Functionality to apply formatting to a given project.

Functional hierarchical zipper, with navigation, editing,
and enumeration.  See Huet

Tools for working with command line arguments.

Standalone auto-complete library based on cljs analyzer state

Utilities for parsing and storing the current completion context.

Core namespace. Most interactions with Compliment should happen
through functions defined here.

Tools for defining sources for the completion.

Completion for both static and non-static class members.

Completion for keywords interned globally across the application

Completion source for local bindings introduced by defn, let and the like.

Completion for namespace and class names.

Completion for vars and classes in the current namespace.

Completion for bundled resource files.

Completion for Clojure's special forms.

Functions and utilities for source implementations.

An implementation of the confluently persistent vector data
structure introduced in Bagwell, Rompf, "RRB-Trees: Efficient
Immutable Vectors", EPFL-REPORT-169879, September, 2011.

RRB-Trees build upon Clojure's PersistentVectors, adding logarithmic
time concatenation and slicing.

The main API entry points are cider.inlined-deps.fipp.v0v6v13.corerrb-vector.v0v0v12.clojure.core.rrb-vector/catvec,
performing vector concatenation, and cider.inlined-deps.fipp.v0v6v13.corerrb-vector.v0v0v12.clojure.core.rrb-vector/subvec,
which produces a new vector containing the appropriate subrange of
the input vector (in contrast to clojure.core/subvec, which returns
a view on the input vector).

core.rrb-vector's vectors can store objects or unboxed primitives.
The implementation allows for seamless interoperability with
clojure.lang.PersistentVector, clojure.core.Vec (more commonly known
as gvec) and clojure.lang.APersistentVector$SubVector instances:
cider.inlined-deps.fipp.v0v6v13.corerrb-vector.v0v0v12.clojure.core.rrb-vector/catvec and cider.inlined-deps.fipp.v0v6v13.corerrb-vector.v0v0v12.clojure.core.rrb-vector/subvec
convert their inputs to cider.inlined-deps.fipp.v0v6v13.corerrb-vector.v0v0v12.clojure.core.rrb-vector.rrbt.Vector
instances whenever necessary (this is a very fast constant time
operation for PersistentVector and gvec; for SubVector it is O(log
n), where n is the size of the underlying vector).

cider.inlined-deps.fipp.v0v6v13.corerrb-vector.v0v0v12.clojure.core.rrb-vector also exports its own versions of vector and
vector-of and vec which always produce
cider.inlined-deps.fipp.v0v6v13.corerrb-vector.v0v0v12.clojure.core.rrb-vector.rrbt.Vector instances. Note that vector-of
accepts :object as one of the possible type arguments, in addition
to keywords naming primitive types.

Provides a pretty document serializer and pprint fn for Clojure code.
See cider.inlined-deps.fipp.v0v6v13.fipp.edn for pretty printing Clojure/EDN data structures

Double-sided queue built on rrb vectors.

Provides a pretty document serializer and pprint fn for Clojure/EDN forms.
See cider.inlined-deps.fipp.v0v6v13.fipp.clojure for pretty printing Clojure code.

See: Oleg Kiselyov, Simon Peyton-Jones, and Amr Sabry
Lazy v. Yield: Incremental, Linear Pretty-printing

Convert to and visit edn structures.

Utilities for dealing with the JVM's classpath

Provides default DynamicClasspath implementations for DynamicClassLoader and URLClassLoader.

Provides the implementation of the DynamicClasspath protocol.

Abstracts the getURLs and addURL functionality of URLClassLoader to a protocol.

Search symbols and docs matching a regular expression

A simple wrapper around `cider.inlined-deps.javaclasspath.v0v3v0.clojure.java.classpath` that is Boot-aware.

Some helper functions to support eldoc-like functionality
in editors.

Clojure data structure inspection functionality.
This code has a long history and at various points of
time it lived in different projects. Originally
it was part of swank-clojure, afterwards it was moved to
javert, then forked to another project from which it
was contributed to cider-nrepl. Finally cider-nrepl
was split into two libraries and the code ended up here.

Pretty wild, right?

Info for Java classes and members

Source and docstring info for Java classes and members

Utility functions for extracting and manipulating metadata.

Utilities for resolving and loading namespaces

Query for namespaces and vars

(require '[cider.inlined-deps.profile.v0v5v2.profile.core :refer :all])
(defn my-add [a b] (+ a b))
(defn my-mult [a b] (* a b))

(profile-vars my-add my-mult)

(profile {}
 (my-add (my-mult (rand-int 100000) (rand-int 1000000))
         (my-mult (rand-int 100000) (rand-int 1000000))))

|          :name | :n | :sum | :q1 | :med | :q3 | :sd | :mad |
|----------------+----+------+-----+------+-----+-----+------|
|  #'user/my-add |  1 |  2µs | 2µs |  2µs | 2µs | 0µs |  0µs |
| #'user/my-mult |  2 | 11µs | 3µs |  8µs | 3µs | 3µs |  5µs |

A Clojure library for profiling.

## Example

```clojure
(require '[cider.inlined-deps.profile.v0v5v2.profile.core :refer :all])
(defn my-add [a b] (+ a b))
(defn my-mult [a b] (* a b))

(profile-vars my-add my-mult)

(profile {}
 (my-add (my-mult (rand-int 100000) (rand-int 1000000))
         (my-mult (rand-int 100000) (rand-int 1000000))))
```

`profile` prints output to `*err*` using `pprint/print-table`; it
looks like this:

```
|          :name | :n | :sum | :q1 | :med | :q3 | :sd | :mad |
|----------------+----+------+-----+------+-----+-----+------|
|  #'user/my-add |  1 |  2µs | 2µs |  2µs | 2µs | 0µs |  0µs |
| #'user/my-mult |  2 | 11µs | 3µs |  8µs | 3µs | 3µs |  5µs |
```

This namespace provides a total-ordering comparator for Clojure values.

Coloring multimethods to format text by adding markup.

#### Color Options

`:print-color`

When true, ouptut colored text from print functions.

`:color-markup`

- `:ansi` for color terminal text (default)
- `:html-inline` for inline-styled html
- `:html-classes` for html with semantic classes

`:color-scheme`

Map of syntax element keywords to color codes.

Coloring implementation that applies ANSI color codes to text designed to be
output to a terminal.

Use with a `:color-markup` of `:ansi`.

Coloring implementation that wraps text in HTML tags to apply color.

Supports the following modes for `:color-markup`:

- `:html-inline` applies inline `style` attributes to the tags.
- `:html-classes` adds semantic `class` attributes to the tags.

Dispatch functions take a `Class` argument and return the looked-up value.
This provides similar functionality to Clojure's protocols, but operates over
locally-constructed logic rather than using a global dispatch table.

A simple example is a map from classes to values, which can be used directly
as a lookup function.

Enhanced printing functions for rendering Clojure values. The following
options are available to control the printer:

#### General Rendering

`:width`

Number of characters to try to wrap pretty-printed forms at.

`:print-meta`

If true, metadata will be printed before values. Defaults to the value of
`*print-meta*` if unset.

#### Collection Options

`:sort-keys`

Print maps and sets with ordered keys. Defaults to true, which will sort all
collections. If a number, counted collections will be sorted up to the set
size. Otherwise, collections are not sorted before printing.

`:map-delimiter`

The text placed between key-value pairs in a map.

`:map-coll-separator`

The text placed between a map key and a collection value. The keyword :line
will cause line breaks if the whole map does not fit on a single line.

`:seq-limit`

If set to a positive number, then lists will only render at most the first n
elements. This can help prevent unintentional realization of infinite lazy
sequences.

#### Color Options

`:print-color`

When true, ouptut colored text from print functions.

`:color-markup`

:ansi for ANSI color text (the default),
:html-inline for inline-styled html,
:html-classes to use the names of the keys in the :color-scheme map
as class names for spans so styling can be specified via CSS.

`:color-scheme`

Map of syntax element keywords to color codes.

#### Type Handling

`:print-handlers`

A lookup function which will return a rendering function for a given class
type. This will be tried before the built-in type logic. See the
`cider.inlined-deps.puget.v1v0v2.puget.dispatch` namespace for some helpful constructors. The returned
function should accept the current printer and the value to be rendered,
returning a format document.

`:print-fallback`

Keyword argument specifying how to format unknown values. Puget supports a few
different options:

- `:pretty` renders values with the default colored representation.
- `:print` defers to the standard print method by rendering unknown values
  using `pr-str`.
- `:error` will throw an exception when types with no defined handler are
  encountered.
- A function value will be called with the current printer options and the
  unknown value and is expected to return a formatting document representing
  it.

This namespace is DEPRECATED; most functions have been moved to
other namespaces

Bidirectional graphs of dependencies and dependent objects.

Track namespace dependencies and changes by monitoring
file-modification timestamps

Read and track namespace information from files

Search for namespace declarations in directories and JAR files.

Refactoring tool to move a Clojure namespace from one name/file to
another, and update all references to that namespace in your other
Clojure source files.

WARNING: This code is ALPHA and subject to change. It also modifies
and deletes your source files! Make sure you have a backup or
version control.

Parse Clojure namespace (ns) declarations and extract
dependencies.

Force reloading namespaces on demand or through a
dependency tracker

REPL utilities for working with namespaces

Dependency tracker which can compute which namespaces need to be
reloaded after files have changed. This is the low-level
implementation that requires you to find the namespace dependencies
yourself: most uses will interact with the wrappers in
cider.inlined-deps.toolsnamespace.v0v3v0-alpha4.clojure.tools.namespace.file and cider.inlined-deps.toolsnamespace.v0v3v0-alpha4.clojure.tools.namespace.dir or the
public API in cider.inlined-deps.toolsnamespace.v0v3v0-alpha4.clojure.tools.namespace.repl.

A clojure reader in clojure

An EDN reader in clojure

Protocols and default Reader types implementation

This file defines simple tracing macros to help you see what your code is doing.