anchor.diff:  
   Then just refer to your dependencies as usual in the `:deps`.
   
  -==== Maven S3 repos
  +=== Maven S3 repos
   
   The tools also provide support for connecting to public and private S3 Maven repositories.
   
  
positive.code: 
  This mechanism is used by repositories that authenticate using a token, rather than by username and password.
  
  ==== Git configuration
  
  The supported git url protocols are https and ssh. https repos will be accessed anonymously and require no additional authentication information. This approach is recommended for public repos.
  
  
negative.code: 
  Key/value pairs are read as edn strings. A general rule is that you can surround edn data with single quotes `'data'` to get a literal string (which exec will read as edn data). In some cases (particularly numbers and keywords), you can omit the single quotes as bash does not have any conflicting interpretation.
  
  Note that strings must be passed in double quotes, also surrounded by single quotes to escape correctly with bash: `clj -X:my-fn :config '"foo"'`.
  
  == Running a main or script
  
  In other cases, the Clojure tools will invoke clojure.main to run either a namespace with a `-main` function or load a Clojure script.
  
  See the <<repl_and_main#,clojure.main>> documentation for more details.
  
  = Operation
  
  When you execute the Clojure tool, there are a series of steps performed to prepare and execute your command. This section is an overview of those steps, see the next section for how to modify those steps in a variety of ways.
  
  == Locate deps.edn sources
  
  Configuration is stored in one or more "deps.edn" maps. These are edn maps with the following top-level keys:
  
  * `:deps` - map of lib (symbol) to coordinate
  * `:paths` - vector of paths
  * `:aliases` - map of alias name to alias data
  * provider-specific keys for configuring dependency sources
  
  The Clojure tools look for 4 potential deps.edn sources:
  
  * Root - found in the installation of clj (or as a resource in tools.deps)
  * User - cross-project configuration (typically tools), usually found at `~/.clojure/deps.edn`
  * Project - the `deps.edn` in the current directory
  * Config data - a `deps.edn` map passed on the command line
  
  == Check cache
  
  The next several steps of this execution can be skipped if we have already computed the classpath and cached it. Classpath and the runtime basis files are cached in the current directory under `.cpcache/`. The key is based on the contents of the deps.edn files and some of the command arguments passed and several files will be cached, most importantly the classpath and runtime basis.
  
  If the key is found, and the cached files are newer than all deps.edn sources, they will be used and execution begins immediately.
  
  == Replace project environment ("tool")
  
  When you execute a tool in the context of your project, the tool uses its own paths and/or deps in place of the project's paths and/or deps.
  
  == Merge sources
  
  All deps.edn sources are merged into a single master edn file in the order listed above - root, user, project (possibly with tool replacements), config. This merged deps will be included in the runtime basis and used after this point.
  
  deps.edn sources is essentially `merge-with merge`, except for the `:paths` key, where only the last :paths found is used (they replace, not combine).
  
  == Resolve dependencies
  
  Starting from the master edn's merged :deps, the full transitive expansion of the dependency tree is computed. Dependency sources (procurers) are used to obtain metadata and other dependency information. At the completion of this step, all libraries to use in the execution have been found and downloaded to local files if needed.
  
  == Make classpath
  
  JVM execution relies on computing the classpath for the execution. The classpath will consist of the :paths in the merged deps.edn and the locations of all resolved dependencies.
  
  == Prepare JVM environment
  
  JVM arguments may either be passed on the command line (with `-J`) or by using data stored in an alias under `:jvm-opts` and passed with `-O` or `-A`
  
  == Execute command
  
  Finally the command is executed - see the Overview above for the execution options. The already computed (or loaded from cache) classpath, JVM environment, and main arguments if relevant are used in the execution. 
  
  = deps.edn
  
  The configuration file format (in "deps.edn" files) is an edn map with top-level keys for `:deps`, `:paths`, and `:aliases`, plus provider-specific keys for configuring dependency sources.
  
  == Paths
  
  Paths are declared in a top level key `:paths` and are a vector of string paths or alias names. Relative paths are resolved in relation to the directory containing the deps.edn (the project root). These source paths will be added to the classpath.
  
  Example:
  
  [source,clojure]
  ----
  {:paths ["src"]}
  ----
  
  If used, alias names should refer to a path vector in the alias data:
  
  [source,clojure]
  ----
  {:paths [:clj-paths :resource-paths]
   :aliases
   {:clj-paths ["src/clj" "src/cljc"]
    :resource-paths ["resources"]}}
  ----
  
  == Dependencies
  
  Dependencies are declared in deps.edn with a top level key `:deps` - a map from library to coordinate. Libraries are symbols of the form `<groupID>/<artifactId>`. To indicate a Maven classifier, use `<groupId>/<artifactId>$<classifier>`.
  
  Coordinates can take several forms depending on the coordinate type:
  
  * Maven coordinate: `{:mvn/version "1.2.3"}`
  ** Other optional keys: `:exclusions`
  ** Note: `:classifier` is not supported - add to lib name as specified above
  * Local project coordinate: `{:local/root "/path/to/project"}`
  ** Optional key `:deps/manifest`
  *** Specifies the project manifest type
  *** Default is to auto-detect the project type (currently either `:deps` or `:pom`)
  * Local jar coordinate: `{:local/root "/path/to/file.jar"}`
  ** If the jar includes a pom.xml file, it will be used to find transitive deps
  * Git coordinate: `{:git/url "https://github.com/user/project.git", :sha "sha", :tag "tag"}`
  ** Required key `:git/url` can be one of the following:
  *** https - secure anonymous access to public repos
  