Provides a simple way to setup the CIDER nREPL middleware in
Leiningen projects.

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.

Search symbols and docs matching a regular expression

Rich content handling for CIDER.
Mostly derived from the pprint middleware.

---

In the long ago, @technomancy [1] talked about his vision for using
nREPL to support multimedia results beyond plain text, ala DrRacket
and other "rich" REPLs. There was an initial cut at this [2],
which never became part of the mainline Emacs tooling.

The goal of this module is to provide some support for recognizing
multimedia objects (images and URIs thereto) as the result of
evaluation, so that they can be rendered by a REPL.

The design of this module is based heavily on RFC-2045 [3] which
describes messages packaged with `Content-Type`,
`Content-Transfer-Encoding` and of course a body in that it seeks to
provide decorated responses which contain metadata which a client
can use to provide a rich interpretation.

There's also RFC-2017 [4] which defines the `message/external-body`
MIME type for defining messages which don't contain their own
bodies.

The basic architecture of this changeset is that eval results are
inspected, and matched against two fundamental supported cases. One
is that the value is actually a binary Java image, which can be MIME
encoded and transmitted back directly. The other is that the object
is some variant of a URI (such as a file naming an image or other
content) which cannot be directly serialized. In this second case we
send an RFC-2017 response which provides the URL from which a client
could request the nREPL server slurp the desired content.

Hence the slurp middleware which slurps URLs and produces MIME coded
data.

---

[1] https://groups.google.com/forum/#!topic/clojure-tools/rkmJ-5086RY
[2] https://github.com/technomancy/nrepl-discover/blob/master/src/nrepl/discover/samples.clj#L135
[3] https://tools.ietf.org/html/rfc2045
[4] https://tools.ietf.org/html/rfc2017

Expression-based debugger for clojure code

Instrument user code to "light up" when it runs.
The instrumented code will report the value of local variables and
report its return value.
Implemented as an extension of the debugger.

Code and EDN formatting functionality.

Macroexpansion middleware.

Change *out*, *err*, System/out and System/err to print on sessions
in addition to process out.

Automatically changes the root binding of all output channels to
print to any active sessions. An active session is one that has sent
at least one "eval" op.

We use an eval message, instead of the clone op, because there's no
guarantee that the channel that sent the clone message will properly
handle output replies.

This profiler is intended for interactive profiling applications where you do
not expect a profiling tool to automatically compensate for JVM
warm-up and garbage collection issues. If you are doing numeric
computing or writing other purely functional code that can be
executed repeatedly without unpleasant side effects, I recommend you
at the very least check out Criterium.

If you are primarily concerned about the influence of JVM-exogenous
factors on your code—HTTP requests, SQL queries, other network-
or (possibly) filesystem-accessing operations—then this package may
be just what the doctor ordered.

Based on older middleware (nrepl-profile) that's not actively
maintained anymore.

Rich reading & handling for CIDER.

Goes with middleware.content-types, providing the capability to
convert URLs to values which can be handled nicely.

Cause and stacktrace analysis for exceptions

Test execution, reporting, and inspection

Extensions to `clojure.test` functionality.

These are kept in a separate namespace because they are, by definition,
opinionated.

State tracker for client sessions.

Undefine a symbol

Coercion utilities for coercing bencoded maps.

Utilities to safely reply to op requests and help deal with the
errors/exceptions that might arise from doing so.

Generic instrumentation for clojure code

Utility functions for extracting and manipulating metadata.

Common utilities for interaction with the client.

Return version info of the CIDER-nREPL middleware itself.

Extending `print-method` defined in clojure.core, to provide
prettier versions of some objects. This applies to anything that
calls `print-method`, which includes return values, `pr`, `print`
and the likes.