anchor.diff:  :parallel-build true
   ----
   
  -[[watch-fn]]
  -=== :watch-fn
  -
  -Is a function that will be called after a successful build.
  -
  -*Only available for `cljs.build.api/watch`*
  -
  -[source,clojure]
  -----
  -:watch-fn (fn [] (println "Updated build"))
  +[[preamble]]
  +=== :preamble
  +
  +Prepends the contents of the given files to each output file.  Files
  +should reside on the classpath. Only valid with optimizations other
  +than `:none`.
  +
  +Defaults to the empty vector `[]`
  +
  +[source,clojure]
  +----
  +:preamble ["license.js"]
  +----
  +
  +[[print-input-delimiter]]
  +=== :print-input-delimiter
  +
  +Determines whether comments will be output in the JavaScript that can be
  +used to determine the original source of the compiled code.
  +
  +Defaults to false.
  +
  +[source,clojure]
  +----
  +:print-input-delimiter false
   ----
   
   [[process-shim]]
  
positive.code: [[externs]]
  === :externs
  
  Configure externs files for external libraries. The files are searched for in the current working directory and on the classpath.
  
  For this option, and those below, you can find a very good explanation
  at:
  
negative.code: :cache-analysis true
  ----
  
  [[closure-defines]]
  === :closure-defines
  
  Set the values of Closure libraries' variables annotated with
  https://developers.google.com/closure/compiler/docs/js-for-compiler#tag-define[@define]
  or with the `cljs.core/goog-define` helper macro. A common usage is
  setting `goog.DEBUG` to false:
  
  [source,clojure]
  ----
  :closure-defines {"goog.DEBUG" false}
  ----
  
  You can also use symbols:
  
  [source,clojure]
  ----
  :closure-defines {my.cool-ns/some-def true}
  ----
  
  Note when using Lein the quote is unnecessary due to implicit quoting.
  
  [NOTE]
  ====
  For `:optimizations :none`, a `:main` option must be specified for
  defines to work, and only `goog-define` defines are affected.
  `:closure-defines` currently does not have any effect with
  `:optimizations :whitespace`.
  ====
  
  You can use the variables set in `:closure-defines` to eliminate parts
  of your code at compile time (DCE). However, to do so you must use `if`
  or `cond` in combination with an `identical?` comparison. Any other
  forms (such as `case` or `condp`) will work correctly at runtime, but
  the javascript output will contain the dead code branches.
  
  For example, if you want to make a localized build of your application
  which only contains the translation messages relevant for the locale:
  
  [source,clojure]
  ----
  (def messages
    (cond
      (identical? js/goog.LOCALE "nl") i18n.nl/messages
      (identical? js/goog.LOCALE "fr") i18n.fr/messages
      :else i18n.en/messages))
  ----
  
  [[closure-extra-annotations]]
  === :closure-extra-annotations
  
  Define extra JSDoc annotations that a closure library might use so that
  they don't trigger compiler warnings.
  
  [source,clojure]
  ----
  :closure-extra-annotations #{"api"}
  ----
  
  [[closure-output-charset]]
  