Repository: nvim-treesitter/nvim-tree-docs
Branch: master
Commit: 5db023d783da
Files: 54
Total size: 353.9 KB

Directory structure:
gitextract_uscgubcz/

├── .gitignore
├── Makefile
├── README.md
├── fnl/
│   └── nvim-tree-docs/
│       ├── collector.fnl
│       ├── editing.fnl
│       ├── internal.fnl
│       ├── macros.fnl
│       ├── main.fnl
│       ├── specs/
│       │   ├── base/
│       │   │   └── base.fnl
│       │   ├── javascript/
│       │   │   └── jsdoc.fnl
│       │   ├── lua/
│       │   │   └── luadoc.fnl
│       │   └── typescript/
│       │       └── tsdoc.fnl
│       ├── template.fnl
│       └── utils.fnl
├── lua/
│   └── nvim-tree-docs/
│       ├── aniseed/
│       │   ├── autoload.lua
│       │   ├── compile.lua
│       │   ├── core.lua
│       │   ├── deps/
│       │   │   ├── fennel.lua
│       │   │   ├── fennelview.lua
│       │   │   └── nvim.lua
│       │   ├── env.lua
│       │   ├── eval.lua
│       │   ├── fennel.lua
│       │   ├── fs.lua
│       │   ├── macros.fnl
│       │   ├── nvim/
│       │   │   └── util.lua
│       │   ├── nvim.lua
│       │   ├── string.lua
│       │   ├── test.lua
│       │   └── view.lua
│       ├── collector.lua
│       ├── editing.lua
│       ├── internal.lua
│       ├── macros.fnl
│       ├── main.lua
│       ├── specs/
│       │   ├── base/
│       │   │   └── base.lua
│       │   ├── javascript/
│       │   │   └── jsdoc.lua
│       │   ├── lua/
│       │   │   └── luadoc.lua
│       │   └── typescript/
│       │       └── tsdoc.lua
│       ├── template.lua
│       └── utils.lua
├── plugin/
│   └── nvim-tree-docs.vim
├── queries/
│   ├── ecma/
│   │   └── docs.scm
│   ├── javascript/
│   │   └── docs.scm
│   ├── javascriptreact/
│   │   └── docs.scm
│   ├── jsdoc/
│   │   └── edits.scm
│   ├── jsx/
│   │   └── docs.scm
│   ├── lua/
│   │   └── docs.scm
│   ├── python/
│   │   └── docs.scm
│   ├── tsx/
│   │   └── docs.scm
│   ├── typescript/
│   │   └── docs.scm
│   └── typescriptreact/
│       └── docs.scm
├── scripts/
│   └── dep.sh
└── test/
    └── fnl/
        └── example/
            └── main-test.fnl

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
/deps/
/test/results.txt
/test/lua/
/doc/tags


================================================
FILE: Makefile
================================================
.PHONY: deps compile test

default: deps compile test

deps:
	scripts/dep.sh Olical aniseed origin/master

compile:
	rm -rf lua
	deps/aniseed/scripts/compile.sh
	## Uncomment and set CHANGEME to your project prefix if you need access to
	## Aniseed at runtime, instead of just compile time.
	## If your project modules are like myplugin.some-thing, you'd use myplugin
	## in place of CHANGEME.
	deps/aniseed/scripts/embed.sh aniseed nvim-tree-docs

test:
	rm -rf test/lua
	deps/aniseed/scripts/test.sh


================================================
FILE: README.md
================================================
nvim-tree-docs
==============

Highly configurable documentation generator using treesitter.

This plugin is experimental!

## Setup

nvim-tree-docs is a module for the `nvim-treesitter` plugin. You can install both by doing (vim-plug):

```vim
Plug 'nvim-treesitter/nvim-treesitter'
Plug 'nvim-treesitter/nvim-tree-docs'
```

You can configure `nvim-tree-docs` as part of your `nvim-treesitter` configuration.

```lua
require "nvim-treesitter.configs".setup {
  tree_docs = {enable = true}
}
```

## Usage

There are two key bindings provided by default:

- `doc_node_at_cursor`: `gdd`
- `doc_all_in_range`: `gdd` (Visual)

These can be configured through the `keymap` option in the config.

## Advanced configuration

This plugin is extremely configurable. Most documentation is standardized, but our
projects and personal preferences for documentation vary. This plugin aims to add total
customization to the user.

### Core concepts

There three key components to how this plugin operates.

- `processors` -> Processors generate lines of content within a template.
- `slots` -> Slots are positions where a processor can output it's content.
- `templates` -> Templates are a list of slots, basically the ordering of processors.
                 These are by `kind` (Ex: function).
- `specs` -> Specs are a collection of templates and processors (Ex: jsdoc).

### Basic example

Here is a basic example of how this works (psuedo code).

```lua
local processors = {
  my_processor = function() -- The processor
    return "Output!!!"
  end
}

local template = { -- template
  "my_processor", -- slot
  "my_processor"  -- slot
}
```

This example would generate the lines

```
Output!!!
Output!!!
```

You get the idea... The above code doesn't actually do anything, but is just to illustrate the point.

### Configuring slots

The key advantage is they can be toggled on and off.
For example, lets say you like to include an `@author` tag on all your jsdoc classes.
You can enable the `author` slot to generate an author tag.
This is done in the configuration for the spec.

```lua
require "nvim-treesitter.configs".setup {
  tree_docs = {
    enable = true,
    spec_config = {
      jsdoc = {
        slots = {
          class = {author = true}
        }
      }
    }
  }
}
```

This will generate the following output.

```javascript
/**
 * The person class
 * @author
 */
class Person {}
```

Pretty cool... but this is using the default processor for the spec, which in the case
of jsdoc, just generates a tag. What if we could modify the behavior of that processor?
We can configure author processor in the same config.

```lua
require "nvim-treesitter.configs".setup {
  tree_docs = {
    enable = true,
    spec_config = {
      jsdoc = {
        slots = {
          class = {author = true}
        },
        processors = {
          author = function()
            return " * @author Steven Sojka"
          end
        }
      }
    }
  }
}
```

This will generate.

```javascript
/**
 * The person class
 * @author Steven Sojka
 */
class Person {}
```

Processors can return a single line or multiple lines.
Here's an advanced sample that will prompt the user for
an issue ticket number. If the user doesn't enter anything
the tag won't get generated.

```lua
require "nvim-treesitter.configs".setup {
  tree_docs = {
    enable = true,
    spec_config = {
      jsdoc = {
        slots = {
          class = {see = true, author = true}
        },
        processors = {
          author = function() return " * @author Steven Sojka" end
          see = function()
            local ticket = vim.fn.input("Ticket: ")
            return ticket ~= "" and (" * @see " .. ticket) or []
          end
        }
      }
    }
  }
}
```

This will result in the following (assuming PROJ-X-123456 was inputted).

```javascript
/**
 * The person class
 * @author Steven Sojka
 * @see PROJ-X-123456
 */
class Person {}
```

### Configuring templates

Templates aren't traditional templates. It's basically just a set of slots in a specific order.
You can configure the template in the config.

```lua
require "nvim-treesitter.configs".setup {
  tree_docs = {
    enable = true,
    spec_config = {
      jsdoc = {
        slots = {
          class = {custom = true, author = true}
        },
        templates = {
          class = {
            "doc-start" -- Note, these are implicit slots and can't be turned off and vary between specs.
            "custom"
            "author"
            "doc-end"
            "%content%"
          }
        }
      }
    }
  }
}
```

This will generate.

```javascript
/**
 * The person class
 * @custom
 * @author
 */
class Person {}
```

Note, in the above example, if we would have left out the `custom` slot in the template, it would not have output anything.


#### Builtin processors

There are some builtin processors that work across all specs (unless overridden, which is possible).

- `%content%` -> This will output the content line, in our case above it would be the class declaration line.
                 This makes it possible to wrap or put the documentation below the content line.
- `%rest%` -> This will output all slots that are enabled, but do not have an explicit slot in the template.

### Template context

This still needs to be documented...

## Writing language queries

Queries contain a couple conventions that are shared amongst all languages.

Query tag syntax is `@<kind>.<property>`

The `<kind>` tag corresponds with a template in the language specific template file.
Properties can be accessed within a processor as the first argument.

For example, a simple processor that gets the name of a nod

```lua
function(ctx) return ctx.get_text(ctx.name.node) end
```

This would correspond to a tag `@<kind>.name`.

Properties are not predefined and can differ from language to language, but there a couple
that have special behavior.

### `@<kind>.definition`

This is the most important one and is required for each `<kind>`.
This defines the node that defines the `<kind>`. If multiple queries
match the same definition node, those entries will be merged together.
This is very important for function parameters where multiple matches
need to be grouped under the same function definition.

For example, that this javascript query.

```scheme
(function_declaration
  name: (identifier) @function.name
  body: (statement_block
    (return_statement)? @function.return)) @function.definition

(export_statement
  (function_declaration) @function.definition) @function.export
```

This will match both these functions.

```javascript
function test() {}

export function test() {}
```

The key difference is one will have an `export` node associated with it. Both queries
match the function that is exported but they get merged into a single data model
because both `@function.definition` tags match the same node at the same position.

### `@<kind>.<kind>.definition`

Kind queries can be nested to define multiple different node merge points. This can be done
by providing multiple, nested definition tags. For example in function parameters. A nested `<kind>`
can be thought of as a list of similiar items.

### `@<kind>.start_point`

When docs are inserted into the document, it will insert the docs at the indentation and position
of the definition node (`@<kind>.definition`). This can be changed, if you need to keep the same definition
node, but need a different start point to insert.

For example, that this javascript query.

```scheme
(function_declaration
  name: (identifier) @function.name
  body: (statement_block
    (return_statement)? @function.return_statement)) @function.definition

(export_statement
  (function_declaration) @function.definition) @function.start_point @function.export
```

If we doc'ed the following functions WITHOUT the root tag, we would get this:

```javascript
/**
 * test
 */
function test() {}

       /**
        * test
        */
export function test() {}
```

Including the start_point tag flags the export_statement node as the root node INSTEAD of the definition node.

### `@<kind>.end_point`

This flags the end node that document can be triggered from. For example, the end of a function signature.
This is important, because it allows us to trigger docs on a multiline signature.

For example, that this javascript query.

```scheme
(
  (comment)+? @function.doc
  (function_declaration
    name: (identifier) @function.name
    parameters: (formal_parameters) @function.end_point
    body: (statement_block
      (return_statement)? @function.return)) @function.definition
)
```

This flags the parameters node as the end node for the signature. This allows us
to doc signatures that look like this.

```javascript
function test(
  someVeryLongNameThatRequiresUsToWrap,
  blorg, // <- We can trigger here to generate docs with no problem
  boom
) {
  return;
}
```

The furtherest end node will be used if there are overlapping end_points.
You should always have an end_point defined in order to avoid unwanted document triggers.

### `@<kind>.doc`

The doc references the current doc that is preceding the definition node. This gives access to existing
documentation to either parse, update, or remove with updated information.

# Roadmap

- Filetype aliases
- Template marks
- More doc specs
- Doc commands that don't require a treesitter node (jsdoc modules)
- Predifined processors that can be swapped in... (think promptable descriptions?)


================================================
FILE: fnl/nvim-tree-docs/collector.fnl
================================================
(module nvim-tree-docs.collector
  {autoload {core nvim-tree-docs.aniseed.core}})

(def- collector-metatable
  {:__index (fn [tbl key]
              (if (= (type key) :number)
                (let [id (. tbl.__order key)]
                  (if id (. tbl.__entries id) nil))
                (rawget tbl key)))})

(defn new-collector []
  (setmetatable {:__entries {}
                 :__order {}}
                collector-metatable))

(defn is-collector [value]
  (and (= (type value) :table)
       (= (type value.__entries) :table)))

(defn is-collector-empty [collector]
  (= (length collector.__order) 0))

(defn iterate-collector [collector]
  (var i 1)
  (fn []
    (let [id (. collector.__order i)]
      (if id
          (do
            (set i (+ i 1))
            {:index (- i 1)
             :entry (. collector.__entries id)})
          nil))))

(defn get-node-id [node]
  (let [(srow scol erow ecol) (node:range)]
    (string.format "%d_%d_%d_%d" srow scol erow ecol)))

(defn collect_ [collector entry _match key add-fn]
  (if _match.definition
    (do
      (when (not (. entry key))
        (tset entry key (new-collector)))
      (-> (. entry key)
          (add-fn key _match collect)))
    (not (. entry key))
    (tset entry key _match)
    (and (= key :start_point) _match.node)
    (let [(_ _ current-start) (-> (. entry key) (. :node) (: :start))
          (_ _ new-start) (-> (. _match :node) (: :start))]
      (when (< new-start current-start)
        (tset entry key _match)))
    (and (= key :end_point) _match.node)
    (let [(_ _ current-end) (-> (. entry key) (. :node) (: :end_))
          (_ _ new-end) (-> (. _match :node) (: :end_))]
      (when (> new-end current-end)
        (tset entry key _match)))))

(defn add-match [collector kind _match]
  (if (and _match _match.definition)
    (let [_def _match.definition
          def-node _def.node
          node-id (get-node-id def-node)]
      (when (not (. collector.__entries node-id))
        (var order-index 1)
        (let [(_ _ def-start-byte) (def-node:start)
              entry-keys (core.keys collector.__entries)]
          (var done false)
          (var i 1)
          (while (not done)
            (local entry (-?>> (. entry-keys i)
                               (. collector.__entries)))
            (if (not entry)
              (set done true)
              (let [(_ _ start-byte) (entry.definition.node:start)]
                (if (< def-start-byte start-byte)
                  (set done true)
                  (do
                    (set order-index (+ order-index 1))
                    (set i (+ i 1)))))))
          (table.insert collector.__order order-index node-id)
          (tset collector.__entries node-id {:kind kind :definition _def})))
      (each [key submatch (pairs _match)]
        (when (not= key :definition)
          (collect_ collector (. collector.__entries node-id) submatch key add-match))))))



================================================
FILE: fnl/nvim-tree-docs/editing.fnl
================================================
(module nvim-tree-docs.editing
  {autoload {ts-utils nvim-treesitter.ts_utils
             tsq vim.treesitter.query}})

(def- ns (vim.api.nvim_create_namespace "doc-edit"))

(defn get-doc-comment-data [args]
  (let [{: lang
         : doc-lang
         : node
         : bufnr} args
        doc-lines (ts-utils.get_node_text node bufnr)
        doc-string (table.concat doc-lines "\n")
        parser (vim.treesitter.get_string_parser doc-string doc-lang)
        query (tsq.get_query doc-lang :edits)
        iter (query:iter_matches
               (-> (parser:parse) (: :root))
               doc-string
               1
               (+ (length doc-string) 1))
        result {}]
    (var item [(iter)])
    (while (. item 1)
      (let [[pattern-id matches] item]
        (each [id match-node (pairs matches)]
          (let [match-name (. query.captures id)]
            (when (not (. result match-name))
              (tset result match-name []))
            (table.insert (. result match-name) match-node)))
        (set item [(iter)])))
    result))

(defn edit-doc [args]
  (let [{: bufnr :node doc-node} args
        {: edit} (get-doc-comment-data args)
        (sr) (doc-node:range)]
    (vim.api.nvim_buf_clear_namespace bufnr ns 0 -1)
    (each [_ node (ipairs edit)]
      (let [(dsr dsc der dec) (node:range)]
        (ts-utils.highlight_range
          [(+ dsr sr ) dsc (+ der sr) dec]
          bufnr
          ns
          :Visual)))))


================================================
FILE: fnl/nvim-tree-docs/internal.fnl
================================================
(module nvim-tree-docs.internal
  {autoload {utils nvim-tree-docs.utils
             core nvim-tree-docs.aniseed.core
             templates nvim-tree-docs.template
             collectors nvim-tree-docs.collector
             editing nvim-tree-docs.editing
             configs nvim-treesitter.configs
             queries nvim-treesitter.query
             ts-utils nvim-treesitter.ts_utils}})

(def- language-specs {:javascript :jsdoc
                      :lua :luadoc
                      :typescript :tsdoc})

(def- doc-cache {})

(defn get-spec-for-lang [lang]
  (let [spec (. language-specs lang)]
    (when (not spec)
      (error (string.format "No language spec configured for %s" lang)))
    spec))

(defn get-spec-config [lang spec]
  (let [spec-def (templates.get-spec lang spec)
        module-config (configs.get_module :tree_docs)
        spec-default-config spec-def.config
        lang-config (utils.get [:lang_config lang spec] module-config {})
        spec-config (utils.get [:spec_config spec] module-config {})]
    (vim.tbl_deep_extend :force spec-default-config spec-config lang-config)))

(defn get-spec-for-buf [bufnr?]
  (let [bufnr (or bufnr? (vim.api.nvim_get_current_buf))]
    (get-spec-for-lang (vim.api.nvim_buf_get_option bufnr :ft))))

(defn generate-docs [data-list bufnr? lang?]
  (let [bufnr (utils.get-bufnr bufnr?)
        lang (or lang? (vim.api.nvim_buf_get_option bufnr :ft))
        spec-name (get-spec-for-lang lang)
        spec (templates.get-spec lang spec-name)
        spec-config (get-spec-config lang spec-name)
        edits []
        marks []]
    ; Guarantee that docs are from the top down.
    (table.sort data-list #(let [(_ _ start-byte-a) (utils.get-start-position $1)
                                  (_ _ start-byte-b) (utils.get-start-position $2)]
                                 (< start-byte-a start-byte-b)))
    (var line-offset 0)
    (each [_ doc-data (ipairs data-list)]
      (let [(node-sr node-sc) (utils.get-start-position doc-data)
            (node-er node-ec) (utils.get-end-position doc-data)
            content-lines (utils.get-buf-content node-sr node-sc node-er node-ec bufnr)
            replaced-count (- (+ node-er 1) node-sr)
            result (templates.process-template
                      doc-data
                      {: spec
                       : bufnr
                       :config spec-config
                       :start-line (+ node-sr line-offset)
                       :start-col node-sc
                       :kind doc-data.kind
                       :content content-lines})]
        (table.insert edits {:newText (.. (table.concat result.content "\n") "\n")
                             :range
                              {:start {:line node-sr :character 0}
                               :end {:line (+ node-er 1) :character 0}}})
        (vim.list_extend marks result.marks)
        (set line-offset (- (+ line-offset (length result.content)) replaced-count))))
    (vim.lsp.util.apply_text_edits edits bufnr)))
    ; Uncomment to test marks
    ;(utils.highlight-marks marks bufnr)))

(defn collect-docs [bufnr?]
  (let [bufnr (utils.get-bufnr bufnr?)]
    (if (= (utils.get [bufnr :tick] doc-cache)
           (vim.api.nvim_buf_get_changedtick bufnr))
      (utils.get [bufnr :docs] doc-cache)
      (let [collector (collectors.new-collector)
            doc-matches (queries.collect_group_results bufnr :docs)]
        (each [_ item (ipairs doc-matches)]
          (each [kind _match (pairs item)]
            (collectors.add-match collector kind _match)))
        (tset doc-cache bufnr {:tick (vim.api.nvim_buf_get_changedtick bufnr)
                               :docs collector})
        collector))))

(defn get-doc-data-for-node [node bufnr?]
  (var current nil)
  (var last-start nil)
  (var last-end nil)
  (let [doc-data (collect-docs bufnr?)
        (_ _ node-start) (node:start)]
    (each [iter-item (collectors.iterate-collector doc-data)]
      (var is-more-specific true)
      (let [{:entry doc-def} iter-item
            (_ _ start) (utils.get-start-position doc-def)
            (_ _ end) (utils.get-end-position doc-def)
            is-in-range (and (>= node-start start)
                             (< node-start end))]
        (when (and last-start last-end)
          (set is-more-specific (and (>= start last-start) (<= end last-end))))
        (when (and is-in-range is-more-specific)
          (do
            (set last-start start)
            (set last-end end)
            (set current doc-def)))))
    current))

(defn doc-node [node bufnr? lang?]
  (if node
    (let [doc-data (get-doc-data-for-node node bufnr?)]
      (generate-docs [doc-data] bufnr? lang?))))

(defn doc-node-at-cursor []
  (doc-node (ts-utils.get_node_at_cursor)))

(defn get-docs-from-position [args]
  (let [{: start-line
         : end-line
         : position
         :inclusion inclusion?
         :bufnr bufnr?} args
        is-edit-type? (= position :edit)
        doc-data (collect-docs bufnr?)
        result []]
    (each [item (collectors.iterate-collector doc-data)]
      (let [{:entry _def} item
            start-r (if is-edit-type?
                      (utils.get-edit-start-position _def)
                      (utils.get-start-position _def))
            end-r (if is-edit-type?
                    (utils.get-edit-end-position _def)
                    (utils.get-end-position _def))]
        (when (if inclusion?
                (and (>= start-line start-r) (<= end-line end-r))
                (and (>= start-r start-line) (<= end-r end-line)))
          (table.insert result _def))))
    result))

(defn get-docs-in-range [args]
  (get-docs-from-position (vim.tbl_extend
                            "force"
                            args
                            {:inclusion false :position nil})))

(defn get-docs-at-range [args]
  (get-docs-from-position (vim.tbl_extend
                            "force"
                            args
                            {:inclusion true :position :edit})))

(defn get-docs-from-selection []
  (let [(_ start _ _) (unpack (vim.fn.getpos "'<"))
        (_ end _ _) (unpack (vim.fn.getpos "'>"))]
    (get-docs-in-range {:start-line (- start 1)
                        :end-line (- end 1)})))

(defn doc-all-in-range []
  (-> (get-docs-from-selection)
      (generate-docs)))

(defn edit-doc-at-cursor []
  (let [[row] (vim.api.nvim_win_get_cursor 0)
        doc-data (get-docs-at-range {:start-line (- row 1)
                                     :end-line (- row 1)})
        bufnr (vim.api.nvim_get_current_buf)
        lang (vim.api.nvim_buf_get_option bufnr :ft)
        spec-name (get-spec-for-lang lang)
        spec (templates.get-spec lang spec-name)
        doc-lang spec.doc-lang
        doc-entry (-?> doc-data (. 1) (. :doc))]
    (when (and (core.table? doc-entry) doc-entry.node doc-lang)
      (editing.edit-doc {: lang
                         : spec-name
                         : bufnr
                         : doc-lang
                         :node doc-entry.node}))))

(defn attach [bufnr?]
  (let [bufnr (utils.get-bufnr bufnr?)
        config (configs.get_module :tree_docs)]
    (each [_fn mapping (pairs config.keymaps)]
      (var mode :n)
      (when (= _fn :doc_all_in_range)
        (set mode :v))
      (when mapping
        (vim.api.nvim_buf_set_keymap
          bufnr
          mode
          mapping
          (string.format ":lua require 'nvim-tree-docs.internal'.%s()<CR>" _fn)
          {:silent true})))))

(defn detach [bufnr?]
  (let [bufnr (utils.get-bufnr bufnr?)
        config (configs.get_module :tree_docs)]
    (each [_fn mapping (pairs config.keymaps)]
      (var mode :n)
      (when (= _fn :doc_all_in_range)
        (set mode :v))
      (when mapping
        (vim.api.nvim_buf_del_keymap bufnr mode mapping)))))

; Export these as snake case for configuration purposes.
(def doc_node_at_cursor doc-node-at-cursor)
(def doc_node doc-node)
(def doc_all_in_range doc-all-in-range)
(def edit_doc_at_cursor edit-doc-at-cursor)


================================================
FILE: fnl/nvim-tree-docs/macros.fnl
================================================
(local modsym (gensym))

(fn doc-spec [config]
  "Defines a documentation specification"
  (assert config.lang "A language is required")
  (assert config.spec "A specification name is required")
  `(local ,modsym
     (let [mod-name# (.. ,(tostring config.lang) "." ,(tostring config.spec))
           template-mod# (require "nvim-tree-docs.template")
           module# {:templates {}
                    :utils {}
                    :processors {}
                    :doc-lang ,(tostring config.doc-lang)
                    :config (vim.tbl_deep_extend
                              "force"
                              {:slots {}
                               :processors {}}
                              ,(or config.config {}))
                    :inherits nil
                    :spec ,(tostring config.spec)
                    :lang ,(tostring config.lang)
                    :module mod-name#
                    :__build template-mod#.build-line}]
       (template-mod#.extend-spec module# :base.base)
       (template-mod#.extend-spec module# ,(if config.extends (tostring config.extends) nil))
       (tset (. template-mod# :loaded-specs)
             mod-name#
             module#)
       module#)))

(fn util [name parameters ...]
  "Defines a util function as part of this specification.
  These can be used in templates as well as any specification
  That extends this specification."
  `(tset (. ,modsym :utils) ,(tostring name) (fn ,parameters ,...)))

(fn template [kind ...]
  "Defines a template for a given 'kind'.
  The kind correlates with the query matches."
  (let [slots (let [results []]
                (each [_ slot (ipairs [...])]
                  (table.insert results (tostring slot)))
                results)]
    `(tset (. ,modsym :templates) ,(tostring kind) ,slots)))

(fn %= [key tbl default]
  "Get a nodes text content. A key is provided and will
  access the root context or the provided table."
  `($.get-text (. ,(or tbl `$) ,(tostring key)) ,default))

(fn %- [...]
  "Builds a line of output."
  `((. ,modsym :__build) ,...))

(fn %^ [content kind]
  "Marks content for the builder"
  `{:content ,content :mark ,kind})

(fn %! [content]
  "Marks a tab stop for the builder"
  `{:content ,content :mark :tabstop})

(fn %> [util-name ...]
  "Invokes a util function on this specification.
  This will invoke any inherited utils as well."
  `((. (. ,modsym :utils) ,(tostring util-name)) ,...))

(fn processor [...]
  (let [processor {}
        forms [...]
        has-name (not= (% (length forms) 2) 0)]
    (var hook nil)
    (var callback nil)
    (var name :__default)
    (when has-name
      (do
        (set name (. forms 1))
        (table.remove forms 1)))
    (each [_ form (ipairs forms)]
      (if hook
        (set callback form)
        (set hook (tostring form)))
      (if (and hook callback)
        (do
          (tset processor hook form)
          (set hook nil)
          (set callback nil))))
    `(tset (. ,modsym :processors) ,(tostring name) ,processor)))

(fn post-processor [name bindings ...]
  `(tset (. ,modsym :post-processors) ,name (fn ,bindings ,...)))

(fn log [...]
  `(let [result# ,...]
     (print (vim.inspect result#))
     result#))

{: template
 : util
 : %=
 : %>
 : %-
 : %^
 : %!
 : log
 : post-processor
 : processor
 : doc-spec}


================================================
FILE: fnl/nvim-tree-docs/main.fnl
================================================
(module nvim-tree-docs.main
  {autoload {queries nvim-treesitter.query
             ts nvim-treesitter}})

(defn init []
  (->> {:tree_docs {:module_path "nvim-tree-docs.internal"
                    :keymaps {:doc_node_at_cursor :gdd
                              :doc_all_in_range :gdd
                              :edit_doc_at_cursor :gde}
                    :is_supported #(not= (queries.get_query $1 :docs) nil)}}
       (ts.define_modules)))


================================================
FILE: fnl/nvim-tree-docs/specs/base/base.fnl
================================================
(require-macros "nvim-tree-docs.macros")

(doc-spec
  {:spec base
   :lang base})

(processor %rest%
  implicit true
  expand (fn [slot-indexes slot-config]
           (let [expanded []]
             (each [ps-name enabled (pairs slot-config)]
               (when (and enabled (not (. slot-indexes ps-name)))
                 (table.insert expanded ps-name)))
             expanded)))

(processor %content%
  implicit true
  build #$.content
  indent #0)


================================================
FILE: fnl/nvim-tree-docs/specs/javascript/jsdoc.fnl
================================================
(require-macros "nvim-tree-docs.macros")

(doc-spec
  {:spec jsdoc
   :lang javascript
   :doc-lang jsdoc
   :config {:include_types true
            :empty_line_after_description false
            :slots {:function {:param true
                               :example false
                               :returns true
                               :function true
                               :generator true
                               :template true
                               :yields true
                               :export true}
                    :variable {:type true
                               :export true}
                    :class {:class true
                            :example false
                            :export true
                            :extends true}
                    :member {:memberof true
                             :type true}
                    :method {:memberof true
                             :example false
                             :yields true
                             :generator true
                             :param true
                             :returns true}
                    :module {:module true}}}})

(template function
  doc-start
  description
  function
  generator
  yields
  %rest%
  param
  returns
  example
  doc-end
  %content%)

(template variable
  doc-start
  description
  %rest%
  doc-end
  %content%)

(template method
  doc-start
  description
  memberof
  %rest%
  param
  returns
  example
  doc-end
  %content%)

(template class
  doc-start
  description
  class
  extends
  %rest%
  example
  doc-end
  %content%)

(template member
  doc-start
  description
  memberof
  %rest%
  doc-end
  %content%)

(template module
  doc-start
  description
  module
  %rest%
  doc-end)

(processor doc-start
  implicit true
  build #"/**")

(processor doc-end
  implicit true
  build #" */")

(processor returns
  when #$.return_statement
  build #(let [type-str (%> get-marked-type $ " ")]
           (%- " * @returns" type-str (%! "The result"))))

(processor function
  when #(not $.generator)
  build #(%- " * @function " (%= name)))

(processor module
  build #(let [filename (vim.fn.expand "%:t:r")]
           (%- " * @module " (%! filename))))

(processor template
  when #$.generics
  build #(%> build-generics $ :template))

(processor typeParam
  when #$.generics
  build #(%> build-generics $ :typeParam))

(processor extends
  when #$.extends
  build #(%- " * @extends " (%= extends)))

(processor class
  build #(%- " * @class " (%= name)))

(processor generator
  when #$.generator)

(processor yields
  when #$.yields
  build #(%- " * @yields" (%> get-marked-type $ "")))

(processor description
  implicit true
  build #(let [description (%- " * " (%! (.. "The " (%= name) " " $2.name)))
               {: processors : index} $2
               next-ps (. processors (+ index 1))]
           (if (or (= next-ps :doc-end)
                   (not ($.conf :empty_line_after_description)))
             description
             [description " *"])))

(processor type
  when #$.type
  build #(let [type-str (%> get-marked-type $ " ")]
           (%- " * @type" type-str)))

(processor export
  when #$.export)

(processor param
  when #(and $.parameters
             (not ($.empty? $.parameters)))
  build #(let [result []]
           (each [param ($.iter $.parameters)]
             (let [param-name (%> get-param-name $ param.entry)
                   type-str (%> get-marked-type $ " ")
                   name (%= name param.entry)]
               (table.insert
                 result
                 (%- " * @param"
                     type-str
                     param-name
                     " - "
                     (%! (.. "The " name " param"))))))
           result))

(processor memberof
  when #$.class
  build #(%-  " * @memberof " (%= class)))

(processor
  build #(%- " * @" $2.name))

(util get-param-name [$ param]
  (if param.default_value
    (string.format "%s=%s"
                   ($.get-text param.name)
                   ($.get-text param.default_value))
    ($.get-text param.name)))

(util get-marked-type [$ not-found?]
  (if ($.conf :include_types)
    " {any} "
    (or not-found? "")))

(util build-generics [$ tag]
  (let [result []]
    (each [generic ($.iter $.generics)]
      (let [name (%= name generic.entry)]
        (table.insert result
                      (%- " * @" tag " " name " " (%! (.. "The " name " type"))))))
    result))


================================================
FILE: fnl/nvim-tree-docs/specs/lua/luadoc.fnl
================================================
(require-macros "nvim-tree-docs.macros")

(doc-spec
  {:spec luadoc
   :lang lua
   :config {:slots {:function {:param true
                               :returns true}
                    :variable {}}}})

(template function
  description
  param
  returns)

(template variable
  description)

(processor description
  implicit true
  build #"--- Description")

(processor param
  when #(and $.parameters
             (not ($.empty? $.parameters)))
  build #(let [result []]
           (each [param ($.iter $.parameters)]
             (let [name (%= name param.entry)]
               (table.insert
                 result
                 (.. "-- @param " name " The " name))))
           result))


================================================
FILE: fnl/nvim-tree-docs/specs/typescript/tsdoc.fnl
================================================
(require-macros "nvim-tree-docs.macros")

(doc-spec
  {:spec tsdoc
   :lang typescript
   :extends javascript.jsdoc
   :config {:include_types false
            :empty_line_after_description true
            :slots {:function {:export false
                               :generator false
                               :function false}
                    :variable {:type false
                               :export false}
                    :class {:class false
                            :export false
                            :extends false}
                    :member {:memberof false
                             :type false}
                    :method {:memberof false}}}})


================================================
FILE: fnl/nvim-tree-docs/template.fnl
================================================
(module nvim-tree-docs.template
  {autoload {core nvim-tree-docs.aniseed.core
             utils nvim-tree-docs.utils
             collectors nvim-tree-docs.collector
             ts-utils nvim-treesitter.ts_utils}})

(import-macros {: log} "nvim-tree-docs.macros")

(def loaded-specs {})

(defn get-text [context node default multi]
  (let [default-value (or default "")]
    (if (and node (= (type node) :table))
      (let [tsnode (if node.node node.node node)
            lines (ts-utils.get_node_text tsnode)]
        (if multi
          lines
          (let [line (. lines 1)]
            (if (not= line "") line default-value))))
      default-value)))

(defn iter [collector]
  (if collector (collectors.iterate-collector collector) #nil))

(defn conf [context path default?]
  (utils.get path context.config default?))

(defn empty? [collector]
  (collectors.is-collector-empty collector))

(defn build-line [...]
  "Builds a line of content while capturing any marks that are defined"
  (let [result {:content "" :marks []}
        add-content #(set result.content (.. result.content $))]
    (each [_ value (ipairs [...])]
      (if (core.string? value)
        (add-content value)
        (and (core.table? value) (core.string? value.content))
        (if value.mark
          (let [start (length result.content)]
            (add-content value.content)
            (table.insert result.marks {:kind value.mark
                                        :stop (+ (length value.content) start)
                                        : start}))
          (add-content value.content))))
    result))

(defn new-template-context [collector options?]
  (let [options (or options? {})
        context (vim.tbl_extend
                  "keep"
                  {: iter
                   : empty?
                   :build build-line
                   :config options.config
                   :kind options.kind
                   :start-line (or options.start-line 0)
                   :start-col (or options.start-col 0)
                   :content (or options.content [])
                   :bufnr (utils.get-bufnr options.bufnr)}
                  collector)]
    (set context.get-text (partial get-text context))
    (set context.conf (partial conf context))
    context))

(defn get-spec [lang spec]
  (let [key (.. lang "." spec)]
    (when (not (. loaded-specs key))
      (require (string.format "nvim-tree-docs.specs.%s.%s" lang spec)))
    (. loaded-specs key)))

(defn- normalize-processor [processor]
  (if (utils.func? processor)
    {:build processor}
    processor))

(defn- get-processor [processors name aliased-from?]
  (let [processor-config (. processors name)]
    (if (core.string? processor-config)
      (get-processor processors processor-config (or aliased-from? name))
      (let [result (-> (or processor-config processors.__default)
                       (normalize-processor))]
        {:processor result :name name :aliased-from aliased-from?}))))

(defn get-expanded-slots [ps-list slot-config processors]
  (let [result [(unpack ps-list)]]
    (var i 1)
    (while (<= i (length result))
      (let [ps-name (. result i)
            {: processor} (get-processor processors ps-name)]
        (if (and processor processor.expand)
          (let [expanded (processor.expand
                           (utils.make-inverse-list result)
                           slot-config)]
            (table.remove result i)
            (each [j expanded-ps (ipairs expanded)]
              (table.insert result (- (+ i j) 1) expanded-ps))))
        (set i (+ i 1))))
    result))

(defn get-filtered-slots [ps-list processors slot-config context]
  (->>
    (core.map #(get-processor processors $) ps-list)
    (core.filter #(and $.processor
                       (or $.processor.implicit
                           (. slot-config (or $.aliased-from $.name)))))
    (core.map #(let [include-ps (if (utils.method? $.processor :when)
                                    ($.processor.when context)
                                    (core.table? $.processor))]
                 (if include-ps $.name nil)))
    (core.filter #(not= $ nil))))

(defn normalize-build-output [output]
  (if (core.string? output)
    [{:content output :marks []}]
    (core.table? output)
    (if (core.string? output.content)
      [output]
      (core.map #(if (core.string? $)
                   {:content $ :marks []}
                   $)
                output))))

(defn indent-lines [lines indenter context]
  (let [indentation-amount (if (utils.func? indenter)
                             (indenter lines context)
                             context.start-col)]
    (core.map (fn [line]
                (vim.tbl_extend
                 "force"
                 {}
                 {:content (.. (string.rep " " indentation-amount) line.content)
                  :marks (core.map
                           #(vim.tbl_extend
                              "force"
                              $
                              {:start (+ $.start indentation-amount)
                               :stop (+ $.stop indentation-amount)})
                           line.marks)}))
              lines)))

(defn build-slots [ps-list processors context]
  (let [result []]
    (each [i ps-name (ipairs ps-list)]
      (let [{: processor} (get-processor processors ps-name)
            default-processor processors.__default
            build-fn (or (-?> processor (. :build))
                         (-?> default-processor (. :build)))
            indent-fn (or (-?> processor (. :indent))
                          (-?> default-processor (. :indent)))]
        (table.insert
          result
          (if (utils.func? build-fn)
            (-> (build-fn context {:processors ps-list
                                   :index i
                                   :name ps-name})
                (normalize-build-output)
                (indent-lines indent-fn context))
            []))))
    result))

(defn output-to-lines [output]
  (core.reduce #(vim.list_extend $1 $2) [] output))

(defn package-build-output [output context]
  (let [result {:content [] :marks []}]
    (each [i entry (ipairs output)]
      (each [j line (ipairs entry)]
        (let [lnum (+ (length result.content) 1)]
          (table.insert result.content line.content)
          (vim.list_extend result.marks (core.map #(vim.tbl_extend
                                                     "force"
                                                     {}
                                                     $
                                                     {:line (+ lnum
                                                               (or context.start-line 0))})
                                                  line.marks)))))
    result))

(defn process-template [collector config]
  (let [{: spec : kind :config spec-conf} config
        ps-list (or (-?> spec-conf (. :templates) (. kind))
                    (. spec.templates kind))
        processors (vim.tbl_extend
                     "force"
                     spec.processors
                     (or spec-conf.processors {}))
        slot-config (or (-?> spec-conf.slots (. kind)) {})
        context (new-template-context collector config)]
    (-> ps-list
        (get-expanded-slots slot-config processors)
        (get-filtered-slots processors slot-config context)
        (build-slots processors context)
        (package-build-output context))))

(defn extend-spec [mod spec]
  (when (and spec (not= mod.module spec))
    (do
      (require (.. "nvim-tree-docs.specs." spec))
      (let [inherited-spec (. loaded-specs spec)]
        (tset mod :templates (vim.tbl_extend "force"
                                         mod.templates
                                         (-> loaded-specs (. spec) (. :templates))))
        (tset mod :utils (vim.tbl_extend "force"
                                     mod.utils
                                     (-> loaded-specs (. spec) (. :utils))))
        (tset mod :inherits inherited-spec)
        (tset mod :processors (vim.tbl_extend "force" mod.processors inherited-spec.processors))
        (tset mod :config (vim.tbl_deep_extend "force" inherited-spec.config mod.config))))))



================================================
FILE: fnl/nvim-tree-docs/utils.fnl
================================================
(module nvim-tree-docs.utils
  {autoload {core nvim-tree-docs.aniseed.core}})

(def ns (vim.api.nvim_create_namespace "blorg"))

(defn get-start-node [entry]
  (or (-?> entry (. :start_point) (. :node))
      (-?> entry (. :definition) (. :node))))

(defn get-end-node [entry]
  (or (-?> entry (. :end_point) (. :node))
      (-?> entry (. :definition) (. :node))))

(defn get-position [keys default-position entry]
  (var i 1)
  (var result nil)
  (while (and (not result) (<= i (length keys)))
    (let [key (. keys i)
          match? (. entry key)
          has-match? (and (core.table? match?) match?.node)
          position? (if has-match? (or match?.position default-position) nil)]
      (if has-match?
        (set result (if (= position? :start)
                      [(match?.node:start)]
                      [(match?.node:end_)]))))
    (set i (core.inc i)))
  (unpack result))

(def get-start-position (partial get-position [:start_point :definition] :start))
(def get-end-position (partial get-position [:end_point :definition] :end))
(def get-edit-start-position (partial get-position [:edit_start_point :start_point :definition] :start))
(def get-edit-end-position (partial get-position [:edit_end_point :end_point :definition] :end))

(defn get-bufnr [bufnr]
  (or bufnr (vim.api.nvim_get_current_buf)))

(defn get-buf-content [start-row start-col end-row end-col bufnr]
  (vim.api.nvim_buf_get_lines bufnr start-row (+ end-row 1) false))

(defn get [path tbl default?]
  (let [segments (if (= (type path) :string)
                   (vim.split path "%.")
                   path)]
    (var result tbl)
    (each [_ segment (ipairs segments)]
      (if (= (type result) :table)
        (set result (. result segment))
        (set result nil)))
    (if (= result nil) default? result)))

(defn make-inverse-list [tbl]
  (let [result {}]
    (each [i v (ipairs tbl)]
      (tset result v i))
    result))

(defn get-all-truthy-keys [tbl]
  (let [result []]
    (each [k v (pairs tbl)]
      (when v (table.insert result k)))
    result))

(defn func? [v] (= (type v) :function))
(defn method? [v key] (and (= (type v) :table)
                           (= (type (. v key)) :function)))

(defn highlight-marks [marks bufnr]
  (each [_ mark (ipairs marks)]
    (let [line (- mark.line 1)]
      (vim.highlight.range bufnr ns "Visual" [line mark.start] [line mark.stop]))))


================================================
FILE: lua/nvim-tree-docs/aniseed/autoload.lua
================================================
local _2afile_2a = "fnl/aniseed/autoload.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.autoload"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.autoload"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local autoload0
do
  local v_0_
  do
    local v_0_0
    local function autoload1(name)
      local res = {["aniseed/autoload-enabled?"] = true, ["aniseed/autoload-module"] = false}
      local function ensure()
        if res["aniseed/autoload-module"] then
          return res["aniseed/autoload-module"]
        else
          local m = require(name)
          do end (res)["aniseed/autoload-module"] = m
          return m
        end
      end
      local function _3_(t, ...)
        return ensure()(...)
      end
      local function _4_(t, k)
        return ensure()[k]
      end
      local function _5_(t, k, v)
        ensure()[k] = v
        return nil
      end
      return setmetatable(res, {__call = _3_, __index = _4_, __newindex = _5_})
    end
    v_0_0 = autoload1
    _0_["autoload"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["autoload"] = v_0_
  autoload0 = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/compile.lua
================================================
local _2afile_2a = "fnl/aniseed/compile.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.compile"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.core"), autoload("nvim-tree-docs.aniseed.fennel"), autoload("nvim-tree-docs.aniseed.fs"), autoload("nvim-tree-docs.aniseed.nvim")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {a = "nvim-tree-docs.aniseed.core", fennel = "nvim-tree-docs.aniseed.fennel", fs = "nvim-tree-docs.aniseed.fs", nvim = "nvim-tree-docs.aniseed.nvim"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local a = _local_0_[1]
local fennel = _local_0_[2]
local fs = _local_0_[3]
local nvim = _local_0_[4]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.compile"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local macros_prefix
do
  local v_0_
  do
    local v_0_0
    local function macros_prefix0(code, opts)
      local macros_module = "nvim-tree-docs.aniseed.macros"
      local filename
      do
        local _3_ = a.get(opts, "filename")
        if _3_ then
          filename = string.gsub(_3_, (nvim.fn.getcwd() .. fs["path-sep"]), "")
        else
          filename = _3_
        end
      end
      local _4_
      if filename then
        _4_ = ("\"" .. string.gsub(filename, "\\", "\\\\") .. "\"")
      else
        _4_ = "nil"
      end
      return ("(local *file* " .. _4_ .. ")" .. "(require-macros \"" .. macros_module .. "\")\n" .. code)
    end
    v_0_0 = macros_prefix0
    _0_["macros-prefix"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["macros-prefix"] = v_0_
  macros_prefix = v_0_
end
local str
do
  local v_0_
  do
    local v_0_0
    local function str0(code, opts)
      local fnl = fennel.impl()
      local function _3_()
        return fnl.compileString(macros_prefix(code, opts), a.merge({allowedGlobals = false}, opts))
      end
      return xpcall(_3_, fnl.traceback)
    end
    v_0_0 = str0
    _0_["str"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["str"] = v_0_
  str = v_0_
end
local file
do
  local v_0_
  do
    local v_0_0
    local function file0(src, dest)
      local code = a.slurp(src)
      local _3_, _4_ = str(code, {filename = src})
      if ((_3_ == false) and (nil ~= _4_)) then
        local err = _4_
        return nvim.err_writeln(err)
      elseif ((_3_ == true) and (nil ~= _4_)) then
        local result = _4_
        fs.mkdirp(fs.basename(dest))
        return a.spit(dest, result)
      end
    end
    v_0_0 = file0
    _0_["file"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["file"] = v_0_
  file = v_0_
end
local glob
do
  local v_0_
  do
    local v_0_0
    local function glob0(src_expr, src_dir, dest_dir)
      for _, path in ipairs(fs.relglob(src_dir, src_expr)) do
        if fs["macro-file-path?"](path) then
          a.spit((dest_dir .. path), a.slurp((src_dir .. path)))
        else
          file((src_dir .. path), string.gsub((dest_dir .. path), ".fnl$", ".lua"))
        end
      end
      return nil
    end
    v_0_0 = glob0
    _0_["glob"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["glob"] = v_0_
  glob = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/core.lua
================================================
local _2afile_2a = "fnl/aniseed/core.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.core"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.view")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {view = "nvim-tree-docs.aniseed.view"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local view = _local_0_[1]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.core"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
math.randomseed(os.time())
local rand
do
  local v_0_
  do
    local v_0_0
    local function rand0(n)
      return (math.random() * (n or 1))
    end
    v_0_0 = rand0
    _0_["rand"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["rand"] = v_0_
  rand = v_0_
end
local string_3f
do
  local v_0_
  do
    local v_0_0
    local function string_3f0(x)
      return ("string" == type(x))
    end
    v_0_0 = string_3f0
    _0_["string?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["string?"] = v_0_
  string_3f = v_0_
end
local nil_3f
do
  local v_0_
  do
    local v_0_0
    local function nil_3f0(x)
      return (nil == x)
    end
    v_0_0 = nil_3f0
    _0_["nil?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["nil?"] = v_0_
  nil_3f = v_0_
end
local table_3f
do
  local v_0_
  do
    local v_0_0
    local function table_3f0(x)
      return ("table" == type(x))
    end
    v_0_0 = table_3f0
    _0_["table?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["table?"] = v_0_
  table_3f = v_0_
end
local count
do
  local v_0_
  do
    local v_0_0
    local function count0(xs)
      if table_3f(xs) then
        return table.maxn(xs)
      elseif not xs then
        return 0
      else
        return #xs
      end
    end
    v_0_0 = count0
    _0_["count"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["count"] = v_0_
  count = v_0_
end
local empty_3f
do
  local v_0_
  do
    local v_0_0
    local function empty_3f0(xs)
      return (0 == count(xs))
    end
    v_0_0 = empty_3f0
    _0_["empty?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["empty?"] = v_0_
  empty_3f = v_0_
end
local first
do
  local v_0_
  do
    local v_0_0
    local function first0(xs)
      if xs then
        return xs[1]
      end
    end
    v_0_0 = first0
    _0_["first"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["first"] = v_0_
  first = v_0_
end
local second
do
  local v_0_
  do
    local v_0_0
    local function second0(xs)
      if xs then
        return xs[2]
      end
    end
    v_0_0 = second0
    _0_["second"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["second"] = v_0_
  second = v_0_
end
local last
do
  local v_0_
  do
    local v_0_0
    local function last0(xs)
      if xs then
        return xs[count(xs)]
      end
    end
    v_0_0 = last0
    _0_["last"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["last"] = v_0_
  last = v_0_
end
local inc
do
  local v_0_
  do
    local v_0_0
    local function inc0(n)
      return (n + 1)
    end
    v_0_0 = inc0
    _0_["inc"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["inc"] = v_0_
  inc = v_0_
end
local dec
do
  local v_0_
  do
    local v_0_0
    local function dec0(n)
      return (n - 1)
    end
    v_0_0 = dec0
    _0_["dec"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["dec"] = v_0_
  dec = v_0_
end
local even_3f
do
  local v_0_
  do
    local v_0_0
    local function even_3f0(n)
      return ((n % 2) == 0)
    end
    v_0_0 = even_3f0
    _0_["even?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["even?"] = v_0_
  even_3f = v_0_
end
local odd_3f
do
  local v_0_
  do
    local v_0_0
    local function odd_3f0(n)
      return not even_3f(n)
    end
    v_0_0 = odd_3f0
    _0_["odd?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["odd?"] = v_0_
  odd_3f = v_0_
end
local keys
do
  local v_0_
  do
    local v_0_0
    local function keys0(t)
      local result = {}
      if t then
        for k, _ in pairs(t) do
          table.insert(result, k)
        end
      end
      return result
    end
    v_0_0 = keys0
    _0_["keys"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["keys"] = v_0_
  keys = v_0_
end
local vals
do
  local v_0_
  do
    local v_0_0
    local function vals0(t)
      local result = {}
      if t then
        for _, v in pairs(t) do
          table.insert(result, v)
        end
      end
      return result
    end
    v_0_0 = vals0
    _0_["vals"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["vals"] = v_0_
  vals = v_0_
end
local kv_pairs
do
  local v_0_
  do
    local v_0_0
    local function kv_pairs0(t)
      local result = {}
      if t then
        for k, v in pairs(t) do
          table.insert(result, {k, v})
        end
      end
      return result
    end
    v_0_0 = kv_pairs0
    _0_["kv-pairs"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["kv-pairs"] = v_0_
  kv_pairs = v_0_
end
local run_21
do
  local v_0_
  do
    local v_0_0
    local function run_210(f, xs)
      if xs then
        local nxs = count(xs)
        if (nxs > 0) then
          for i = 1, nxs do
            f(xs[i])
          end
          return nil
        end
      end
    end
    v_0_0 = run_210
    _0_["run!"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["run!"] = v_0_
  run_21 = v_0_
end
local filter
do
  local v_0_
  do
    local v_0_0
    local function filter0(f, xs)
      local result = {}
      local function _3_(x)
        if f(x) then
          return table.insert(result, x)
        end
      end
      run_21(_3_, xs)
      return result
    end
    v_0_0 = filter0
    _0_["filter"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["filter"] = v_0_
  filter = v_0_
end
local map
do
  local v_0_
  do
    local v_0_0
    local function map0(f, xs)
      local result = {}
      local function _3_(x)
        local mapped = f(x)
        local function _4_()
          if (0 == select("#", mapped)) then
            return nil
          else
            return mapped
          end
        end
        return table.insert(result, _4_())
      end
      run_21(_3_, xs)
      return result
    end
    v_0_0 = map0
    _0_["map"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["map"] = v_0_
  map = v_0_
end
local map_indexed
do
  local v_0_
  do
    local v_0_0
    local function map_indexed0(f, xs)
      return map(f, kv_pairs(xs))
    end
    v_0_0 = map_indexed0
    _0_["map-indexed"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["map-indexed"] = v_0_
  map_indexed = v_0_
end
local identity
do
  local v_0_
  do
    local v_0_0
    local function identity0(x)
      return x
    end
    v_0_0 = identity0
    _0_["identity"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["identity"] = v_0_
  identity = v_0_
end
local reduce
do
  local v_0_
  do
    local v_0_0
    local function reduce0(f, init, xs)
      local result = init
      local function _3_(x)
        result = f(result, x)
        return nil
      end
      run_21(_3_, xs)
      return result
    end
    v_0_0 = reduce0
    _0_["reduce"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["reduce"] = v_0_
  reduce = v_0_
end
local some
do
  local v_0_
  do
    local v_0_0
    local function some0(f, xs)
      local result = nil
      local n = 1
      while (nil_3f(result) and (n <= count(xs))) do
        local candidate = f(xs[n])
        if candidate then
          result = candidate
        end
        n = inc(n)
      end
      return result
    end
    v_0_0 = some0
    _0_["some"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["some"] = v_0_
  some = v_0_
end
local butlast
do
  local v_0_
  do
    local v_0_0
    local function butlast0(xs)
      local total = count(xs)
      local function _4_(_3_)
        local _arg_0_ = _3_
        local n = _arg_0_[1]
        local v = _arg_0_[2]
        return (n ~= total)
      end
      return map(second, filter(_4_, kv_pairs(xs)))
    end
    v_0_0 = butlast0
    _0_["butlast"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["butlast"] = v_0_
  butlast = v_0_
end
local rest
do
  local v_0_
  do
    local v_0_0
    local function rest0(xs)
      local function _4_(_3_)
        local _arg_0_ = _3_
        local n = _arg_0_[1]
        local v = _arg_0_[2]
        return (n ~= 1)
      end
      return map(second, filter(_4_, kv_pairs(xs)))
    end
    v_0_0 = rest0
    _0_["rest"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["rest"] = v_0_
  rest = v_0_
end
local concat
do
  local v_0_
  do
    local v_0_0
    local function concat0(...)
      local result = {}
      local function _3_(xs)
        local function _4_(x)
          return table.insert(result, x)
        end
        return run_21(_4_, xs)
      end
      run_21(_3_, {...})
      return result
    end
    v_0_0 = concat0
    _0_["concat"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["concat"] = v_0_
  concat = v_0_
end
local mapcat
do
  local v_0_
  do
    local v_0_0
    local function mapcat0(f, xs)
      return concat(unpack(map(f, xs)))
    end
    v_0_0 = mapcat0
    _0_["mapcat"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["mapcat"] = v_0_
  mapcat = v_0_
end
local pr_str
do
  local v_0_
  do
    local v_0_0
    local function pr_str0(...)
      local s
      local function _3_(x)
        return view.serialise(x, {["one-line"] = true})
      end
      s = table.concat(map(_3_, {...}), " ")
      if (nil_3f(s) or ("" == s)) then
        return "nil"
      else
        return s
      end
    end
    v_0_0 = pr_str0
    _0_["pr-str"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["pr-str"] = v_0_
  pr_str = v_0_
end
local str
do
  local v_0_
  do
    local v_0_0
    local function str0(...)
      local function _3_(acc, s)
        return (acc .. s)
      end
      local function _4_(s)
        if string_3f(s) then
          return s
        else
          return pr_str(s)
        end
      end
      return reduce(_3_, "", map(_4_, {...}))
    end
    v_0_0 = str0
    _0_["str"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["str"] = v_0_
  str = v_0_
end
local println
do
  local v_0_
  do
    local v_0_0
    local function println0(...)
      local function _3_(acc, s)
        return (acc .. s)
      end
      local function _5_(_4_)
        local _arg_0_ = _4_
        local i = _arg_0_[1]
        local s = _arg_0_[2]
        if (1 == i) then
          return s
        else
          return (" " .. s)
        end
      end
      local function _6_(s)
        if string_3f(s) then
          return s
        else
          return pr_str(s)
        end
      end
      return print(reduce(_3_, "", map_indexed(_5_, map(_6_, {...}))))
    end
    v_0_0 = println0
    _0_["println"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["println"] = v_0_
  println = v_0_
end
local pr
do
  local v_0_
  do
    local v_0_0
    local function pr0(...)
      return println(pr_str(...))
    end
    v_0_0 = pr0
    _0_["pr"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["pr"] = v_0_
  pr = v_0_
end
local slurp
do
  local v_0_
  do
    local v_0_0
    local function slurp0(path, silent_3f)
      local _3_, _4_ = io.open(path, "r")
      if ((_3_ == nil) and (nil ~= _4_)) then
        local msg = _4_
        return nil
      elseif (nil ~= _3_) then
        local f = _3_
        local content = f:read("*all")
        f:close()
        return content
      end
    end
    v_0_0 = slurp0
    _0_["slurp"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["slurp"] = v_0_
  slurp = v_0_
end
local spit
do
  local v_0_
  do
    local v_0_0
    local function spit0(path, content)
      local _3_, _4_ = io.open(path, "w")
      if ((_3_ == nil) and (nil ~= _4_)) then
        local msg = _4_
        return error(("Could not open file: " .. msg))
      elseif (nil ~= _3_) then
        local f = _3_
        f:write(content)
        f:close()
        return nil
      end
    end
    v_0_0 = spit0
    _0_["spit"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["spit"] = v_0_
  spit = v_0_
end
local merge_21
do
  local v_0_
  do
    local v_0_0
    local function merge_210(base, ...)
      local function _3_(acc, m)
        if m then
          for k, v in pairs(m) do
            acc[k] = v
          end
        end
        return acc
      end
      return reduce(_3_, (base or {}), {...})
    end
    v_0_0 = merge_210
    _0_["merge!"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["merge!"] = v_0_
  merge_21 = v_0_
end
local merge
do
  local v_0_
  do
    local v_0_0
    local function merge0(...)
      return merge_21({}, ...)
    end
    v_0_0 = merge0
    _0_["merge"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["merge"] = v_0_
  merge = v_0_
end
local select_keys
do
  local v_0_
  do
    local v_0_0
    local function select_keys0(t, ks)
      if (t and ks) then
        local function _3_(acc, k)
          if k then
            acc[k] = t[k]
          end
          return acc
        end
        return reduce(_3_, {}, ks)
      else
        return {}
      end
    end
    v_0_0 = select_keys0
    _0_["select-keys"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["select-keys"] = v_0_
  select_keys = v_0_
end
local get
do
  local v_0_
  do
    local v_0_0
    local function get0(t, k, d)
      local res
      if table_3f(t) then
        local val = t[k]
        if not nil_3f(val) then
          res = val
        else
        res = nil
        end
      else
      res = nil
      end
      if nil_3f(res) then
        return d
      else
        return res
      end
    end
    v_0_0 = get0
    _0_["get"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get"] = v_0_
  get = v_0_
end
local get_in
do
  local v_0_
  do
    local v_0_0
    local function get_in0(t, ks, d)
      local res
      local function _3_(acc, k)
        if table_3f(acc) then
          return get(acc, k)
        end
      end
      res = reduce(_3_, t, ks)
      if nil_3f(res) then
        return d
      else
        return res
      end
    end
    v_0_0 = get_in0
    _0_["get-in"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-in"] = v_0_
  get_in = v_0_
end
local assoc
do
  local v_0_
  do
    local v_0_0
    local function assoc0(t, ...)
      local _let_0_ = {...}
      local k = _let_0_[1]
      local v = _let_0_[2]
      local xs = {(table.unpack or unpack)(_let_0_, 3)}
      local rem = count(xs)
      local t0 = (t or {})
      if odd_3f(rem) then
        error("assoc expects even number of arguments after table, found odd number")
      end
      if not nil_3f(k) then
        t0[k] = v
      end
      if (rem > 0) then
        assoc0(t0, unpack(xs))
      end
      return t0
    end
    v_0_0 = assoc0
    _0_["assoc"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["assoc"] = v_0_
  assoc = v_0_
end
local assoc_in
do
  local v_0_
  do
    local v_0_0
    local function assoc_in0(t, ks, v)
      local path = butlast(ks)
      local final = last(ks)
      local t0 = (t or {})
      local function _3_(acc, k)
        local step = get(acc, k)
        if nil_3f(step) then
          return get(assoc(acc, k, {}), k)
        else
          return step
        end
      end
      assoc(reduce(_3_, t0, path), final, v)
      return t0
    end
    v_0_0 = assoc_in0
    _0_["assoc-in"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["assoc-in"] = v_0_
  assoc_in = v_0_
end
local update
do
  local v_0_
  do
    local v_0_0
    local function update0(t, k, f)
      return assoc(t, k, f(get(t, k)))
    end
    v_0_0 = update0
    _0_["update"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["update"] = v_0_
  update = v_0_
end
local update_in
do
  local v_0_
  do
    local v_0_0
    local function update_in0(t, ks, f)
      return assoc_in(t, ks, f(get_in(t, ks)))
    end
    v_0_0 = update_in0
    _0_["update-in"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["update-in"] = v_0_
  update_in = v_0_
end
local constantly
do
  local v_0_
  do
    local v_0_0
    local function constantly0(v)
      local function _3_()
        return v
      end
      return _3_
    end
    v_0_0 = constantly0
    _0_["constantly"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["constantly"] = v_0_
  constantly = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/deps/fennel.lua
================================================
package.preload["nvim-tree-docs.aniseed.fennel.repl"] = package.preload["nvim-tree-docs.aniseed.fennel.repl"] or function(...)
  local utils = require("nvim-tree-docs.aniseed.fennel.utils")
  local parser = require("nvim-tree-docs.aniseed.fennel.parser")
  local compiler = require("nvim-tree-docs.aniseed.fennel.compiler")
  local specials = require("nvim-tree-docs.aniseed.fennel.specials")
  local function default_read_chunk(parser_state)
    local function _0_()
      if (0 < parser_state["stack-size"]) then
        return ".."
      else
        return ">> "
      end
    end
    io.write(_0_())
    io.flush()
    local input = io.read()
    return (input and (input .. "\n"))
  end
  local function default_on_values(xs)
    io.write(table.concat(xs, "\9"))
    return io.write("\n")
  end
  local function default_on_error(errtype, err, lua_source)
    local function _1_()
      local _0_0 = errtype
      if (_0_0 == "Lua Compile") then
        return ("Bad code generated - likely a bug with the compiler:\n" .. "--- Generated Lua Start ---\n" .. lua_source .. "--- Generated Lua End ---\n")
      elseif (_0_0 == "Runtime") then
        return (compiler.traceback(tostring(err), 4) .. "\n")
      else
        local _ = _0_0
        return ("%s error: %s\n"):format(errtype, tostring(err))
      end
    end
    return io.write(_1_())
  end
  local save_source = table.concat({"local ___i___ = 1", "while true do", " local name, value = debug.getlocal(1, ___i___)", " if(name and name ~= \"___i___\") then", " ___replLocals___[name] = value", " ___i___ = ___i___ + 1", " else break end end"}, "\n")
  local function splice_save_locals(env, lua_source)
    env.___replLocals___ = (env.___replLocals___ or {})
    local spliced_source = {}
    local bind = "local %s = ___replLocals___['%s']"
    for line in lua_source:gmatch("([^\n]+)\n?") do
      table.insert(spliced_source, line)
    end
    for name in pairs(env.___replLocals___) do
      table.insert(spliced_source, 1, bind:format(name, name))
    end
    if ((1 < #spliced_source) and (spliced_source[#spliced_source]):match("^ *return .*$")) then
      table.insert(spliced_source, #spliced_source, save_source)
    end
    return table.concat(spliced_source, "\n")
  end
  local commands = {}
  local function command_3f(input)
    return input:match("^%s*,")
  end
  local function command_docs()
    local _0_
    do
      local tbl_0_ = {}
      for name, f in pairs(commands) do
        tbl_0_[(#tbl_0_ + 1)] = ("  ,%s - %s"):format(name, ((compiler.metadata):get(f, "fnl/docstring") or "undocumented"))
      end
      _0_ = tbl_0_
    end
    return table.concat(_0_, "\n")
  end
  commands.help = function(_, _0, on_values)
    return on_values({("Welcome to Fennel.\nThis is the REPL where you can enter code to be evaluated.\nYou can also run these repl commands:\n\n" .. command_docs() .. "\n  ,exit - Leave the repl.\n\nUse (doc something) to see descriptions for individual macros and special forms.\n\nFor more information about the language, see https://fennel-lang.org/reference")})
  end
  do end (compiler.metadata):set(commands.help, "fnl/docstring", "Show this message.")
  local function reload(module_name, env, on_values, on_error)
    local _0_0, _1_0 = pcall(specials["load-code"]("return require(...)", env), module_name)
    if ((_0_0 == true) and (nil ~= _1_0)) then
      local old = _1_0
      local _ = nil
      package.loaded[module_name] = nil
      _ = nil
      local ok, new = pcall(require, module_name)
      local new0 = nil
      if not ok then
        on_values({new})
        new0 = old
      else
        new0 = new
      end
      if ((type(old) == "table") and (type(new0) == "table")) then
        for k, v in pairs(new0) do
          old[k] = v
        end
        for k in pairs(old) do
          if (nil == new0[k]) then
            old[k] = nil
          end
        end
        package.loaded[module_name] = old
      end
      return on_values({"ok"})
    elseif ((_0_0 == false) and (nil ~= _1_0)) then
      local msg = _1_0
      local function _3_()
        local _2_0 = msg:gsub("\n.*", "")
        return _2_0
      end
      return on_error("Runtime", _3_())
    end
  end
  commands.reload = function(env, read, on_values, on_error)
    local _0_0, _1_0, _2_0 = pcall(read)
    if ((_0_0 == true) and (_1_0 == true) and (nil ~= _2_0)) then
      local module_sym = _2_0
      return reload(tostring(module_sym), env, on_values, on_error)
    elseif ((_0_0 == false) and true and true) then
      local _3fparse_ok = _1_0
      local _3fmsg = _2_0
      return on_error("Parse", (_3fmsg or _3fparse_ok))
    end
  end
  do end (compiler.metadata):set(commands.reload, "fnl/docstring", "Reload the specified module.")
  commands.reset = function(env, _, on_values)
    env.___replLocals___ = {}
    return on_values({"ok"})
  end
  do end (compiler.metadata):set(commands.reset, "fnl/docstring", "Erase all repl-local scope.")
  local function load_plugin_commands()
    if (utils.root and utils.root.options and utils.root.options.plugins) then
      for _, plugin in ipairs(utils.root.options.plugins) do
        for name, f in pairs(plugin) do
          local _0_0 = name:match("^repl%-command%-(.*)")
          if (nil ~= _0_0) then
            local cmd_name = _0_0
            commands[cmd_name] = (commands[cmd_name] or f)
          end
        end
      end
      return nil
    end
  end
  local function run_command(input, read, loop, env, on_values, on_error)
    load_plugin_commands()
    local command_name = input:match(",([^%s/]+)")
    do
      local _0_0 = commands[command_name]
      if (nil ~= _0_0) then
        local command = _0_0
        command(env, read, on_values, on_error)
      else
        local _ = _0_0
        if ("exit" ~= command_name) then
          on_values({"Unknown command", command_name})
        end
      end
    end
    if ("exit" ~= command_name) then
      return loop()
    end
  end
  local function completer(env, scope, text)
    local matches = {}
    local input_fragment = text:gsub(".*[%s)(]+", "")
    local function add_partials(input, tbl, prefix)
      for k in utils.allpairs(tbl) do
        local k0 = nil
        if ((tbl == env) or (tbl == env.___replLocals___)) then
          k0 = scope.unmanglings[k]
        else
          k0 = k
        end
        if ((#matches < 2000) and (type(k0) == "string") and (input == k0:sub(0, #input))) then
          table.insert(matches, (prefix .. k0))
        end
      end
      return nil
    end
    local function add_matches(input, tbl, prefix)
      local prefix0 = nil
      if prefix then
        prefix0 = (prefix .. ".")
      else
        prefix0 = ""
      end
      if not input:find("%.") then
        return add_partials(input, tbl, prefix0)
      else
        local head, tail = input:match("^([^.]+)%.(.*)")
        local raw_head = nil
        if ((tbl == env) or (tbl == env.___replLocals___)) then
          raw_head = scope.manglings[head]
        else
          raw_head = head
        end
        if (type(tbl[raw_head]) == "table") then
          return add_matches(tail, tbl[raw_head], (prefix0 .. head))
        end
      end
    end
    add_matches(input_fragment, (scope.specials or {}))
    add_matches(input_fragment, (scope.macros or {}))
    add_matches(input_fragment, (env.___replLocals___ or {}))
    add_matches(input_fragment, env)
    add_matches(input_fragment, (env._ENV or env._G or {}))
    return matches
  end
  local function repl(options)
    local old_root_options = utils.root.options
    local env = nil
    if options.env then
      env = specials["wrap-env"](options.env)
    else
      env = setmetatable({}, {__index = (rawget(_G, "_ENV") or _G)})
    end
    local save_locals_3f = ((options.saveLocals ~= false) and env.debug and env.debug.getlocal)
    local opts = {}
    local _ = nil
    for k, v in pairs(options) do
      opts[k] = v
    end
    _ = nil
    local read_chunk = (opts.readChunk or default_read_chunk)
    local on_values = (opts.onValues or default_on_values)
    local on_error = (opts.onError or default_on_error)
    local pp = (opts.pp or tostring)
    local byte_stream, clear_stream = parser.granulate(read_chunk)
    local chars = {}
    local read, reset = nil, nil
    local function _1_(parser_state)
      local c = byte_stream(parser_state)
      table.insert(chars, c)
      return c
    end
    read, reset = parser.parser(_1_)
    local scope = compiler["make-scope"]()
    opts.useMetadata = (options.useMetadata ~= false)
    if (opts.allowedGlobals == nil) then
      opts.allowedGlobals = specials["current-global-names"](opts.env)
    end
    if opts.registerCompleter then
      local function _3_(...)
        return completer(env, scope, ...)
      end
      opts.registerCompleter(_3_)
    end
    local function print_values(...)
      local vals = {...}
      local out = {}
      env._, env.__ = vals[1], vals
      for i = 1, select("#", ...) do
        table.insert(out, pp(vals[i]))
      end
      return on_values(out)
    end
    local function loop()
      for k in pairs(chars) do
        chars[k] = nil
      end
      local ok, parse_ok_3f, x = pcall(read)
      local src_string = string.char((table.unpack or _G.unpack)(chars))
      utils.root.options = opts
      if not ok then
        on_error("Parse", parse_ok_3f)
        clear_stream()
        reset()
        return loop()
      elseif command_3f(src_string) then
        return run_command(src_string, read, loop, env, on_values, on_error)
      else
        if parse_ok_3f then
          do
            local _4_0, _5_0 = pcall(compiler.compile, x, {["assert-compile"] = opts["assert-compile"], ["parse-error"] = opts["parse-error"], correlate = opts.correlate, moduleName = opts.moduleName, scope = scope, source = src_string, useBitLib = opts.useBitLib, useMetadata = opts.useMetadata})
            if ((_4_0 == false) and (nil ~= _5_0)) then
              local msg = _5_0
              clear_stream()
              on_error("Compile", msg)
            elseif ((_4_0 == true) and (nil ~= _5_0)) then
              local src = _5_0
              local src0 = nil
              if save_locals_3f then
                src0 = splice_save_locals(env, src)
              else
                src0 = src
              end
              local _7_0, _8_0 = pcall(specials["load-code"], src0, env)
              if ((_7_0 == false) and (nil ~= _8_0)) then
                local msg = _8_0
                clear_stream()
                on_error("Lua Compile", msg, src0)
              elseif (true and (nil ~= _8_0)) then
                local _0 = _7_0
                local chunk = _8_0
                local function _9_()
                  return print_values(chunk())
                end
                local function _10_(...)
                  return on_error("Runtime", ...)
                end
                xpcall(_9_, _10_)
              end
            end
          end
          utils.root.options = old_root_options
          return loop()
        end
      end
    end
    return loop()
  end
  return repl
end
package.preload["nvim-tree-docs.aniseed.fennel.view"] = package.preload["nvim-tree-docs.aniseed.fennel.view"] or function(...)
  local type_order = {["function"] = 5, boolean = 2, number = 1, string = 3, table = 4, thread = 7, userdata = 6}
  local function sort_keys(_0_0, _1_0)
    local _1_ = _0_0
    local a = _1_[1]
    local _2_ = _1_0
    local b = _2_[1]
    local ta = type(a)
    local tb = type(b)
    if ((ta == tb) and ((ta == "string") or (ta == "number"))) then
      return (a < b)
    else
      local dta = type_order[ta]
      local dtb = type_order[tb]
      if (dta and dtb) then
        return (dta < dtb)
      elseif dta then
        return true
      elseif dtb then
        return false
      else
        return (ta < tb)
      end
    end
  end
  local function table_kv_pairs(t)
    local assoc_3f = false
    local i = 1
    local kv = {}
    local insert = table.insert
    for k, v in pairs(t) do
      if ((type(k) ~= "number") or (k ~= i)) then
        assoc_3f = true
      end
      i = (i + 1)
      insert(kv, {k, v})
    end
    table.sort(kv, sort_keys)
    if (#kv == 0) then
      return kv, "empty"
    else
      local function _2_()
        if assoc_3f then
          return "table"
        else
          return "seq"
        end
      end
      return kv, _2_()
    end
  end
  local function count_table_appearances(t, appearances)
    if (type(t) == "table") then
      if not appearances[t] then
        appearances[t] = 1
        for k, v in pairs(t) do
          count_table_appearances(k, appearances)
          count_table_appearances(v, appearances)
        end
      else
        appearances[t] = ((appearances[t] or 0) + 1)
      end
    end
    return appearances
  end
  local function save_table(t, seen)
    local seen0 = (seen or {len = 0})
    local id = (seen0.len + 1)
    if not seen0[t] then
      seen0[t] = id
      seen0.len = id
    end
    return seen0
  end
  local function detect_cycle(t, seen, _3fk)
    if ("table" == type(t)) then
      seen[t] = true
      local _2_0, _3_0 = next(t, _3fk)
      if ((nil ~= _2_0) and (nil ~= _3_0)) then
        local k = _2_0
        local v = _3_0
        return (seen[k] or detect_cycle(k, seen) or seen[v] or detect_cycle(v, seen) or detect_cycle(t, seen, k))
      end
    end
  end
  local function visible_cycle_3f(t, options)
    return (options["detect-cycles?"] and detect_cycle(t, {}) and save_table(t, options.seen) and (1 < (options.appearances[t] or 0)))
  end
  local function table_indent(t, indent, id)
    local opener_length = nil
    if id then
      opener_length = (#tostring(id) + 2)
    else
      opener_length = 1
    end
    return (indent + opener_length)
  end
  local pp = nil
  local function concat_table_lines(elements, options, multiline_3f, indent, table_type, prefix)
    local indent_str = ("\n" .. string.rep(" ", indent))
    local open = nil
    local function _2_()
      if ("seq" == table_type) then
        return "["
      else
        return "{"
      end
    end
    open = ((prefix or "") .. _2_())
    local close = nil
    if ("seq" == table_type) then
      close = "]"
    else
      close = "}"
    end
    local oneline = (open .. table.concat(elements, " ") .. close)
    if (not options["one-line?"] and (multiline_3f or ((indent + #oneline) > options["line-length"]))) then
      return (open .. table.concat(elements, indent_str) .. close)
    else
      return oneline
    end
  end
  local function pp_associative(t, kv, options, indent, key_3f)
    local multiline_3f = false
    local id = options.seen[t]
    if (options.level >= options.depth) then
      return "{...}"
    elseif (id and options["detect-cycles?"]) then
      return ("@" .. id .. "{...}")
    else
      local visible_cycle_3f0 = visible_cycle_3f(t, options)
      local id0 = (visible_cycle_3f0 and options.seen[t])
      local indent0 = table_indent(t, indent, id0)
      local slength = nil
      local function _3_()
        local _2_0 = rawget(_G, "utf8")
        if _2_0 then
          return _2_0.len
        else
          return _2_0
        end
      end
      local function _4_(_241)
        return #_241
      end
      slength = ((options["utf8?"] and _3_()) or _4_)
      local prefix = nil
      if visible_cycle_3f0 then
        prefix = ("@" .. id0)
      else
        prefix = ""
      end
      local items = nil
      do
        local tbl_0_ = {}
        for _, _6_0 in pairs(kv) do
          local _7_ = _6_0
          local k = _7_[1]
          local v = _7_[2]
          local _8_
          do
            local k0 = pp(k, options, (indent0 + 1), true)
            local v0 = pp(v, options, (indent0 + slength(k0) + 1))
            multiline_3f = (multiline_3f or k0:find("\n") or v0:find("\n"))
            _8_ = (k0 .. " " .. v0)
          end
          tbl_0_[(#tbl_0_ + 1)] = _8_
        end
        items = tbl_0_
      end
      return concat_table_lines(items, options, multiline_3f, indent0, "table", prefix)
    end
  end
  local function pp_sequence(t, kv, options, indent)
    local multiline_3f = false
    local id = options.seen[t]
    if (options.level >= options.depth) then
      return "[...]"
    elseif (id and options["detect-cycles?"]) then
      return ("@" .. id .. "[...]")
    else
      local visible_cycle_3f0 = visible_cycle_3f(t, options)
      local id0 = (visible_cycle_3f0 and options.seen[t])
      local indent0 = table_indent(t, indent, id0)
      local prefix = nil
      if visible_cycle_3f0 then
        prefix = ("@" .. id0)
      else
        prefix = ""
      end
      local items = nil
      do
        local tbl_0_ = {}
        for _, _3_0 in pairs(kv) do
          local _4_ = _3_0
          local _0 = _4_[1]
          local v = _4_[2]
          local _5_
          do
            local v0 = pp(v, options, indent0)
            multiline_3f = (multiline_3f or v0:find("\n"))
            _5_ = v0
          end
          tbl_0_[(#tbl_0_ + 1)] = _5_
        end
        items = tbl_0_
      end
      return concat_table_lines(items, options, multiline_3f, indent0, "seq", prefix)
    end
  end
  local function concat_lines(lines, options, indent, force_multi_line_3f)
    if (#lines == 0) then
      if options["empty-as-sequence?"] then
        return "[]"
      else
        return "{}"
      end
    else
      local oneline = nil
      local _2_
      do
        local tbl_0_ = {}
        for _, line in ipairs(lines) do
          tbl_0_[(#tbl_0_ + 1)] = line:gsub("^%s+", "")
        end
        _2_ = tbl_0_
      end
      oneline = table.concat(_2_, " ")
      if (not options["one-line?"] and (force_multi_line_3f or oneline:find("\n") or ((indent + #oneline) > options["line-length"]))) then
        return table.concat(lines, ("\n" .. string.rep(" ", indent)))
      else
        return oneline
      end
    end
  end
  local function pp_metamethod(t, metamethod, options, indent)
    if (options.level >= options.depth) then
      if options["empty-as-sequence?"] then
        return "[...]"
      else
        return "{...}"
      end
    else
      local _ = nil
      local function _2_(_241)
        return visible_cycle_3f(_241, options)
      end
      options["visible-cycle?"] = _2_
      _ = nil
      local lines, force_multi_line_3f = metamethod(t, pp, options, indent)
      options["visible-cycle?"] = nil
      local _3_0 = type(lines)
      if (_3_0 == "string") then
        return lines
      elseif (_3_0 == "table") then
        return concat_lines(lines, options, indent, force_multi_line_3f)
      else
        local _0 = _3_0
        return error("__fennelview metamethod must return a table of lines")
      end
    end
  end
  local function pp_table(x, options, indent)
    options.level = (options.level + 1)
    local x0 = nil
    do
      local _2_0 = nil
      if options["metamethod?"] then
        local _3_0 = x
        if _3_0 then
          local _4_0 = getmetatable(_3_0)
          if _4_0 then
            _2_0 = _4_0.__fennelview
          else
            _2_0 = _4_0
          end
        else
          _2_0 = _3_0
        end
      else
      _2_0 = nil
      end
      if (nil ~= _2_0) then
        local metamethod = _2_0
        x0 = pp_metamethod(x, metamethod, options, indent)
      else
        local _ = _2_0
        local _4_0, _5_0 = table_kv_pairs(x)
        if (true and (_5_0 == "empty")) then
          local _0 = _4_0
          if options["empty-as-sequence?"] then
            x0 = "[]"
          else
            x0 = "{}"
          end
        elseif ((nil ~= _4_0) and (_5_0 == "table")) then
          local kv = _4_0
          x0 = pp_associative(x, kv, options, indent)
        elseif ((nil ~= _4_0) and (_5_0 == "seq")) then
          local kv = _4_0
          x0 = pp_sequence(x, kv, options, indent)
        else
        x0 = nil
        end
      end
    end
    options.level = (options.level - 1)
    return x0
  end
  local function number__3estring(n)
    local _2_0 = string.gsub(tostring(n), ",", ".")
    return _2_0
  end
  local function colon_string_3f(s)
    return s:find("^[-%w?^_!$%&*+./@|<=>]+$")
  end
  local function pp_string(str, options, indent)
    local escs = nil
    local _2_
    if (options["escape-newlines?"] and (#str < (options["line-length"] - indent))) then
      _2_ = "\\n"
    else
      _2_ = "\n"
    end
    local function _4_(_241, _242)
      return ("\\%03d"):format(_242:byte())
    end
    escs = setmetatable({["\""] = "\\\"", ["\11"] = "\\v", ["\12"] = "\\f", ["\13"] = "\\r", ["\7"] = "\\a", ["\8"] = "\\b", ["\9"] = "\\t", ["\\"] = "\\\\", ["\n"] = _2_}, {__index = _4_})
    return ("\"" .. str:gsub("[%c\\\"]", escs) .. "\"")
  end
  local function make_options(t, options)
    local defaults = {["detect-cycles?"] = true, ["empty-as-sequence?"] = false, ["escape-newlines?"] = false, ["line-length"] = 80, ["metamethod?"] = true, ["one-line?"] = false, ["prefer-colon?"] = false, ["utf8?"] = true, depth = 128}
    local overrides = {appearances = count_table_appearances(t, {}), level = 0, seen = {len = 0}}
    for k, v in pairs((options or {})) do
      defaults[k] = v
    end
    for k, v in pairs(overrides) do
      defaults[k] = v
    end
    return defaults
  end
  local function _2_(x, options, indent, colon_3f)
    local indent0 = (indent or 0)
    local options0 = (options or make_options(x))
    local tv = type(x)
    local function _4_()
      local _3_0 = getmetatable(x)
      if _3_0 then
        return _3_0.__fennelview
      else
        return _3_0
      end
    end
    if ((tv == "table") or ((tv == "userdata") and _4_())) then
      return pp_table(x, options0, indent0)
    elseif (tv == "number") then
      return number__3estring(x)
    else
      local function _5_()
        if (colon_3f ~= nil) then
          return colon_3f
        elseif ("function" == type(options0["prefer-colon?"])) then
          return options0["prefer-colon?"](x)
        else
          return options0["prefer-colon?"]
        end
      end
      if ((tv == "string") and colon_string_3f(x) and _5_()) then
        return (":" .. x)
      elseif (tv == "string") then
        return pp_string(x, options0, indent0)
      elseif ((tv == "boolean") or (tv == "nil")) then
        return tostring(x)
      else
        return ("#<" .. tostring(x) .. ">")
      end
    end
  end
  pp = _2_
  local function view(x, options)
    return pp(x, make_options(x, options), 0)
  end
  return view
end
package.preload["nvim-tree-docs.aniseed.fennel.specials"] = package.preload["nvim-tree-docs.aniseed.fennel.specials"] or function(...)
  local utils = require("nvim-tree-docs.aniseed.fennel.utils")
  local view = require("nvim-tree-docs.aniseed.fennel.view")
  local parser = require("nvim-tree-docs.aniseed.fennel.parser")
  local compiler = require("nvim-tree-docs.aniseed.fennel.compiler")
  local unpack = (table.unpack or _G.unpack)
  local SPECIALS = compiler.scopes.global.specials
  local function wrap_env(env)
    local function _0_(_, key)
      if (type(key) == "string") then
        return env[compiler["global-unmangling"](key)]
      else
        return env[key]
      end
    end
    local function _1_(_, key, value)
      if (type(key) == "string") then
        env[compiler["global-unmangling"](key)] = value
        return nil
      else
        env[key] = value
        return nil
      end
    end
    local function _2_()
      local function putenv(k, v)
        local _3_
        if (type(k) == "string") then
          _3_ = compiler["global-unmangling"](k)
        else
          _3_ = k
        end
        return _3_, v
      end
      return next, utils.kvmap(env, putenv), nil
    end
    return setmetatable({}, {__index = _0_, __newindex = _1_, __pairs = _2_})
  end
  local function current_global_names(env)
    return utils.kvmap((env or _G), compiler["global-unmangling"])
  end
  local function load_code(code, environment, filename)
    local environment0 = (environment or rawget(_G, "_ENV") or _G)
    if (rawget(_G, "setfenv") and rawget(_G, "loadstring")) then
      local f = assert(_G.loadstring(code, filename))
      _G.setfenv(f, environment0)
      return f
    else
      return assert(load(code, filename, "t", environment0))
    end
  end
  local function doc_2a(tgt, name)
    if not tgt then
      return (name .. " not found")
    else
      local docstring = (((compiler.metadata):get(tgt, "fnl/docstring") or "#<undocumented>")):gsub("\n$", ""):gsub("\n", "\n  ")
      local mt = getmetatable(tgt)
      if ((type(tgt) == "function") or ((type(mt) == "table") and (type(mt.__call) == "function"))) then
        local arglist = table.concat(((compiler.metadata):get(tgt, "fnl/arglist") or {"#<unknown-arguments>"}), " ")
        local _0_
        if (#arglist > 0) then
          _0_ = " "
        else
          _0_ = ""
        end
        return string.format("(%s%s%s)\n  %s", name, _0_, arglist, docstring)
      else
        return string.format("%s\n  %s", name, docstring)
      end
    end
  end
  local function doc_special(name, arglist, docstring, body_form_3f)
    compiler.metadata[SPECIALS[name]] = {["fnl/arglist"] = arglist, ["fnl/body-form?"] = body_form_3f, ["fnl/docstring"] = docstring}
    return nil
  end
  local function compile_do(ast, scope, parent, start)
    local start0 = (start or 2)
    local len = #ast
    local sub_scope = compiler["make-scope"](scope)
    for i = start0, len do
      compiler.compile1(ast[i], sub_scope, parent, {nval = 0})
    end
    return nil
  end
  SPECIALS["do"] = function(ast, scope, parent, opts, start, chunk, sub_scope, pre_syms)
    local start0 = (start or 2)
    local sub_scope0 = (sub_scope or compiler["make-scope"](scope))
    local chunk0 = (chunk or {})
    local len = #ast
    local retexprs = {returned = true}
    local function compile_body(outer_target, outer_tail, outer_retexprs)
      if (len < start0) then
        compiler.compile1(nil, sub_scope0, chunk0, {tail = outer_tail, target = outer_target})
      else
        for i = start0, len do
          local subopts = {nval = (((i ~= len) and 0) or opts.nval), tail = (((i == len) and outer_tail) or nil), target = (((i == len) and outer_target) or nil)}
          local _ = utils["propagate-options"](opts, subopts)
          local subexprs = compiler.compile1(ast[i], sub_scope0, chunk0, subopts)
          if (i ~= len) then
            compiler["keep-side-effects"](subexprs, parent, nil, ast[i])
          end
        end
      end
      compiler.emit(parent, chunk0, ast)
      compiler.emit(parent, "end", ast)
      return (outer_retexprs or retexprs)
    end
    if (opts.target or (opts.nval == 0) or opts.tail) then
      compiler.emit(parent, "do", ast)
      return compile_body(opts.target, opts.tail)
    elseif opts.nval then
      local syms = {}
      for i = 1, opts.nval do
        local s = ((pre_syms and pre_syms[i]) or compiler.gensym(scope))
        syms[i] = s
        retexprs[i] = utils.expr(s, "sym")
      end
      local outer_target = table.concat(syms, ", ")
      compiler.emit(parent, string.format("local %s", outer_target), ast)
      compiler.emit(parent, "do", ast)
      return compile_body(outer_target, opts.tail)
    else
      local fname = compiler.gensym(scope)
      local fargs = nil
      if scope.vararg then
        fargs = "..."
      else
        fargs = ""
      end
      compiler.emit(parent, string.format("local function %s(%s)", fname, fargs), ast)
      utils.hook("do", ast, sub_scope0)
      return compile_body(nil, true, utils.expr((fname .. "(" .. fargs .. ")"), "statement"))
    end
  end
  doc_special("do", {"..."}, "Evaluate multiple forms; return last value.", true)
  SPECIALS.values = function(ast, scope, parent)
    local len = #ast
    local exprs = {}
    for i = 2, len do
      local subexprs = compiler.compile1(ast[i], scope, parent, {nval = ((i ~= len) and 1)})
      table.insert(exprs, subexprs[1])
      if (i == len) then
        for j = 2, #subexprs do
          table.insert(exprs, subexprs[j])
        end
      end
    end
    return exprs
  end
  doc_special("values", {"..."}, "Return multiple values from a function. Must be in tail position.")
  local function deep_tostring(x, key_3f)
    local elems = {}
    if utils["sequence?"](x) then
      local _0_
      do
        local tbl_0_ = {}
        for _, v in ipairs(x) do
          tbl_0_[(#tbl_0_ + 1)] = deep_tostring(v)
        end
        _0_ = tbl_0_
      end
      return ("[" .. table.concat(_0_, " ") .. "]")
    elseif utils["table?"](x) then
      local _0_
      do
        local tbl_0_ = {}
        for k, v in pairs(x) do
          tbl_0_[(#tbl_0_ + 1)] = (deep_tostring(k, true) .. " " .. deep_tostring(v))
        end
        _0_ = tbl_0_
      end
      return ("{" .. table.concat(_0_, " ") .. "}")
    elseif (key_3f and (type(x) == "string") and x:find("^[-%w?\\^_!$%&*+./@:|<=>]+$")) then
      return (":" .. x)
    elseif (type(x) == "string") then
      return string.format("%q", x):gsub("\\\"", "\\\\\""):gsub("\"", "\\\"")
    else
      return tostring(x)
    end
  end
  local function set_fn_metadata(arg_list, docstring, parent, fn_name)
    if utils.root.options.useMetadata then
      local args = nil
      local function _0_(_241)
        return ("\"%s\""):format(deep_tostring(_241))
      end
      args = utils.map(arg_list, _0_)
      local meta_fields = {"\"fnl/arglist\"", ("{" .. table.concat(args, ", ") .. "}")}
      if docstring then
        table.insert(meta_fields, "\"fnl/docstring\"")
        table.insert(meta_fields, ("\"" .. docstring:gsub("%s+$", ""):gsub("\\", "\\\\"):gsub("\n", "\\n"):gsub("\"", "\\\"") .. "\""))
      end
      local meta_str = ("require(\"%s\").metadata"):format((utils.root.options.moduleName or "fennel"))
      return compiler.emit(parent, ("pcall(function() %s:setall(%s, %s) end)"):format(meta_str, fn_name, table.concat(meta_fields, ", ")))
    end
  end
  local function get_fn_name(ast, scope, fn_name, multi)
    if (fn_name and (fn_name[1] ~= "nil")) then
      local _0_
      if not multi then
        _0_ = compiler["declare-local"](fn_name, {}, scope, ast)
      else
        _0_ = compiler["symbol-to-expression"](fn_name, scope)[1]
      end
      return _0_, not multi, 3
    else
      return nil, true, 2
    end
  end
  local function compile_named_fn(ast, f_scope, f_chunk, parent, index, fn_name, local_3f, arg_name_list, arg_list, docstring)
    for i = (index + 1), #ast do
      compiler.compile1(ast[i], f_scope, f_chunk, {nval = (((i ~= #ast) and 0) or nil), tail = (i == #ast)})
    end
    local _0_
    if local_3f then
      _0_ = "local function %s(%s)"
    else
      _0_ = "%s = function(%s)"
    end
    compiler.emit(parent, string.format(_0_, fn_name, table.concat(arg_name_list, ", ")), ast)
    compiler.emit(parent, f_chunk, ast)
    compiler.emit(parent, "end", ast)
    set_fn_metadata(arg_list, docstring, parent, fn_name)
    utils.hook("fn", ast, f_scope)
    return utils.expr(fn_name, "sym")
  end
  local function compile_anonymous_fn(ast, f_scope, f_chunk, parent, index, arg_name_list, arg_list, docstring, scope)
    local fn_name = compiler.gensym(scope)
    return compile_named_fn(ast, f_scope, f_chunk, parent, index, fn_name, true, arg_name_list, arg_list, docstring)
  end
  SPECIALS.fn = function(ast, scope, parent)
    local f_scope = nil
    do
      local _0_0 = compiler["make-scope"](scope)
      _0_0["vararg"] = false
      f_scope = _0_0
    end
    local f_chunk = {}
    local fn_sym = utils["sym?"](ast[2])
    local multi = (fn_sym and utils["multi-sym?"](fn_sym[1]))
    local fn_name, local_3f, index = get_fn_name(ast, scope, fn_sym, multi)
    local arg_list = compiler.assert(utils["table?"](ast[index]), "expected parameters table", ast)
    compiler.assert((not multi or not multi["multi-sym-method-call"]), ("unexpected multi symbol " .. tostring(fn_name)), fn_sym)
    local function get_arg_name(arg)
      if utils["varg?"](arg) then
        compiler.assert((arg == arg_list[#arg_list]), "expected vararg as last parameter", ast)
        f_scope.vararg = true
        return "..."
      elseif (utils["sym?"](arg) and (utils.deref(arg) ~= "nil") and not utils["multi-sym?"](utils.deref(arg))) then
        return compiler["declare-local"](arg, {}, f_scope, ast)
      elseif utils["table?"](arg) then
        local raw = utils.sym(compiler.gensym(scope))
        local declared = compiler["declare-local"](raw, {}, f_scope, ast)
        compiler.destructure(arg, raw, ast, f_scope, f_chunk, {declaration = true, nomulti = true, symtype = "arg"})
        return declared
      else
        return compiler.assert(false, ("expected symbol for function parameter: %s"):format(tostring(arg)), ast[2])
      end
    end
    local arg_name_list = utils.map(arg_list, get_arg_name)
    local index0, docstring = nil, nil
    if ((type(ast[(index + 1)]) == "string") and ((index + 1) < #ast)) then
      index0, docstring = (index + 1), ast[(index + 1)]
    else
      index0, docstring = index, nil
    end
    if fn_name then
      return compile_named_fn(ast, f_scope, f_chunk, parent, index0, fn_name, local_3f, arg_name_list, arg_list, docstring)
    else
      return compile_anonymous_fn(ast, f_scope, f_chunk, parent, index0, arg_name_list, arg_list, docstring, scope)
    end
  end
  doc_special("fn", {"name?", "args", "docstring?", "..."}, "Function syntax. May optionally include a name and docstring.\nIf a name is provided, the function will be bound in the current scope.\nWhen called with the wrong number of args, excess args will be discarded\nand lacking args will be nil, use lambda for arity-checked functions.", true)
  SPECIALS.lua = function(ast, _, parent)
    compiler.assert(((#ast == 2) or (#ast == 3)), "expected 1 or 2 arguments", ast)
    if (ast[2] ~= nil) then
      table.insert(parent, {ast = ast, leaf = tostring(ast[2])})
    end
    if (ast[3] ~= nil) then
      return tostring(ast[3])
    end
  end
  SPECIALS.doc = function(ast, scope, parent)
    assert(utils.root.options.useMetadata, "can't look up doc with metadata disabled.")
    compiler.assert((#ast == 2), "expected one argument", ast)
    local target = utils.deref(ast[2])
    local special_or_macro = (scope.specials[target] or scope.macros[target])
    if special_or_macro then
      return ("print(%q)"):format(doc_2a(special_or_macro, target))
    else
      local _0_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
      local value = _0_[1]
      return ("print(require('%s').doc(%s, '%s'))"):format((utils.root.options.moduleName or "fennel"), tostring(value), tostring(ast[2]))
    end
  end
  doc_special("doc", {"x"}, "Print the docstring and arglist for a function, macro, or special form.")
  local function dot(ast, scope, parent)
    compiler.assert((1 < #ast), "expected table argument", ast)
    local len = #ast
    local _0_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
    local lhs = _0_[1]
    if (len == 2) then
      return tostring(lhs)
    else
      local indices = {}
      for i = 3, len do
        local index = ast[i]
        if ((type(index) == "string") and utils["valid-lua-identifier?"](index)) then
          table.insert(indices, ("." .. index))
        else
          local _1_ = compiler.compile1(index, scope, parent, {nval = 1})
          local index0 = _1_[1]
          table.insert(indices, ("[" .. tostring(index0) .. "]"))
        end
      end
      if (tostring(lhs):find("[{\"0-9]") or ("nil" == tostring(lhs))) then
        return ("(" .. tostring(lhs) .. ")" .. table.concat(indices))
      else
        return (tostring(lhs) .. table.concat(indices))
      end
    end
  end
  SPECIALS["."] = dot
  doc_special(".", {"tbl", "key1", "..."}, "Look up key1 in tbl table. If more args are provided, do a nested lookup.")
  SPECIALS.global = function(ast, scope, parent)
    compiler.assert((#ast == 3), "expected name and value", ast)
    compiler.destructure(ast[2], ast[3], ast, scope, parent, {forceglobal = true, nomulti = true, symtype = "global"})
    return nil
  end
  doc_special("global", {"name", "val"}, "Set name as a global with val.")
  SPECIALS.set = function(ast, scope, parent)
    compiler.assert((#ast == 3), "expected name and value", ast)
    compiler.destructure(ast[2], ast[3], ast, scope, parent, {noundef = true, symtype = "set"})
    return nil
  end
  doc_special("set", {"name", "val"}, "Set a local variable to a new value. Only works on locals using var.")
  local function set_forcibly_21_2a(ast, scope, parent)
    compiler.assert((#ast == 3), "expected name and value", ast)
    compiler.destructure(ast[2], ast[3], ast, scope, parent, {forceset = true, symtype = "set"})
    return nil
  end
  SPECIALS["set-forcibly!"] = set_forcibly_21_2a
  local function local_2a(ast, scope, parent)
    compiler.assert((#ast == 3), "expected name and value", ast)
    compiler.destructure(ast[2], ast[3], ast, scope, parent, {declaration = true, nomulti = true, symtype = "local"})
    return nil
  end
  SPECIALS["local"] = local_2a
  doc_special("local", {"name", "val"}, "Introduce new top-level immutable local.")
  SPECIALS.var = function(ast, scope, parent)
    compiler.assert((#ast == 3), "expected name and value", ast)
    compiler.destructure(ast[2], ast[3], ast, scope, parent, {declaration = true, isvar = true, nomulti = true, symtype = "var"})
    return nil
  end
  doc_special("var", {"name", "val"}, "Introduce new mutable local.")
  SPECIALS.let = function(ast, scope, parent, opts)
    local bindings = ast[2]
    local pre_syms = {}
    compiler.assert((utils["list?"](bindings) or utils["table?"](bindings)), "expected binding table", ast)
    compiler.assert(((#bindings % 2) == 0), "expected even number of name/value bindings", ast[2])
    compiler.assert((#ast >= 3), "expected body expression", ast[1])
    for _ = 1, (opts.nval or 0) do
      table.insert(pre_syms, compiler.gensym(scope))
    end
    local sub_scope = compiler["make-scope"](scope)
    local sub_chunk = {}
    for i = 1, #bindings, 2 do
      compiler.destructure(bindings[i], bindings[(i + 1)], ast, sub_scope, sub_chunk, {declaration = true, nomulti = true, symtype = "let"})
    end
    return SPECIALS["do"](ast, scope, parent, opts, 3, sub_chunk, sub_scope, pre_syms)
  end
  doc_special("let", {"[name1 val1 ... nameN valN]", "..."}, "Introduces a new scope in which a given set of local bindings are used.", true)
  local function get_prev_line(parent)
    if ("table" == type(parent)) then
      return get_prev_line((parent.leaf or parent[#parent]))
    else
      return (parent or "")
    end
  end
  local function disambiguate_3f(rootstr, parent)
    local function _1_()
      local _0_0 = get_prev_line(parent)
      if (nil ~= _0_0) then
        local prev_line = _0_0
        return prev_line:match("%)$")
      end
    end
    return (rootstr:match("^{") or _1_())
  end
  SPECIALS.tset = function(ast, scope, parent)
    compiler.assert((#ast > 3), "expected table, key, and value arguments", ast)
    local root = compiler.compile1(ast[2], scope, parent, {nval = 1})[1]
    local keys = {}
    for i = 3, (#ast - 1) do
      local _0_ = compiler.compile1(ast[i], scope, parent, {nval = 1})
      local key = _0_[1]
      table.insert(keys, tostring(key))
    end
    local value = compiler.compile1(ast[#ast], scope, parent, {nval = 1})[1]
    local rootstr = tostring(root)
    local fmtstr = nil
    if disambiguate_3f(rootstr, parent) then
      fmtstr = "do end (%s)[%s] = %s"
    else
      fmtstr = "%s[%s] = %s"
    end
    return compiler.emit(parent, fmtstr:format(rootstr, table.concat(keys, "]["), tostring(value)), ast)
  end
  doc_special("tset", {"tbl", "key1", "...", "keyN", "val"}, "Set the value of a table field. Can take additional keys to set\nnested values, but all parents must contain an existing table.")
  local function calculate_target(scope, opts)
    if not (opts.tail or opts.target or opts.nval) then
      return "iife", true, nil
    elseif (opts.nval and (opts.nval ~= 0) and not opts.target) then
      local accum = {}
      local target_exprs = {}
      for i = 1, opts.nval do
        local s = compiler.gensym(scope)
        accum[i] = s
        target_exprs[i] = utils.expr(s, "sym")
      end
      return "target", opts.tail, table.concat(accum, ", "), target_exprs
    else
      return "none", opts.tail, opts.target
    end
  end
  local function if_2a(ast, scope, parent, opts)
    local do_scope = compiler["make-scope"](scope)
    local branches = {}
    local wrapper, inner_tail, inner_target, target_exprs = calculate_target(scope, opts)
    local body_opts = {nval = opts.nval, tail = inner_tail, target = inner_target}
    local function compile_body(i)
      local chunk = {}
      local cscope = compiler["make-scope"](do_scope)
      compiler["keep-side-effects"](compiler.compile1(ast[i], cscope, chunk, body_opts), chunk, nil, ast[i])
      return {chunk = chunk, scope = cscope}
    end
    for i = 2, (#ast - 1), 2 do
      local condchunk = {}
      local res = compiler.compile1(ast[i], do_scope, condchunk, {nval = 1})
      local cond = res[1]
      local branch = compile_body((i + 1))
      branch.cond = cond
      branch.condchunk = condchunk
      branch.nested = ((i ~= 2) and (next(condchunk, nil) == nil))
      table.insert(branches, branch)
    end
    local has_else_3f = ((#ast > 3) and ((#ast % 2) == 0))
    local else_branch = (has_else_3f and compile_body(#ast))
    local s = compiler.gensym(scope)
    local buffer = {}
    local last_buffer = buffer
    for i = 1, #branches do
      local branch = branches[i]
      local fstr = nil
      if not branch.nested then
        fstr = "if %s then"
      else
        fstr = "elseif %s then"
      end
      local cond = tostring(branch.cond)
      local cond_line = nil
      if ((cond == "true") and branch.nested and (i == #branches) and not has_else_3f) then
        cond_line = "else"
      else
        cond_line = fstr:format(cond)
      end
      if branch.nested then
        compiler.emit(last_buffer, branch.condchunk, ast)
      else
        for _, v in ipairs(branch.condchunk) do
          compiler.emit(last_buffer, v, ast)
        end
      end
      compiler.emit(last_buffer, cond_line, ast)
      compiler.emit(last_buffer, branch.chunk, ast)
      if (i == #branches) then
        if has_else_3f then
          compiler.emit(last_buffer, "else", ast)
          compiler.emit(last_buffer, else_branch.chunk, ast)
        elseif (inner_target and (cond_line ~= "else")) then
          compiler.emit(last_buffer, "else", ast)
          compiler.emit(last_buffer, ("%s = nil"):format(inner_target), ast)
        end
        compiler.emit(last_buffer, "end", ast)
      elseif not branches[(i + 1)].nested then
        local next_buffer = {}
        compiler.emit(last_buffer, "else", ast)
        compiler.emit(last_buffer, next_buffer, ast)
        compiler.emit(last_buffer, "end", ast)
        last_buffer = next_buffer
      end
    end
    if (wrapper == "iife") then
      local iifeargs = ((scope.vararg and "...") or "")
      compiler.emit(parent, ("local function %s(%s)"):format(tostring(s), iifeargs), ast)
      compiler.emit(parent, buffer, ast)
      compiler.emit(parent, "end", ast)
      return utils.expr(("%s(%s)"):format(tostring(s), iifeargs), "statement")
    elseif (wrapper == "none") then
      for i = 1, #buffer do
        compiler.emit(parent, buffer[i], ast)
      end
      return {returned = true}
    else
      compiler.emit(parent, ("local %s"):format(inner_target), ast)
      for i = 1, #buffer do
        compiler.emit(parent, buffer[i], ast)
      end
      return target_exprs
    end
  end
  SPECIALS["if"] = if_2a
  doc_special("if", {"cond1", "body1", "...", "condN", "bodyN"}, "Conditional form.\nTakes any number of condition/body pairs and evaluates the first body where\nthe condition evaluates to truthy. Similar to cond in other lisps.")
  local function remove_until_condition(bindings)
    if ("until" == bindings[(#bindings - 1)]) then
      table.remove(bindings, (#bindings - 1))
      return table.remove(bindings)
    end
  end
  local function compile_until(condition, scope, chunk)
    if condition then
      local _0_ = compiler.compile1(condition, scope, chunk, {nval = 1})
      local condition_lua = _0_[1]
      return compiler.emit(chunk, ("if %s then break end"):format(tostring(condition_lua)), condition)
    end
  end
  SPECIALS.each = function(ast, scope, parent)
    compiler.assert((#ast >= 3), "expected body expression", ast[1])
    local binding = compiler.assert(utils["table?"](ast[2]), "expected binding table", ast)
    local _ = compiler.assert((2 <= #binding), "expected binding and iterator", binding)
    local until_condition = remove_until_condition(binding)
    local iter = table.remove(binding, #binding)
    local destructures = {}
    local new_manglings = {}
    local sub_scope = compiler["make-scope"](scope)
    local function destructure_binding(v)
      if utils["sym?"](v) then
        return compiler["declare-local"](v, {}, sub_scope, ast, new_manglings)
      else
        local raw = utils.sym(compiler.gensym(sub_scope))
        destructures[raw] = v
        return compiler["declare-local"](raw, {}, sub_scope, ast)
      end
    end
    local bind_vars = utils.map(binding, destructure_binding)
    local vals = compiler.compile1(iter, sub_scope, parent)
    local val_names = utils.map(vals, tostring)
    local chunk = {}
    compiler.emit(parent, ("for %s in %s do"):format(table.concat(bind_vars, ", "), table.concat(val_names, ", ")), ast)
    for raw, args in utils.stablepairs(destructures) do
      compiler.destructure(args, raw, ast, sub_scope, chunk, {declaration = true, nomulti = true, symtype = "each"})
    end
    compiler["apply-manglings"](sub_scope, new_manglings, ast)
    compile_until(until_condition, sub_scope, chunk)
    compile_do(ast, sub_scope, chunk, 3)
    compiler.emit(parent, chunk, ast)
    return compiler.emit(parent, "end", ast)
  end
  doc_special("each", {"[key value (iterator)]", "..."}, "Runs the body once for each set of values provided by the given iterator.\nMost commonly used with ipairs for sequential tables or pairs for  undefined\norder, but can be used with any iterator.", true)
  local function while_2a(ast, scope, parent)
    local len1 = #parent
    local condition = compiler.compile1(ast[2], scope, parent, {nval = 1})[1]
    local len2 = #parent
    local sub_chunk = {}
    if (len1 ~= len2) then
      for i = (len1 + 1), len2 do
        table.insert(sub_chunk, parent[i])
        parent[i] = nil
      end
      compiler.emit(parent, "while true do", ast)
      compiler.emit(sub_chunk, ("if not %s then break end"):format(condition[1]), ast)
    else
      compiler.emit(parent, ("while " .. tostring(condition) .. " do"), ast)
    end
    compile_do(ast, compiler["make-scope"](scope), sub_chunk, 3)
    compiler.emit(parent, sub_chunk, ast)
    return compiler.emit(parent, "end", ast)
  end
  SPECIALS["while"] = while_2a
  doc_special("while", {"condition", "..."}, "The classic while loop. Evaluates body until a condition is non-truthy.", true)
  local function for_2a(ast, scope, parent)
    local ranges = compiler.assert(utils["table?"](ast[2]), "expected binding table", ast)
    local until_condition = remove_until_condition(ast[2])
    local binding_sym = table.remove(ast[2], 1)
    local sub_scope = compiler["make-scope"](scope)
    local range_args = {}
    local chunk = {}
    compiler.assert(utils["sym?"](binding_sym), ("unable to bind %s %s"):format(type(binding_sym), tostring(binding_sym)), ast[2])
    compiler.assert((#ast >= 3), "expected body expression", ast[1])
    for i = 1, math.min(#ranges, 3) do
      range_args[i] = tostring(compiler.compile1(ranges[i], sub_scope, parent, {nval = 1})[1])
    end
    compiler.emit(parent, ("for %s = %s do"):format(compiler["declare-local"](binding_sym, {}, sub_scope, ast), table.concat(range_args, ", ")), ast)
    compile_until(until_condition, sub_scope, chunk)
    compile_do(ast, sub_scope, chunk, 3)
    compiler.emit(parent, chunk, ast)
    return compiler.emit(parent, "end", ast)
  end
  SPECIALS["for"] = for_2a
  doc_special("for", {"[index start stop step?]", "..."}, "Numeric loop construct.\nEvaluates body once for each value between start and stop (inclusive).", true)
  local function native_method_call(ast, _scope, _parent, target, args)
    local _0_ = ast
    local _ = _0_[1]
    local _0 = _0_[2]
    local method_string = _0_[3]
    local call_string = nil
    if ((target.type == "literal") or (target.type == "expression")) then
      call_string = "(%s):%s(%s)"
    else
      call_string = "%s:%s(%s)"
    end
    return utils.expr(string.format(call_string, tostring(target), method_string, table.concat(args, ", ")), "statement")
  end
  local function nonnative_method_call(ast, scope, parent, target, args)
    local method_string = tostring(compiler.compile1(ast[3], scope, parent, {nval = 1})[1])
    local args0 = {tostring(target), unpack(args)}
    return utils.expr(string.format("%s[%s](%s)", tostring(target), method_string, table.concat(args0, ", ")), "statement")
  end
  local function double_eval_protected_method_call(ast, scope, parent, target, args)
    local method_string = tostring(compiler.compile1(ast[3], scope, parent, {nval = 1})[1])
    local call = "(function(tgt, m, ...) return tgt[m](tgt, ...) end)(%s, %s)"
    table.insert(args, 1, method_string)
    return utils.expr(string.format(call, tostring(target), table.concat(args, ", ")), "statement")
  end
  local function method_call(ast, scope, parent)
    compiler.assert((2 < #ast), "expected at least 2 arguments", ast)
    local _0_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
    local target = _0_[1]
    local args = {}
    for i = 4, #ast do
      local subexprs = nil
      local _1_
      if (i ~= #ast) then
        _1_ = 1
      else
      _1_ = nil
      end
      subexprs = compiler.compile1(ast[i], scope, parent, {nval = _1_})
      utils.map(subexprs, tostring, args)
    end
    if ((type(ast[3]) == "string") and utils["valid-lua-identifier?"](ast[3])) then
      return native_method_call(ast, scope, parent, target, args)
    elseif (target.type == "sym") then
      return nonnative_method_call(ast, scope, parent, target, args)
    else
      return double_eval_protected_method_call(ast, scope, parent, target, args)
    end
  end
  SPECIALS[":"] = method_call
  doc_special(":", {"tbl", "method-name", "..."}, "Call the named method on tbl with the provided args.\nMethod name doesn't have to be known at compile-time; if it is, use\n(tbl:method-name ...) instead.")
  SPECIALS.comment = function(ast, _, parent)
    local els = {}
    for i = 2, #ast do
      local function _1_()
        local _0_0 = tostring(ast[i]):gsub("\n", " ")
        return _0_0
      end
      table.insert(els, _1_())
    end
    return compiler.emit(parent, ("-- " .. table.concat(els, " ")), ast)
  end
  doc_special("comment", {"..."}, "Comment which will be emitted in Lua output.", true)
  local function hashfn_max_used(f_scope, i, max)
    local max0 = nil
    if f_scope.symmeta[("$" .. i)].used then
      max0 = i
    else
      max0 = max
    end
    if (i < 9) then
      return hashfn_max_used(f_scope, (i + 1), max0)
    else
      return max0
    end
  end
  SPECIALS.hashfn = function(ast, scope, parent)
    compiler.assert((#ast == 2), "expected one argument", ast)
    local f_scope = nil
    do
      local _0_0 = compiler["make-scope"](scope)
      _0_0["vararg"] = false
      _0_0["hashfn"] = true
      f_scope = _0_0
    end
    local f_chunk = {}
    local name = compiler.gensym(scope)
    local symbol = utils.sym(name)
    local args = {}
    compiler["declare-local"](symbol, {}, scope, ast)
    for i = 1, 9 do
      args[i] = compiler["declare-local"](utils.sym(("$" .. i)), {}, f_scope, ast)
    end
    local function walker(idx, node, parent_node)
      if (utils["sym?"](node) and (utils.deref(node) == "$...")) then
        parent_node[idx] = utils.varg()
        f_scope.vararg = true
        return nil
      else
        return (utils["list?"](node) or utils["table?"](node))
      end
    end
    utils["walk-tree"](ast[2], walker)
    compiler.compile1(ast[2], f_scope, f_chunk, {tail = true})
    local max_used = hashfn_max_used(f_scope, 1, 0)
    if f_scope.vararg then
      compiler.assert((max_used == 0), "$ and $... in hashfn are mutually exclusive", ast)
    end
    local arg_str = nil
    if f_scope.vararg then
      arg_str = utils.deref(utils.varg())
    else
      arg_str = table.concat(args, ", ", 1, max_used)
    end
    compiler.emit(parent, string.format("local function %s(%s)", name, arg_str), ast)
    compiler.emit(parent, f_chunk, ast)
    compiler.emit(parent, "end", ast)
    return utils.expr(name, "sym")
  end
  doc_special("hashfn", {"..."}, "Function literal shorthand; args are either $... OR $1, $2, etc.")
  local function arithmetic_special(name, zero_arity, unary_prefix, ast, scope, parent)
    local len = #ast
    if (len == 1) then
      compiler.assert(zero_arity, "Expected more than 0 arguments", ast)
      return utils.expr(zero_arity, "literal")
    else
      local operands = {}
      local padded_op = (" " .. name .. " ")
      for i = 2, len do
        local subexprs = nil
        local _0_
        if (i ~= len) then
          _0_ = 1
        else
        _0_ = nil
        end
        subexprs = compiler.compile1(ast[i], scope, parent, {nval = _0_})
        utils.map(subexprs, tostring, operands)
      end
      if (#operands == 1) then
        if unary_prefix then
          return ("(" .. unary_prefix .. padded_op .. operands[1] .. ")")
        else
          return operands[1]
        end
      else
        return ("(" .. table.concat(operands, padded_op) .. ")")
      end
    end
  end
  local function define_arithmetic_special(name, zero_arity, unary_prefix, lua_name)
    local function _0_(...)
      return arithmetic_special((lua_name or name), zero_arity, unary_prefix, ...)
    end
    SPECIALS[name] = _0_
    return doc_special(name, {"a", "b", "..."}, "Arithmetic operator; works the same as Lua but accepts more arguments.")
  end
  define_arithmetic_special("+", "0")
  define_arithmetic_special("..", "''")
  define_arithmetic_special("^")
  define_arithmetic_special("-", nil, "")
  define_arithmetic_special("*", "1")
  define_arithmetic_special("%")
  define_arithmetic_special("/", nil, "1")
  define_arithmetic_special("//", nil, "1")
  local function bitop_special(native_name, lib_name, zero_arity, unary_prefix, ast, scope, parent)
    if (#ast == 1) then
      return compiler.assert(zero_arity, "Expected more than 0 arguments.", ast)
    else
      local len = #ast
      local operands = {}
      local padded_native_name = (" " .. native_name .. " ")
      local prefixed_lib_name = ("bit." .. lib_name)
      for i = 2, len do
        local subexprs = nil
        local _0_
        if (i ~= len) then
          _0_ = 1
        else
        _0_ = nil
        end
        subexprs = compiler.compile1(ast[i], scope, parent, {nval = _0_})
        utils.map(subexprs, tostring, operands)
      end
      if (#operands == 1) then
        if utils.root.options.useBitLib then
          return (prefixed_lib_name .. "(" .. unary_prefix .. ", " .. operands[1] .. ")")
        else
          return ("(" .. unary_prefix .. padded_native_name .. operands[1] .. ")")
        end
      else
        if utils.root.options.useBitLib then
          return (prefixed_lib_name .. "(" .. table.concat(operands, ", ") .. ")")
        else
          return ("(" .. table.concat(operands, padded_native_name) .. ")")
        end
      end
    end
  end
  local function define_bitop_special(name, zero_arity, unary_prefix, native)
    local function _0_(...)
      return bitop_special(native, name, zero_arity, unary_prefix, ...)
    end
    SPECIALS[name] = _0_
    return nil
  end
  define_bitop_special("lshift", nil, "1", "<<")
  define_bitop_special("rshift", nil, "1", ">>")
  define_bitop_special("band", "0", "0", "&")
  define_bitop_special("bor", "0", "0", "|")
  define_bitop_special("bxor", "0", "0", "~")
  doc_special("lshift", {"x", "n"}, "Bitwise logical left shift of x by n bits.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
  doc_special("rshift", {"x", "n"}, "Bitwise logical right shift of x by n bits.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
  doc_special("band", {"x1", "x2", "..."}, "Bitwise AND of any number of arguments.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
  doc_special("bor", {"x1", "x2", "..."}, "Bitwise OR of any number of arguments.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
  doc_special("bxor", {"x1", "x2", "..."}, "Bitwise XOR of any number of arguments.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
  define_arithmetic_special("or", "false")
  define_arithmetic_special("and", "true")
  doc_special("and", {"a", "b", "..."}, "Boolean operator; works the same as Lua but accepts more arguments.")
  doc_special("or", {"a", "b", "..."}, "Boolean operator; works the same as Lua but accepts more arguments.")
  doc_special("..", {"a", "b", "..."}, "String concatenation operator; works the same as Lua but accepts more arguments.")
  local function native_comparator(op, _0_0, scope, parent)
    local _1_ = _0_0
    local _ = _1_[1]
    local lhs_ast = _1_[2]
    local rhs_ast = _1_[3]
    local _2_ = compiler.compile1(lhs_ast, scope, parent, {nval = 1})
    local lhs = _2_[1]
    local _3_ = compiler.compile1(rhs_ast, scope, parent, {nval = 1})
    local rhs = _3_[1]
    return string.format("(%s %s %s)", tostring(lhs), op, tostring(rhs))
  end
  local function double_eval_protected_comparator(op, chain_op, ast, scope, parent)
    local arglist = {}
    local comparisons = {}
    local vals = {}
    local chain = string.format(" %s ", (chain_op or "and"))
    for i = 2, #ast do
      table.insert(arglist, tostring(compiler.gensym(scope)))
      table.insert(vals, tostring(compiler.compile1(ast[i], scope, parent, {nval = 1})[1]))
    end
    for i = 1, (#arglist - 1) do
      table.insert(comparisons, string.format("(%s %s %s)", arglist[i], op, arglist[(i + 1)]))
    end
    return string.format("(function(%s) return %s end)(%s)", table.concat(arglist, ","), table.concat(comparisons, chain), table.concat(vals, ","))
  end
  local function define_comparator_special(name, lua_op, chain_op)
    do
      local op = (lua_op or name)
      local function opfn(ast, scope, parent)
        compiler.assert((2 < #ast), "expected at least two arguments", ast)
        if (3 == #ast) then
          return native_comparator(op, ast, scope, parent)
        else
          return double_eval_protected_comparator(op, chain_op, ast, scope, parent)
        end
      end
      SPECIALS[name] = opfn
    end
    return doc_special(name, {"a", "b", "..."}, "Comparison operator; works the same as Lua but accepts more arguments.")
  end
  define_comparator_special(">")
  define_comparator_special("<")
  define_comparator_special(">=")
  define_comparator_special("<=")
  define_comparator_special("=", "==")
  define_comparator_special("not=", "~=", "or")
  local function define_unary_special(op, realop)
    local function opfn(ast, scope, parent)
      compiler.assert((#ast == 2), "expected one argument", ast)
      local tail = compiler.compile1(ast[2], scope, parent, {nval = 1})
      return ((realop or op) .. tostring(tail[1]))
    end
    SPECIALS[op] = opfn
    return nil
  end
  define_unary_special("not", "not ")
  doc_special("not", {"x"}, "Logical operator; works the same as Lua.")
  define_unary_special("bnot", "~")
  doc_special("bnot", {"x"}, "Bitwise negation; only works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
  define_unary_special("length", "#")
  doc_special("length", {"x"}, "Returns the length of a table or string.")
  SPECIALS["~="] = SPECIALS["not="]
  SPECIALS["#"] = SPECIALS.length
  SPECIALS.quote = function(ast, scope, parent)
    compiler.assert((#ast == 2), "expected one argument")
    local runtime, this_scope = true, scope
    while this_scope do
      this_scope = this_scope.parent
      if (this_scope == compiler.scopes.compiler) then
        runtime = false
      end
    end
    return compiler["do-quote"](ast[2], scope, parent, runtime)
  end
  doc_special("quote", {"x"}, "Quasiquote the following form. Only works in macro/compiler scope.")
  local already_warned_3f = {}
  local compile_env_warning = table.concat({"WARNING: Attempting to %s %s in compile scope.", "In future versions of Fennel this will not be allowed without the", "--no-compiler-sandbox flag or passing a :compilerEnv globals table", "in the options.\n"}, "\n")
  local function compiler_env_warn(_, key)
    local v = _G[key]
    if (v and io and io.stderr and not already_warned_3f[key]) then
      already_warned_3f[key] = true
      do end (io.stderr):write(compile_env_warning:format("use global", key))
    end
    return v
  end
  local function safe_getmetatable(tbl)
    local mt = getmetatable(tbl)
    assert((mt ~= getmetatable("")), "Illegal metatable access!")
    return mt
  end
  local safe_require = nil
  local function safe_compiler_env(strict_3f)
    local _1_
    if strict_3f then
      _1_ = nil
    else
      _1_ = compiler_env_warn
    end
    return setmetatable({assert = assert, bit = rawget(_G, "bit"), error = error, getmetatable = safe_getmetatable, ipairs = ipairs, math = utils.copy(math), next = next, pairs = pairs, pcall = pcall, print = print, rawequal = rawequal, rawget = rawget, rawlen = rawget(_G, "rawlen"), rawset = rawset, require = safe_require, select = select, setmetatable = setmetatable, string = utils.copy(string), table = utils.copy(table), tonumber = tonumber, tostring = tostring, type = type, xpcall = xpcall}, {__index = _1_})
  end
  local function make_compiler_env(ast, scope, parent, strict_3f)
    local function _1_()
      return compiler.scopes.macro
    end
    local function _2_(symbol)
      compiler.assert(compiler.scopes.macro, "must call from macro", ast)
      return compiler.scopes.macro.manglings[tostring(symbol)]
    end
    local function _3_(base)
      return utils.sym(compiler.gensym((compiler.scopes.macro or scope), base))
    end
    local function _4_(form)
      compiler.assert(compiler.scopes.macro, "must call from macro", ast)
      return compiler.macroexpand(form, compiler.scopes.macro)
    end
    local _6_
    do
      local _5_0 = utils.root.options
      if ((type(_5_0) == "table") and (_5_0["compiler-env"] == "strict")) then
        _6_ = safe_compiler_env(true)
      elseif ((type(_5_0) == "table") and (nil ~= _5_0.compilerEnv)) then
        local compilerEnv = _5_0.compilerEnv
        _6_ = compilerEnv
      elseif ((type(_5_0) == "table") and (nil ~= _5_0["compiler-env"])) then
        local compiler_env = _5_0["compiler-env"]
        _6_ = compiler_env
      else
        local _ = _5_0
        _6_ = safe_compiler_env(false)
      end
    end
    return setmetatable({["assert-compile"] = compiler.assert, ["get-scope"] = _1_, ["in-scope?"] = _2_, ["list?"] = utils["list?"], ["multi-sym?"] = utils["multi-sym?"], ["sequence?"] = utils["sequence?"], ["sym?"] = utils["sym?"], ["table?"] = utils["table?"], ["varg?"] = utils["varg?"], _AST = ast, _CHUNK = parent, _IS_COMPILER = true, _SCOPE = scope, _SPECIALS = compiler.scopes.global.specials, _VARARG = utils.varg(), gensym = _3_, list = utils.list, macroexpand = _4_, sequence = utils.sequence, sym = utils.sym, unpack = unpack, view = view}, {__index = _6_})
  end
  local cfg = string.gmatch(package.config, "([^\n]+)")
  local dirsep, pathsep, pathmark = (cfg() or "/"), (cfg() or ";"), (cfg() or "?")
  local pkg_config = {dirsep = dirsep, pathmark = pathmark, pathsep = pathsep}
  local function escapepat(str)
    return string.gsub(str, "[^%w]", "%%%1")
  end
  local function search_module(modulename, pathstring)
    local pathsepesc = escapepat(pkg_config.pathsep)
    local pattern = ("([^%s]*)%s"):format(pathsepesc, pathsepesc)
    local no_dot_module = modulename:gsub("%.", pkg_config.dirsep)
    local fullpath = ((pathstring or utils["fennel-module"].path) .. pkg_config.pathsep)
    local function try_path(path)
      local filename = path:gsub(escapepat(pkg_config.pathmark), no_dot_module)
      local filename2 = path:gsub(escapepat(pkg_config.pathmark), modulename)
      local _1_0 = (io.open(filename) or io.open(filename2))
      if (nil ~= _1_0) then
        local file = _1_0
        file:close()
        return filename
      end
    end
    local function find_in_path(start)
      local _1_0 = fullpath:match(pattern, start)
      if (nil ~= _1_0) then
        local path = _1_0
        return (try_path(path) or find_in_path((start + #path + 1)))
      end
    end
    return find_in_path(1)
  end
  local function make_searcher(options)
    local function _1_(module_name)
      local opts = utils.copy(utils.root.options)
      for k, v in pairs((options or {})) do
        opts[k] = v
      end
      opts["module-name"] = module_name
      local _2_0 = search_module(module_name)
      if (nil ~= _2_0) then
        local filename = _2_0
        local function _3_(...)
          return utils["fennel-module"].dofile(filename, opts, ...)
        end
        return _3_, filename
      end
    end
    return _1_
  end
  local function macro_globals(env, globals)
    local allowed = current_global_names(env)
    for _, k in pairs((globals or {})) do
      table.insert(allowed, k)
    end
    return allowed
  end
  local function default_macro_searcher(module_name)
    local _1_0 = search_module(module_name)
    if (nil ~= _1_0) then
      local filename = _1_0
      local function _2_(...)
        return utils["fennel-module"].dofile(filename, {env = "_COMPILER"}, ...)
      end
      return _2_, filename
    end
  end
  local macro_searchers = {default_macro_searcher}
  local function search_macro_module(modname, n)
    local _1_0 = macro_searchers[n]
    if (nil ~= _1_0) then
      local f = _1_0
      local _2_0, _3_0 = f(modname)
      if ((nil ~= _2_0) and true) then
        local loader = _2_0
        local _3ffilename = _3_0
        return loader, _3ffilename
      else
        local _ = _2_0
        return search_macro_module(modname, (n + 1))
      end
    end
  end
  local macro_loaded = {}
  local function metadata_only_fennel(modname)
    if ((modname == "nvim-tree-docs.aniseed.fennel.macros") or (package and package.loaded and ("table" == type(package.loaded[modname])) and (package.loaded[modname].metadata == compiler.metadata))) then
      return {metadata = compiler.metadata}
    end
  end
  local function _1_(modname)
    local function _2_()
      local loader, filename = search_macro_module(modname, 1)
      compiler.assert(loader, (modname .. " module not found."))
      macro_loaded[modname] = loader(modname, filename)
      return macro_loaded[modname]
    end
    return (macro_loaded[modname] or metadata_only_fennel(modname) or _2_())
  end
  safe_require = _1_
  local function add_macros(macros_2a, ast, scope)
    compiler.assert(utils["table?"](macros_2a), "expected macros to be table", ast)
    for k, v in pairs(macros_2a) do
      compiler.assert((type(v) == "function"), "expected each macro to be function", ast)
      scope.macros[k] = v
    end
    return nil
  end
  SPECIALS["require-macros"] = function(ast, scope, parent, real_ast)
    compiler.assert((#ast == 2), "Expected one module name argument", (real_ast or ast))
    local filename = (ast[2].filename or ast.filename)
    local modname_chunk = load_code(compiler.compile(ast[2]), nil, filename)
    local modname = modname_chunk(utils.root.options["module-name"], filename)
    compiler.assert((type(modname) == "string"), "module name must compile to string", (real_ast or ast))
    if not macro_loaded[modname] then
      local env = make_compiler_env(ast, scope, parent)
      local loader, filename0 = search_macro_module(modname, 1)
      compiler.assert(loader, (modname .. " module not found."), ast)
      macro_loaded[modname] = loader(modname, filename0)
    end
    return add_macros(macro_loaded[modname], ast, scope, parent)
  end
  doc_special("require-macros", {"macro-module-name"}, "Load given module and use its contents as macro definitions in current scope.\nMacro module should return a table of macro functions with string keys.\nConsider using import-macros instead as it is more flexible.")
  local function emit_included_fennel(src, path, opts, sub_chunk)
    local subscope = compiler["make-scope"](utils.root.scope.parent)
    local forms = {}
    if utils.root.options.requireAsInclude then
      subscope.specials.require = compiler["require-include"]
    end
    for _, val in parser.parser(parser["string-stream"](src), path) do
      table.insert(forms, val)
    end
    for i = 1, #forms do
      local subopts = nil
      if (i == #forms) then
        subopts = {tail = true}
      else
        subopts = {nval = 0}
      end
      utils["propagate-options"](opts, subopts)
      compiler.compile1(forms[i], subscope, sub_chunk, subopts)
    end
    return nil
  end
  local function include_path(ast, opts, path, mod, fennel_3f)
    utils.root.scope.includes[mod] = "fnl/loading"
    local src = nil
    do
      local f = assert(io.open(path))
      local function close_handlers_0_(ok_0_, ...)
        f:close()
        if ok_0_ then
          return ...
        else
          return error(..., 0)
        end
      end
      local function _2_()
        return f:read("*all"):gsub("[\13\n]*$", "")
      end
      src = close_handlers_0_(xpcall(_2_, (package.loaded.fennel or debug).traceback))
    end
    local ret = utils.expr(("require(\"" .. mod .. "\")"), "statement")
    local target = ("package.preload[%q]"):format(mod)
    local preload_str = (target .. " = " .. target .. " or function(...)")
    local temp_chunk, sub_chunk = {}, {}
    compiler.emit(temp_chunk, preload_str, ast)
    compiler.emit(temp_chunk, sub_chunk)
    compiler.emit(temp_chunk, "end", ast)
    for i, v in ipairs(temp_chunk) do
      table.insert(utils.root.chunk, i, v)
    end
    if fennel_3f then
      emit_included_fennel(src, path, opts, sub_chunk)
    else
      compiler.emit(sub_chunk, src, ast)
    end
    utils.root.scope.includes[mod] = ret
    return ret
  end
  local function include_circular_fallback(mod, modexpr, fallback, ast)
    if (utils.root.scope.includes[mod] == "fnl/loading") then
      compiler.assert(fallback, "circular include detected", ast)
      return fallback(modexpr)
    end
  end
  SPECIALS.include = function(ast, scope, parent, opts)
    compiler.assert((#ast == 2), "expected one argument", ast)
    local modexpr = compiler.compile1(ast[2], scope, parent, {nval = 1})[1]
    if ((modexpr.type ~= "literal") or ((modexpr[1]):byte() ~= 34)) then
      if opts.fallback then
        return opts.fallback(modexpr)
      else
        return compiler.assert(false, "module name must be string literal", ast)
      end
    else
      local mod = load_code(("return " .. modexpr[1]))()
      local function _3_()
        local _2_0 = search_module(mod)
        if (nil ~= _2_0) then
          local fennel_path = _2_0
          return include_path(ast, opts, fennel_path, mod, true)
        else
          local _ = _2_0
          local lua_path = search_module(mod, package.path)
          if lua_path then
            return include_path(ast, opts, lua_path, mod, false)
          elseif opts.fallback then
            return opts.fallback(modexpr)
          else
            return compiler.assert(false, ("module not found " .. mod), ast)
          end
        end
      end
      return (include_circular_fallback(mod, modexpr, opts.fallback, ast) or utils.root.scope.includes[mod] or _3_())
    end
  end
  doc_special("include", {"module-name-literal"}, "Like require but load the target module during compilation and embed it in the\nLua output. The module must be a string literal and resolvable at compile time.")
  local function eval_compiler_2a(ast, scope, parent)
    local env = make_compiler_env(ast, scope, parent)
    local opts = utils.copy(utils.root.options)
    opts.scope = compiler["make-scope"](compiler.scopes.compiler)
    opts.allowedGlobals = macro_globals(env, current_global_names())
    return load_code(compiler.compile(ast, opts), wrap_env(env))(opts["module-name"], ast.filename)
  end
  SPECIALS.macros = function(ast, scope, parent)
    compiler.assert((#ast == 2), "Expected one table argument", ast)
    return add_macros(eval_compiler_2a(ast[2], scope, parent), ast, scope, parent)
  end
  doc_special("macros", {"{:macro-name-1 (fn [...] ...) ... :macro-name-N macro-body-N}"}, "Define all functions in the given table as macros local to the current scope.")
  SPECIALS["eval-compiler"] = function(ast, scope, parent)
    local old_first = ast[1]
    ast[1] = utils.sym("do")
    local val = eval_compiler_2a(ast, scope, parent)
    ast[1] = old_first
    return val
  end
  doc_special("eval-compiler", {"..."}, "Evaluate the body at compile-time. Use the macro system instead if possible.", true)
  return {["current-global-names"] = current_global_names, ["load-code"] = load_code, ["macro-loaded"] = macro_loaded, ["macro-searchers"] = macro_searchers, ["make-compiler-env"] = make_compiler_env, ["make-searcher"] = make_searcher, ["search-module"] = search_module, ["wrap-env"] = wrap_env, doc = doc_2a}
end
package.preload["nvim-tree-docs.aniseed.fennel.compiler"] = package.preload["nvim-tree-docs.aniseed.fennel.compiler"] or function(...)
  local utils = require("nvim-tree-docs.aniseed.fennel.utils")
  local parser = require("nvim-tree-docs.aniseed.fennel.parser")
  local friend = require("nvim-tree-docs.aniseed.fennel.friend")
  local unpack = (table.unpack or _G.unpack)
  local scopes = {}
  local function make_scope(parent)
    local parent0 = (parent or scopes.global)
    local _0_
    if parent0 then
      _0_ = ((parent0.depth or 0) + 1)
    else
      _0_ = 0
    end
    return {autogensyms = setmetatable({}, {__index = (parent0 and parent0.autogensyms)}), depth = _0_, gensyms = setmetatable({}, {__index = (parent0 and parent0.gensyms)}), hashfn = (parent0 and parent0.hashfn), includes = setmetatable({}, {__index = (parent0 and parent0.includes)}), macros = setmetatable({}, {__index = (parent0 and parent0.macros)}), manglings = setmetatable({}, {__index = (parent0 and parent0.manglings)}), parent = parent0, refedglobals = setmetatable({}, {__index = (parent0 and parent0.refedglobals)}), specials = setmetatable({}, {__index = (parent0 and parent0.specials)}), symmeta = setmetatable({}, {__index = (parent0 and parent0.symmeta)}), unmanglings = setmetatable({}, {__index = (parent0 and parent0.unmanglings)}), vararg = (parent0 and parent0.vararg)}
  end
  local function assert_msg(ast, msg)
    local ast_tbl = nil
    if ("table" == type(ast)) then
      ast_tbl = ast
    else
      ast_tbl = {}
    end
    local m = getmetatable(ast)
    local filename = ((m and m.filename) or ast_tbl.filename or "unknown")
    local line = ((m and m.line) or ast_tbl.line or "?")
    local target = nil
    local function _1_()
      if utils["sym?"](ast_tbl[1]) then
        return utils.deref(ast_tbl[1])
      else
        return (ast_tbl[1] or "()")
      end
    end
    target = tostring(_1_())
    return string.format("Compile error in '%s' %s:%s: %s", target, filename, line, msg)
  end
  local function assert_compile(condition, msg, ast)
    if not condition then
      local _0_ = (utils.root.options or {})
      local source = _0_["source"]
      local unfriendly = _0_["unfriendly"]
      utils.root.reset()
      if unfriendly then
        error(assert_msg(ast, msg), 0)
      else
        friend["assert-compile"](condition, msg, ast, source)
      end
    end
    return condition
  end
  scopes.global = make_scope()
  scopes.global.vararg = true
  scopes.compiler = make_scope(scopes.global)
  scopes.macro = scopes.global
  local serialize_subst = {["\11"] = "\\v", ["\12"] = "\\f", ["\7"] = "\\a", ["\8"] = "\\b", ["\9"] = "\\t", ["\n"] = "n"}
  local function serialize_string(str)
    local function _0_(_241)
      return ("\\" .. _241:byte())
    end
    return string.gsub(string.gsub(string.format("%q", str), ".", serialize_subst), "[\128-\255]", _0_)
  end
  local function global_mangling(str)
    if utils["valid-lua-identifier?"](str) then
      return str
    else
      local function _0_(_241)
        return string.format("_%02x", _241:byte())
      end
      return ("__fnl_global__" .. str:gsub("[^%w]", _0_))
    end
  end
  local function global_unmangling(identifier)
    local _0_0 = string.match(identifier, "^__fnl_global__(.*)$")
    if (nil ~= _0_0) then
      local rest = _0_0
      local _1_0 = nil
      local function _2_(_241)
        return string.char(tonumber(_241:sub(2), 16))
      end
      _1_0 = string.gsub(rest, "_[%da-f][%da-f]", _2_)
      return _1_0
    else
      local _ = _0_0
      return identifier
    end
  end
  local allowed_globals = nil
  local function global_allowed_3f(name)
    return (not allowed_globals or utils["member?"](name, allowed_globals))
  end
  local function unique_mangling(original, mangling, scope, append)
    if (scope.unmanglings[mangling] and not scope.gensyms[mangling]) then
      return unique_mangling(original, (original .. append), scope, (append + 1))
    else
      return mangling
    end
  end
  local function local_mangling(str, scope, ast, temp_manglings)
    assert_compile(not utils["multi-sym?"](str), ("unexpected multi symbol " .. str), ast)
    local raw = nil
    if (utils["lua-keywords"][str] or str:match("^%d")) then
      raw = ("_" .. str)
    else
      raw = str
    end
    local mangling = nil
    local function _1_(_241)
      return string.format("_%02x", _241:byte())
    end
    mangling = string.gsub(string.gsub(raw, "-", "_"), "[^%w_]", _1_)
    local unique = unique_mangling(mangling, mangling, scope, 0)
    scope.unmanglings[unique] = str
    do
      local manglings = (temp_manglings or scope.manglings)
      manglings[str] = unique
    end
    return unique
  end
  local function apply_manglings(scope, new_manglings, ast)
    for raw, mangled in pairs(new_manglings) do
      assert_compile(not scope.refedglobals[mangled], ("use of global " .. raw .. " is aliased by a local"), ast)
      scope.manglings[raw] = mangled
    end
    return nil
  end
  local function combine_parts(parts, scope)
    local ret = (scope.manglings[parts[1]] or global_mangling(parts[1]))
    for i = 2, #parts do
      if utils["valid-lua-identifier?"](parts[i]) then
        if (parts["multi-sym-method-call"] and (i == #parts)) then
          ret = (ret .. ":" .. parts[i])
        else
          ret = (ret .. "." .. parts[i])
        end
      else
        ret = (ret .. "[" .. serialize_string(parts[i]) .. "]")
      end
    end
    return ret
  end
  local function gensym(scope, base)
    local append, mangling = 0, ((base or "") .. "_0_")
    while scope.unmanglings[mangling] do
      mangling = ((base or "") .. "_" .. append .. "_")
      append = (append + 1)
    end
    scope.unmanglings[mangling] = (base or true)
    scope.gensyms[mangling] = true
    return mangling
  end
  local function autogensym(base, scope)
    local _0_0 = utils["multi-sym?"](base)
    if (nil ~= _0_0) then
      local parts = _0_0
      parts[1] = autogensym(parts[1], scope)
      return table.concat(parts, ((parts["multi-sym-method-call"] and ":") or "."))
    else
      local _ = _0_0
      local function _1_()
        local mangling = gensym(scope, base:sub(1, ( - 2)))
        scope.autogensyms[base] = mangling
        return mangling
      end
      return (scope.autogensyms[base] or _1_())
    end
  end
  local already_warned = {}
  local function check_binding_valid(symbol, scope, ast)
    local name = utils.deref(symbol)
    if (io and io.stderr and name:find("&") and not already_warned[symbol]) then
      already_warned[symbol] = true
      do end (io.stderr):write(("-- Warning: & will not be allowed in identifier names in " .. "future versions: " .. (symbol.filename or "unknown") .. ":" .. (symbol.line or "?") .. "\n"))
    end
    assert_compile(not (scope.specials[name] or scope.macros[name]), ("local %s was overshadowed by a special form or macro"):format(name), ast)
    return assert_compile(not utils["quoted?"](symbol), string.format("macro tried to bind %s without gensym", name), symbol)
  end
  local function declare_local(symbol, meta, scope, ast, temp_manglings)
    check_binding_valid(symbol, scope, ast)
    local name = utils.deref(symbol)
    assert_compile(not utils["multi-sym?"](name), ("unexpected multi symbol " .. name), ast)
    scope.symmeta[name] = meta
    return local_mangling(name, scope, ast, temp_manglings)
  end
  local function hashfn_arg_name(name, multi_sym_parts, scope)
    if not scope.hashfn then
      return nil
    elseif (name == "$") then
      return "$1"
    elseif multi_sym_parts then
      if (multi_sym_parts and (multi_sym_parts[1] == "$")) then
        multi_sym_parts[1] = "$1"
      end
      return table.concat(multi_sym_parts, ".")
    end
  end
  local function symbol_to_expression(symbol, scope, reference_3f)
    utils.hook("symbol-to-expression", symbol, scope, reference_3f)
    local name = symbol[1]
    local multi_sym_parts = utils["multi-sym?"](name)
    local name0 = (hashfn_arg_name(name, multi_sym_parts, scope) or name)
    local parts = (multi_sym_parts or {name0})
    local etype = (((#parts > 1) and "expression") or "sym")
    local local_3f = scope.manglings[parts[1]]
    if (local_3f and scope.symmeta[parts[1]]) then
      scope.symmeta[parts[1]]["used"] = true
    end
    assert_compile((not reference_3f or local_3f or ("_ENV" == parts[1]) or global_allowed_3f(parts[1])), ("unknown global in strict mode: " .. tostring(parts[1])), symbol)
    if (allowed_globals and not local_3f) then
      utils.root.scope.refedglobals[parts[1]] = true
    end
    return utils.expr(combine_parts(parts, scope), etype)
  end
  local function emit(chunk, out, ast)
    if (type(out) == "table") then
      return table.insert(chunk, out)
    else
      return table.insert(chunk, {ast = ast, leaf = out})
    end
  end
  local function peephole(chunk)
    if chunk.leaf then
      return chunk
    elseif ((#chunk >= 3) and (chunk[(#chunk - 2)].leaf == "do") and not chunk[(#chunk - 1)].leaf and (chunk[#chunk].leaf == "end")) then
      local kid = peephole(chunk[(#chunk - 1)])
      local new_chunk = {ast = chunk.ast}
      for i = 1, (#chunk - 3) do
        table.insert(new_chunk, peephole(chunk[i]))
      end
      for i = 1, #kid do
        table.insert(new_chunk, kid[i])
      end
      return new_chunk
    else
      return utils.map(chunk, peephole)
    end
  end
  local function ast_source(ast)
    local m = getmetatable(ast)
    return ((m and m.line and m) or (("table" == type(ast)) and ast) or {})
  end
  local function flatten_chunk_correlated(main_chunk, options)
    local function flatten(chunk, out, last_line, file)
      local last_line0 = last_line
      if chunk.leaf then
        out[last_line0] = ((out[last_line0] or "") .. " " .. chunk.leaf)
      else
        for _, subchunk in ipairs(chunk) do
          if (subchunk.leaf or (#subchunk > 0)) then
            local source = ast_source(subchunk.ast)
            if (file == source.filename) then
              last_line0 = math.max(last_line0, (source.line or 0))
            end
            last_line0 = flatten(subchunk, out, last_line0, file)
          end
        end
      end
      return last_line0
    end
    local out = {}
    local last = flatten(main_chunk, out, 1, options.filename)
    for i = 1, last do
      if (out[i] == nil) then
        out[i] = ""
      end
    end
    return table.concat(out, "\n")
  end
  local function flatten_chunk(sm, chunk, tab, depth)
    if chunk.leaf then
      local code = chunk.leaf
      local info = chunk.ast
      if sm then
        table.insert(sm, {(info and info.filename), (info and info.line)})
      end
      return code
    else
      local tab0 = nil
      do
        local _0_0 = tab
        if (_0_0 == true) then
          tab0 = "  "
        elseif (_0_0 == false) then
          tab0 = ""
        elseif (_0_0 == tab) then
          tab0 = tab
        elseif (_0_0 == nil) then
          tab0 = ""
        else
        tab0 = nil
        end
      end
      local function parter(c)
        if (c.leaf or (#c > 0)) then
          local sub = flatten_chunk(sm, c, tab0, (depth + 1))
          if (depth > 0) then
            return (tab0 .. sub:gsub("\n", ("\n" .. tab0)))
          else
            return sub
          end
        end
      end
      return table.concat(utils.map(chunk, parter), "\n")
    end
  end
  local fennel_sourcemap = {}
  local function make_short_src(source)
    local source0 = source:gsub("\n", " ")
    if (#source0 <= 49) then
      return ("[fennel \"" .. source0 .. "\"]")
    else
      return ("[fennel \"" .. source0:sub(1, 46) .. "...\"]")
    end
  end
  local function flatten(chunk, options)
    local chunk0 = peephole(chunk)
    if options.correlate then
      return flatten_chunk_correlated(chunk0, options), {}
    else
      local sm = {}
      local ret = flatten_chunk(sm, chunk0, options.indent, 0)
      if sm then
        sm.short_src = (options.filename or make_short_src((options.source or ret)))
        if options.filename then
          sm.key = ("@" .. options.filename)
        else
          sm.key = ret
        end
        fennel_sourcemap[sm.key] = sm
      end
      return ret, sm
    end
  end
  local function make_metadata()
    local function _0_(self, tgt, key)
      if self[tgt] then
        return self[tgt][key]
      end
    end
    local function _1_(self, tgt, key, value)
      self[tgt] = (self[tgt] or {})
      self[tgt][key] = value
      return tgt
    end
    local function _2_(self, tgt, ...)
      local kv_len = select("#", ...)
      local kvs = {...}
      if ((kv_len % 2) ~= 0) then
        error("metadata:setall() expected even number of k/v pairs")
      end
      self[tgt] = (self[tgt] or {})
      for i = 1, kv_len, 2 do
        self[tgt][kvs[i]] = kvs[(i + 1)]
      end
      return tgt
    end
    return setmetatable({}, {__index = {get = _0_, set = _1_, setall = _2_}, __mode = "k"})
  end
  local function exprs1(exprs)
    return table.concat(utils.map(exprs, 1), ", ")
  end
  local function keep_side_effects(exprs, chunk, start, ast)
    local start0 = (start or 1)
    for j = start0, #exprs do
      local se = exprs[j]
      if ((se.type == "expression") and (se[1] ~= "nil")) then
        emit(chunk, string.format("do local _ = %s end", tostring(se)), ast)
      elseif (se.type == "statement") then
        local code = tostring(se)
        local disambiguated = nil
        if (code:byte() == 40) then
          disambiguated = ("do end " .. code)
        else
          disambiguated = code
        end
        emit(chunk, disambiguated, ast)
      end
    end
    return nil
  end
  local function handle_compile_opts(exprs, parent, opts, ast)
    if opts.nval then
      local n = opts.nval
      local len = #exprs
      if (n ~= len) then
        if (len > n) then
          keep_side_effects(exprs, parent, (n + 1), ast)
          for i = (n + 1), len do
            exprs[i] = nil
          end
        else
          for i = (#exprs + 1), n do
            exprs[i] = utils.expr("nil", "literal")
          end
        end
      end
    end
    if opts.tail then
      emit(parent, string.format("return %s", exprs1(exprs)), ast)
    end
    if opts.target then
      local result = exprs1(exprs)
      local function _2_()
        if (result == "") then
          return "nil"
        else
          return result
        end
      end
      emit(parent, string.format("%s = %s", opts.target, _2_()), ast)
    end
    if (opts.tail or opts.target) then
      return {returned = true}
    else
      local _3_0 = exprs
      _3_0["returned"] = true
      return _3_0
    end
  end
  local function find_macro(ast, scope, multi_sym_parts)
    local function find_in_table(t, i)
      if (i <= #multi_sym_parts) then
        return find_in_table((utils["table?"](t) and t[multi_sym_parts[i]]), (i + 1))
      else
        return t
      end
    end
    local macro_2a = (utils["sym?"](ast[1]) and scope.macros[utils.deref(ast[1])])
    if (not macro_2a and multi_sym_parts) then
      local nested_macro = find_in_table(scope.macros, 1)
      assert_compile((not scope.macros[multi_sym_parts[1]] or (type(nested_macro) == "function")), "macro not found in imported macro module", ast)
      return nested_macro
    else
      return macro_2a
    end
  end
  local function macroexpand_2a(ast, scope, once)
    local _0_0 = nil
    if utils["list?"](ast) then
      _0_0 = find_macro(ast, scope, utils["multi-sym?"](ast[1]))
    else
    _0_0 = nil
    end
    if (_0_0 == false) then
      return ast
    elseif (nil ~= _0_0) then
      local macro_2a = _0_0
      local old_scope = scopes.macro
      local _ = nil
      scopes.macro = scope
      _ = nil
      local ok, transformed = nil, nil
      local function _2_()
        return macro_2a(unpack(ast, 2))
      end
      ok, transformed = xpcall(_2_, debug.traceback)
      scopes.macro = old_scope
      assert_compile(ok, transformed, ast)
      if (once or not transformed) then
        return transformed
      else
        return macroexpand_2a(transformed, scope)
      end
    else
      local _ = _0_0
      return ast
    end
  end
  local function compile_special(ast, scope, parent, opts, special)
    local exprs = (special(ast, scope, parent, opts) or utils.expr("nil", "literal"))
    local exprs0 = nil
    if (type(exprs) == "string") then
      exprs0 = utils.expr(exprs, "expression")
    else
      exprs0 = exprs
    end
    local exprs2 = nil
    if utils["expr?"](exprs0) then
      exprs2 = {exprs0}
    else
      exprs2 = exprs0
    end
    if not exprs2.returned then
      return handle_compile_opts(exprs2, parent, opts, ast)
    elseif (opts.tail or opts.target) then
      return {returned = true}
    else
      return exprs2
    end
  end
  local function compile_function_call(ast, scope, parent, opts, compile1, len)
    local fargs = {}
    local fcallee = compile1(ast[1], scope, parent, {nval = 1})[1]
    assert_compile((("string" == type(ast[1])) or (fcallee.type ~= "literal")), ("cannot call literal value " .. tostring(ast[1])), ast)
    for i = 2, len do
      local subexprs = nil
      local _0_
      if (i ~= len) then
        _0_ = 1
      else
      _0_ = nil
      end
      subexprs = compile1(ast[i], scope, parent, {nval = _0_})
      table.insert(fargs, (subexprs[1] or utils.expr("nil", "literal")))
      if (i == len) then
        for j = 2, #subexprs do
          table.insert(fargs, subexprs[j])
        end
      else
        keep_side_effects(subexprs, parent, 2, ast[i])
      end
    end
    local pat = nil
    if ("string" == type(ast[1])) then
      pat = "(%s)(%s)"
    else
      pat = "%s(%s)"
    end
    local call = string.format(pat, tostring(fcallee), exprs1(fargs))
    return handle_compile_opts({utils.expr(call, "statement")}, parent, opts, ast)
  end
  local function compile_call(ast, scope, parent, opts, compile1)
    utils.hook("call", ast, scope)
    local len = #ast
    local first = ast[1]
    local multi_sym_parts = utils["multi-sym?"](first)
    local special = (utils["sym?"](first) and scope.specials[utils.deref(first)])
    assert_compile((len > 0), "expected a function, macro, or special to call", ast)
    if special then
      return compile_special(ast, scope, parent, opts, special)
    elseif (multi_sym_parts and multi_sym_parts["multi-sym-method-call"]) then
      local table_with_method = table.concat({unpack(multi_sym_parts, 1, (#multi_sym_parts - 1))}, ".")
      local method_to_call = multi_sym_parts[#multi_sym_parts]
      local new_ast = utils.list(utils.sym(":", nil, scope), utils.sym(table_with_method, nil, scope), method_to_call, select(2, unpack(ast)))
      return compile1(new_ast, scope, parent, opts)
    else
      return compile_function_call(ast, scope, parent, opts, compile1, len)
    end
  end
  local function compile_varg(ast, scope, parent, opts)
    assert_compile(scope.vararg, "unexpected vararg", ast)
    return handle_compile_opts({utils.expr("...", "varg")}, parent, opts, ast)
  end
  local function compile_sym(ast, scope, parent, opts)
    local multi_sym_parts = utils["multi-sym?"](ast)
    assert_compile(not (multi_sym_parts and multi_sym_parts["multi-sym-method-call"]), "multisym method calls may only be in call position", ast)
    local e = nil
    if (ast[1] == "nil") then
      e = utils.expr("nil", "literal")
    else
      e = symbol_to_expression(ast, scope, true)
    end
    return handle_compile_opts({e}, parent, opts, ast)
  end
  local function serialize_number(n)
    local _0_0 = string.gsub(tostring(n), ",", ".")
    return _0_0
  end
  local function compile_scalar(ast, _scope, parent, opts)
    local serialize = nil
    do
      local _0_0 = type(ast)
      if (_0_0 == "nil") then
        serialize = tostring
      elseif (_0_0 == "boolean") then
        serialize = tostring
      elseif (_0_0 == "string") then
        serialize = serialize_string
      elseif (_0_0 == "number") then
        serialize = serialize_number
      else
      serialize = nil
      end
    end
    return handle_compile_opts({utils.expr(serialize(ast), "literal")}, parent, opts)
  end
  local function compile_table(ast, scope, parent, opts, compile1)
    local buffer = {}
    for i = 1, #ast do
      local nval = ((i ~= #ast) and 1)
      table.insert(buffer, exprs1(compile1(ast[i], scope, parent, {nval = nval})))
    end
    local function write_other_values(k)
      if ((type(k) ~= "number") or (math.floor(k) ~= k) or (k < 1) or (k > #ast)) then
        if ((type(k) == "string") and utils["valid-lua-identifier?"](k)) then
          return {k, k}
        else
          local _0_ = compile1(k, scope, parent, {nval = 1})
          local compiled = _0_[1]
          local kstr = ("[" .. tostring(compiled) .. "]")
          return {kstr, k}
        end
      end
    end
    do
      local keys = nil
      do
        local _0_0 = utils.kvmap(ast, write_other_values)
        local function _1_(a, b)
          return (a[1] < b[1])
        end
        table.sort(_0_0, _1_)
        keys = _0_0
      end
      local function _1_(_2_0)
        local _3_ = _2_0
        local k1 = _3_[1]
        local k2 = _3_[2]
        local _4_ = compile1(ast[k2], scope, parent, {nval = 1})
        local v = _4_[1]
        return string.format("%s = %s", k1, tostring(v))
      end
      utils.map(keys, _1_, buffer)
    end
    return handle_compile_opts({utils.expr(("{" .. table.concat(buffer, ", ") .. "}"), "expression")}, parent, opts, ast)
  end
  local function compile1(ast, scope, parent, opts)
    local opts0 = (opts or {})
    local ast0 = macroexpand_2a(ast, scope)
    if utils["list?"](ast0) then
      return compile_call(ast0, scope, parent, opts0, compile1)
    elseif utils["varg?"](ast0) then
      return compile_varg(ast0, scope, parent, opts0)
    elseif utils["sym?"](ast0) then
      return compile_sym(ast0, scope, parent, opts0)
    elseif (type(ast0) == "table") then
      return compile_table(ast0, scope, parent, opts0, compile1)
    elseif ((type(ast0) == "nil") or (type(ast0) == "boolean") or (type(ast0) == "number") or (type(ast0) == "string")) then
      return compile_scalar(ast0, scope, parent, opts0)
    else
      return assert_compile(false, ("could not compile value of type " .. type(ast0)), ast0)
    end
  end
  local function destructure(to, from, ast, scope, parent, opts)
    local opts0 = (opts or {})
    local _0_ = opts0
    local declaration = _0_["declaration"]
    local forceglobal = _0_["forceglobal"]
    local forceset = _0_["forceset"]
    local isvar = _0_["isvar"]
    local symtype = _0_["symtype"]
    local symtype0 = ("_" .. (symtype or "dst"))
    local setter = nil
    if declaration then
      setter = "local %s = %s"
    else
      setter = "%s = %s"
    end
    local new_manglings = {}
    local function getname(symbol, up1)
      local raw = symbol[1]
      assert_compile(not (opts0.nomulti and utils["multi-sym?"](raw)), ("unexpected multi symbol " .. raw), up1)
      if declaration then
        return declare_local(symbol, nil, scope, symbol, new_manglings)
      else
        local parts = (utils["multi-sym?"](raw) or {raw})
        local meta = scope.symmeta[parts[1]]
        if ((#parts == 1) and not forceset) then
          assert_compile(not (forceglobal and meta), string.format("global %s conflicts with local", tostring(symbol)), symbol)
          assert_compile(not (meta and not meta.var), ("expected var " .. raw), symbol)
          assert_compile((meta or not opts0.noundef), ("expected local " .. parts[1]), symbol)
        end
        if forceglobal then
          assert_compile(not scope.symmeta[scope.unmanglings[raw]], ("global " .. raw .. " conflicts with local"), symbol)
          scope.manglings[raw] = global_mangling(raw)
          scope.unmanglings[global_mangling(raw)] = raw
          if allowed_globals then
            table.insert(allowed_globals, raw)
          end
        end
        return symbol_to_expression(symbol, scope)[1]
      end
    end
    local function compile_top_target(lvalues)
      local inits = nil
      local function _2_(_241)
        if scope.manglings[_241] then
          return _241
        else
          return "nil"
        end
      end
      inits = utils.map(lvalues, _2_)
      local init = table.concat(inits, ", ")
      local lvalue = table.concat(lvalues, ", ")
      local plen, plast = #parent, parent[#parent]
      local ret = compile1(from, scope, parent, {target = lvalue})
      if declaration then
        for pi = plen, #parent do
          if (parent[pi] == plast) then
            plen = pi
          end
        end
        if ((#parent == (plen + 1)) and parent[#parent].leaf) then
          parent[#parent]["leaf"] = ("local " .. parent[#parent].leaf)
        elseif (init == "nil") then
          table.insert(parent, (plen + 1), {ast = ast, leaf = ("local " .. lvalue)})
        else
          table.insert(parent, (plen + 1), {ast = ast, leaf = ("local " .. lvalue .. " = " .. init)})
        end
      end
      return ret
    end
    local function destructure_sym(left, rightexprs, up1, top_3f)
      local lname = getname(left, up1)
      check_binding_valid(left, scope, left)
      if top_3f then
        compile_top_target({lname})
      else
        emit(parent, setter:format(lname, exprs1(rightexprs)), left)
      end
      if declaration then
        scope.symmeta[utils.deref(left)] = {var = isvar}
        return nil
      end
    end
    local function destructure_table(left, rightexprs, top_3f, destructure1)
      local s = gensym(scope, symtype0)
      local right = nil
      do
        local _2_0 = nil
        if top_3f then
          _2_0 = exprs1(compile1(from, scope, parent))
        else
          _2_0 = exprs1(rightexprs)
        end
        if (_2_0 == "") then
          right = "nil"
        elseif (nil ~= _2_0) then
          local right0 = _2_0
          right = right0
        else
        right = nil
        end
      end
      emit(parent, string.format("local %s = %s", s, right), left)
      for k, v in utils.stablepairs(left) do
        if not (("number" == type(k)) and tostring(left[(k - 1)]):find("^&")) then
          if (utils["sym?"](v) and (utils.deref(v) == "&")) then
            local unpack_str = "{(table.unpack or unpack)(%s, %s)}"
            local formatted = string.format(unpack_str, s, k)
            local subexpr = utils.expr(formatted, "expression")
            assert_compile((utils["sequence?"](left) and (nil == left[(k + 2)])), "expected rest argument before last parameter", left)
            destructure1(left[(k + 1)], {subexpr}, left)
          elseif (utils["sym?"](k) and (utils.deref(k) == "&as")) then
            destructure_sym(v, {utils.expr(tostring(s))}, left)
          elseif (utils["sequence?"](left) and (utils.deref(v) == "&as")) then
            local _, next_sym, trailing = select(k, unpack(left))
            assert_compile((nil == trailing), "expected &as argument before last parameter", left)
            destructure_sym(next_sym, {utils.expr(tostring(s))}, left)
          else
            local key = nil
            if (type(k) == "string") then
              key = serialize_string(k)
            else
              key = k
            end
            local subexpr = utils.expr(string.format("%s[%s]", s, key), "expression")
            destructure1(v, {subexpr}, left)
          end
        end
      end
      return nil
    end
    local function destructure_values(left, up1, top_3f, destructure1)
      local left_names, tables = {}, {}
      for i, name in ipairs(left) do
        if utils["sym?"](name) then
          table.insert(left_names, getname(name, up1))
        else
          local symname = gensym(scope, symtype0)
          table.insert(left_names, symname)
          tables[i] = {name, utils.expr(symname, "sym")}
        end
      end
      assert_compile(top_3f, "can't nest multi-value destructuring", left)
      compile_top_target(left_names)
      if declaration then
        for _, sym in ipairs(left) do
          if utils["sym?"](sym) then
            scope.symmeta[utils.deref(sym)] = {var = isvar}
          end
        end
      end
      for _, pair in utils.stablepairs(tables) do
        destructure1(pair[1], {pair[2]}, left)
      end
      return nil
    end
    local function destructure1(left, rightexprs, up1, top_3f)
      if (utils["sym?"](left) and (left[1] ~= "nil")) then
        destructure_sym(left, rightexprs, up1, top_3f)
      elseif utils["table?"](left) then
        destructure_table(left, rightexprs, top_3f, destructure1)
      elseif utils["list?"](left) then
        destructure_values(left, up1, top_3f, destructure1)
      else
        assert_compile(false, string.format("unable to bind %s %s", type(left), tostring(left)), (((type(up1[2]) == "table") and up1[2]) or up1))
      end
      if top_3f then
        return {returned = true}
      end
    end
    local ret = destructure1(to, nil, ast, true)
    utils.hook("destructure", from, to, scope)
    apply_manglings(scope, new_manglings, ast)
    return ret
  end
  local function require_include(ast, scope, parent, opts)
    opts.fallback = function(e)
      return utils.expr(string.format("require(%s)", tostring(e)), "statement")
    end
    return scopes.global.specials.include(ast, scope, parent, opts)
  end
  local function compile_stream(strm, options)
    local opts = utils.copy(options)
    local old_globals = allowed_globals
    local scope = (opts.scope or make_scope(scopes.global))
    local vals = {}
    local chunk = {}
    local _0_ = utils.root
    _0_["set-reset"](_0_)
    allowed_globals = opts.allowedGlobals
    if (opts.indent == nil) then
      opts.indent = "  "
    end
    if opts.requireAsInclude then
      scope.specials.require = require_include
    end
    utils.root.chunk, utils.root.scope, utils.root.options = chunk, scope, opts
    for _, val in parser.parser(strm, opts.filename, opts) do
      table.insert(vals, val)
    end
    for i = 1, #vals do
      local exprs = compile1(vals[i], scope, chunk, {nval = (((i < #vals) and 0) or nil), tail = (i == #vals)})
      keep_side_effects(exprs, chunk, nil, vals[i])
    end
    allowed_globals = old_globals
    utils.root.reset()
    return flatten(chunk, opts)
  end
  local function compile_string(str, opts)
    return compile_stream(parser["string-stream"](str), (opts or {}))
  end
  local function compile(ast, opts)
    local opts0 = utils.copy(opts)
    local old_globals = allowed_globals
    local chunk = {}
    local scope = (opts0.scope or make_scope(scopes.global))
    local _0_ = utils.root
    _0_["set-reset"](_0_)
    allowed_globals = opts0.allowedGlobals
    if (opts0.indent == nil) then
      opts0.indent = "  "
    end
    if opts0.requireAsInclude then
      scope.specials.require = require_include
    end
    utils.root.chunk, utils.root.scope, utils.root.options = chunk, scope, opts0
    local exprs = compile1(ast, scope, chunk, {tail = true})
    keep_side_effects(exprs, chunk, nil, ast)
    allowed_globals = old_globals
    utils.root.reset()
    return flatten(chunk, opts0)
  end
  local function traceback_frame(info)
    if ((info.what == "C") and info.name) then
      return string.format("  [C]: in function '%s'", info.name)
    elseif (info.what == "C") then
      return "  [C]: in ?"
    else
      local remap = fennel_sourcemap[info.source]
      if (remap and remap[info.currentline]) then
        if remap[info.currentline][1] then
          info.short_src = fennel_sourcemap[("@" .. remap[info.currentline][1])].short_src
        else
          info.short_src = remap.short_src
        end
        info.currentline = (remap[info.currentline][2] or -1)
      end
      if (info.what == "Lua") then
        local function _1_()
          if info.name then
            return ("'" .. info.name .. "'")
          else
            return "?"
          end
        end
        return string.format("  %s:%d: in function %s", info.short_src, info.currentline, _1_())
      elseif (info.short_src == "(tail call)") then
        return "  (tail call)"
      else
        return string.format("  %s:%d: in main chunk", info.short_src, info.currentline)
      end
    end
  end
  local function traceback(msg, start)
    local msg0 = tostring((msg or ""))
    if ((msg0:find("^Compile error") or msg0:find("^Parse error")) and not utils["debug-on?"]("trace")) then
      return msg0
    else
      local lines = {}
      if (msg0:find("^Compile error") or msg0:find("^Parse error")) then
        table.insert(lines, msg0)
      else
        local newmsg = msg0:gsub("^[^:]*:%d+:%s+", "runtime error: ")
        table.insert(lines, newmsg)
      end
      table.insert(lines, "stack traceback:")
      local done_3f, level = false, (start or 2)
      while not done_3f do
        do
          local _1_0 = debug.getinfo(level, "Sln")
          if (_1_0 == nil) then
            done_3f = true
          elseif (nil ~= _1_0) then
            local info = _1_0
            table.insert(lines, traceback_frame(info))
          end
        end
        level = (level + 1)
      end
      return table.concat(lines, "\n")
    end
  end
  local function entry_transform(fk, fv)
    local function _0_(k, v)
      if (type(k) == "number") then
        return k, fv(v)
      else
        return fk(k), fv(v)
      end
    end
    return _0_
  end
  local function mixed_concat(t, joiner)
    local seen = {}
    local ret, s = "", ""
    for k, v in ipairs(t) do
      table.insert(seen, k)
      ret = (ret .. s .. v)
      s = joiner
    end
    for k, v in utils.stablepairs(t) do
      if not seen[k] then
        ret = (ret .. s .. "[" .. k .. "]" .. "=" .. v)
        s = joiner
      end
    end
    return ret
  end
  local function do_quote(form, scope, parent, runtime_3f)
    local function q(x)
      return do_quote(x, scope, parent, runtime_3f)
    end
    if utils["varg?"](form) then
      assert_compile(not runtime_3f, "quoted ... may only be used at compile time", form)
      return "_VARARG"
    elseif utils["sym?"](form) then
      local filename = nil
      if form.filename then
        filename = string.format("%q", form.filename)
      else
        filename = "nil"
      end
      local symstr = utils.deref(form)
      assert_compile(not runtime_3f, "symbols may only be used at compile time", form)
      if (symstr:find("#$") or symstr:find("#[:.]")) then
        return string.format("sym('%s', {filename=%s, line=%s})", autogensym(symstr, scope), filename, (form.line or "nil"))
      else
        return string.format("sym('%s', {quoted=true, filename=%s, line=%s})", symstr, filename, (form.line or "nil"))
      end
    elseif (utils["list?"](form) and utils["sym?"](form[1]) and (utils.deref(form[1]) == "unquote")) then
      local payload = form[2]
      local res = unpack(compile1(payload, scope, parent))
      return res[1]
    elseif utils["list?"](form) then
      local mapped = nil
      local function _0_()
        return nil
      end
      mapped = utils.kvmap(form, entry_transform(_0_, q))
      local filename = nil
      if form.filename then
        filename = string.format("%q", form.filename)
      else
        filename = "nil"
      end
      assert_compile(not runtime_3f, "lists may only be used at compile time", form)
      return string.format(("setmetatable({filename=%s, line=%s, bytestart=%s, %s}" .. ", getmetatable(list()))"), filename, (form.line or "nil"), (form.bytestart or "nil"), mixed_concat(mapped, ", "))
    elseif utils["sequence?"](form) then
      local mapped = utils.kvmap(form, entry_transform(q, q))
      local source = getmetatable(form)
      local filename = nil
      if source.filename then
        filename = string.format("%q", source.filename)
      else
        filename = "nil"
      end
      local _1_
      if source then
        _1_ = source.line
      else
        _1_ = "nil"
      end
      return string.format("setmetatable({%s}, {filename=%s, line=%s, sequence=%s})", mixed_concat(mapped, ", "), filename, _1_, "(getmetatable(sequence()))['sequence']")
    elseif (type(form) == "table") then
      local mapped = utils.kvmap(form, entry_transform(q, q))
      local source = getmetatable(form)
      local filename = nil
      if source.filename then
        filename = string.format("%q", source.filename)
      else
        filename = "nil"
      end
      local function _1_()
        if source then
          return source.line
        else
          return "nil"
        end
      end
      return string.format("setmetatable({%s}, {filename=%s, line=%s})", mixed_concat(mapped, ", "), filename, _1_())
    elseif (type(form) == "string") then
      return serialize_string(form)
    else
      return tostring(form)
    end
  end
  return {["apply-manglings"] = apply_manglings, ["compile-stream"] = compile_stream, ["compile-string"] = compile_string, ["declare-local"] = declare_local, ["do-quote"] = do_quote, ["global-mangling"] = global_mangling, ["global-unmangling"] = global_unmangling, ["keep-side-effects"] = keep_side_effects, ["make-scope"] = make_scope, ["require-include"] = require_include, ["symbol-to-expression"] = symbol_to_expression, assert = assert_compile, autogensym = autogensym, compile = compile, compile1 = compile1, destructure = destructure, emit = emit, gensym = gensym, macroexpand = macroexpand_2a, metadata = make_metadata(), scopes = scopes, traceback = traceback}
end
package.preload["nvim-tree-docs.aniseed.fennel.friend"] = package.preload["nvim-tree-docs.aniseed.fennel.friend"] or function(...)
  local function ast_source(ast)
    local m = getmetatable(ast)
    return ((m and m.line and m) or (("table" == type(ast)) and ast) or {})
  end
  local suggestions = {["$ and $... in hashfn are mutually exclusive"] = {"modifying the hashfn so it only contains $... or $, $1, $2, $3, etc"}, ["can't start multisym segment with a digit"] = {"removing the digit", "adding a non-digit before the digit"}, ["cannot call literal value"] = {"checking for typos", "checking for a missing function name"}, ["could not compile value of type "] = {"debugging the macro you're calling to return a list or table"}, ["could not read number (.*)"] = {"removing the non-digit character", "beginning the identifier with a non-digit if it is not meant to be a number"}, ["expected a function.* to call"] = {"removing the empty parentheses", "using square brackets if you want an empty table"}, ["expected binding and iterator"] = {"making sure you haven't omitted a local name or iterator"}, ["expected binding table"] = {"placing a table here in square brackets containing identifiers to bind"}, ["expected body expression"] = {"putting some code in the body of this form after the bindings"}, ["expected each macro to be function"] = {"ensuring that the value for each key in your macros table contains a function", "avoid defining nested macro tables"}, ["expected even number of name/value bindings"] = {"finding where the identifier or value is missing"}, ["expected even number of values in table literal"] = {"removing a key", "adding a value"}, ["expected local"] = {"looking for a typo", "looking for a local which is used out of its scope"}, ["expected macros to be table"] = {"ensuring your macro definitions return a table"}, ["expected parameters"] = {"adding function parameters as a list of identifiers in brackets"}, ["expected rest argument before last parameter"] = {"moving & to right before the final identifier when destructuring"}, ["expected symbol for function parameter: (.*)"] = {"changing %s to an identifier instead of a literal value"}, ["expected var (.*)"] = {"declaring %s using var instead of let/local", "introducing a new local instead of changing the value of %s"}, ["expected vararg as last parameter"] = {"moving the \"...\" to the end of the parameter list"}, ["expected whitespace before opening delimiter"] = {"adding whitespace"}, ["global (.*) conflicts with local"] = {"renaming local %s"}, ["illegal character: (.)"] = {"deleting or replacing %s", "avoiding reserved characters like \", \\, ', ~, ;, @, `, and comma"}, ["local (.*) was overshadowed by a special form or macro"] = {"renaming local %s"}, ["macro not found in macro module"] = {"checking the keys of the imported macro module's returned table"}, ["macro tried to bind (.*) without gensym"] = {"changing to %s# when introducing identifiers inside macros"}, ["malformed multisym"] = {"ensuring each period or colon is not followed by another period or colon"}, ["may only be used at compile time"] = {"moving this to inside a macro if you need to manipulate symbols/lists", "using square brackets instead of parens to construct a table"}, ["method must be last component"] = {"using a period instead of a colon for field access", "removing segments after the colon", "making the method call, then looking up the field on the result"}, ["mismatched closing delimiter (.), expected (.)"] = {"replacing %s with %s", "deleting %s", "adding matching opening delimiter earlier"}, ["multisym method calls may only be in call position"] = {"using a period instead of a colon to reference a table's fields", "putting parens around this"}, ["unable to bind (.*)"] = {"replacing the %s with an identifier"}, ["unexpected closing delimiter (.)"] = {"deleting %s", "adding matching opening delimiter earlier"}, ["unexpected multi symbol (.*)"] = {"removing periods or colons from %s"}, ["unexpected vararg"] = {"putting \"...\" at the end of the fn parameters if the vararg was intended"}, ["unknown global in strict mode: (.*)"] = {"looking to see if there's a typo", "using the _G table instead, eg. _G.%s if you really want a global", "moving this code to somewhere that %s is in scope", "binding %s as a local in the scope of this code"}, ["unused local (.*)"] = {"fixing a typo so %s is used", "renaming the local to _%s"}, ["use of global (.*) is aliased by a local"] = {"renaming local %s", "refer to the global using _G.%s instead of directly"}}
  local unpack = (table.unpack or _G.unpack)
  local function suggest(msg)
    local suggestion = nil
    for pat, sug in pairs(suggestions) do
      local matches = {msg:match(pat)}
      if (0 < #matches) then
        if ("table" == type(sug)) then
          local out = {}
          for _, s in ipairs(sug) do
            table.insert(out, s:format(unpack(matches)))
          end
          suggestion = out
        else
          suggestion = sug(matches)
        end
      end
    end
    return suggestion
  end
  local function read_line_from_file(filename, line)
    local bytes = 0
    local f = assert(io.open(filename))
    local _ = nil
    for _0 = 1, (line - 1) do
      bytes = (bytes + 1 + #f:read())
    end
    _ = nil
    local codeline = f:read()
    f:close()
    return codeline, bytes
  end
  local function read_line_from_string(matcher, target_line, _3fcurrent_line, _3fbytes)
    local this_line, newline = matcher()
    local current_line = (_3fcurrent_line or 1)
    local bytes = ((_3fbytes or 0) + #this_line + #newline)
    if (target_line == current_line) then
      return this_line, bytes
    elseif this_line then
      return read_line_from_string(matcher, target_line, (current_line + 1), bytes)
    end
  end
  local function read_line(filename, line, source)
    if source then
      return read_line_from_string(string.gmatch((source .. "\n"), "(.-)(\13?\n)"), line)
    else
      return read_line_from_file(filename, line)
    end
  end
  local function friendly_msg(msg, _0_0, source)
    local _1_ = _0_0
    local byteend = _1_["byteend"]
    local bytestart = _1_["bytestart"]
    local filename = _1_["filename"]
    local line = _1_["line"]
    local ok, codeline, bol = pcall(read_line, filename, line, source)
    local suggestions0 = suggest(msg)
    local out = {msg, ""}
    if (ok and codeline) then
      table.insert(out, codeline)
    end
    if (ok and codeline and bytestart and byteend) then
      table.insert(out, (string.rep(" ", (bytestart - bol - 1)) .. "^" .. string.rep("^", math.min((byteend - bytestart), ((bol + #codeline) - bytestart)))))
    end
    if (ok and codeline and bytestart and not byteend) then
      table.insert(out, (string.rep("-", (bytestart - bol - 1)) .. "^"))
      table.insert(out, "")
    end
    if suggestions0 then
      for _, suggestion in ipairs(suggestions0) do
        table.insert(out, ("* Try %s."):format(suggestion))
      end
    end
    return table.concat(out, "\n")
  end
  local function assert_compile(condition, msg, ast, source)
    if not condition then
      local _1_ = ast_source(ast)
      local filename = _1_["filename"]
      local line = _1_["line"]
      error(friendly_msg(("Compile error in %s:%s\n  %s"):format((filename or "unknown"), (line or "?"), msg), ast_source(ast), source), 0)
    end
    return condition
  end
  local function parse_error(msg, filename, line, bytestart, source)
    return error(friendly_msg(("Parse error in %s:%s\n  %s"):format(filename, line, msg), {bytestart = bytestart, filename = filename, line = line}, source), 0)
  end
  return {["assert-compile"] = assert_compile, ["parse-error"] = parse_error}
end
package.preload["nvim-tree-docs.aniseed.fennel.parser"] = package.preload["nvim-tree-docs.aniseed.fennel.parser"] or function(...)
  local utils = require("nvim-tree-docs.aniseed.fennel.utils")
  local friend = require("nvim-tree-docs.aniseed.fennel.friend")
  local unpack = (table.unpack or _G.unpack)
  local function granulate(getchunk)
    local c, index, done_3f = "", 1, false
    local function _0_(parser_state)
      if not done_3f then
        if (index <= #c) then
          local b = c:byte(index)
          index = (index + 1)
          return b
        else
          local _1_0, _2_0, _3_0 = getchunk(parser_state)
          local _4_
          do
            local char = _1_0
            _4_ = ((nil ~= _1_0) and (char ~= ""))
          end
          if _4_ then
            local char = _1_0
            c = char
            index = 2
            return c:byte()
          else
            local _ = _1_0
            done_3f = true
            return nil
          end
        end
      end
    end
    local function _1_()
      c = ""
      return nil
    end
    return _0_, _1_
  end
  local function string_stream(str)
    local str0 = str:gsub("^#!", ";;")
    local index = 1
    local function _0_()
      local r = str0:byte(index)
      index = (index + 1)
      return r
    end
    return _0_
  end
  local delims = {[123] = 125, [125] = true, [40] = 41, [41] = true, [91] = 93, [93] = true}
  local function whitespace_3f(b)
    return ((b == 32) or ((b >= 9) and (b <= 13)))
  end
  local function sym_char_3f(b)
    local b0 = nil
    if ("number" == type(b)) then
      b0 = b
    else
      b0 = string.byte(b)
    end
    return ((b0 > 32) and not delims[b0] and (b0 ~= 127) and (b0 ~= 34) and (b0 ~= 39) and (b0 ~= 126) and (b0 ~= 59) and (b0 ~= 44) and (b0 ~= 64) and (b0 ~= 96))
  end
  local prefixes = {[35] = "hashfn", [39] = "quote", [44] = "unquote", [96] = "quote"}
  local function parser(getbyte, filename, options)
    local stack = {}
    local line = 1
    local byteindex = 0
    local lastb = nil
    local function ungetb(ub)
      if (ub == 10) then
        line = (line - 1)
      end
      byteindex = (byteindex - 1)
      lastb = ub
      return nil
    end
    local function getb()
      local r = nil
      if lastb then
        r, lastb = lastb, nil
      else
        r = getbyte({["stack-size"] = #stack})
      end
      byteindex = (byteindex + 1)
      if (r == 10) then
        line = (line + 1)
      end
      return r
    end
    assert(((nil == filename) or ("string" == type(filename))), "expected filename as second argument to parser")
    local function parse_error(msg, byteindex_override)
      local _0_ = (options or utils.root.options or {})
      local source = _0_["source"]
      local unfriendly = _0_["unfriendly"]
      utils.root.reset()
      if unfriendly then
        return error(string.format("Parse error in %s:%s: %s", (filename or "unknown"), (line or "?"), msg), 0)
      else
        return friend["parse-error"](msg, (filename or "unknown"), (line or "?"), (byteindex_override or byteindex), source)
      end
    end
    local function parse_stream()
      local whitespace_since_dispatch, done_3f, retval = true
      local function dispatch(v)
        local _0_0 = stack[#stack]
        if (_0_0 == nil) then
          retval, done_3f, whitespace_since_dispatch = v, true, false
          return nil
        elseif ((type(_0_0) == "table") and (nil ~= _0_0.prefix)) then
          local prefix = _0_0.prefix
          local source = nil
          do
            local _1_0 = table.remove(stack)
            _1_0["byteend"] = byteindex
            source = _1_0
          end
          local list = utils.list(utils.sym(prefix, source), v)
          for k, v0 in pairs(source) do
            list[k] = v0
          end
          return dispatch(list)
        elseif (nil ~= _0_0) then
          local top = _0_0
          whitespace_since_dispatch = false
          return table.insert(top, v)
        end
      end
      local function badend()
        local accum = utils.map(stack, "closer")
        local _0_
        if (#stack == 1) then
          _0_ = ""
        else
          _0_ = "s"
        end
        return parse_error(string.format("expected closing delimiter%s %s", _0_, string.char(unpack(accum))))
      end
      local function skip_whitespace(b)
        if (b and whitespace_3f(b)) then
          whitespace_since_dispatch = true
          return skip_whitespace(getb())
        elseif (not b and (#stack > 0)) then
          return badend()
        else
          return b
        end
      end
      local function parse_comment(b, contents)
        if (b and (10 ~= b)) then
          local function _1_()
            local _0_0 = contents
            table.insert(_0_0, string.char(b))
            return _0_0
          end
          return parse_comment(getb(), _1_())
        elseif (options and options.comments) then
          return dispatch(utils.comment(table.concat(contents), {filename = filename, line = (line - 1)}))
        else
          return b
        end
      end
      local function open_table(b)
        if not whitespace_since_dispatch then
          parse_error(("expected whitespace before opening delimiter " .. string.char(b)))
        end
        return table.insert(stack, {bytestart = byteindex, closer = delims[b], filename = filename, line = line})
      end
      local function close_list(list)
        return dispatch(setmetatable(list, getmetatable(utils.list())))
      end
      local function close_sequence(tbl)
        local val = utils.sequence(unpack(tbl))
        for k, v in pairs(tbl) do
          getmetatable(val)[k] = v
        end
        return dispatch(val)
      end
      local function add_comment_at(comments, index, node)
        local _0_0 = comments[index]
        if (nil ~= _0_0) then
          local existing = _0_0
          return table.insert(existing, node)
        else
          local _ = _0_0
          comments[index] = {node}
          return nil
        end
      end
      local function next_noncomment(tbl, i)
        if utils["comment?"](tbl[i]) then
          return next_noncomment(tbl, (i + 1))
        else
          return tbl[i]
        end
      end
      local function extract_comments(tbl)
        local comments = {keys = {}, last = {}, values = {}}
        while utils["comment?"](tbl[#tbl]) do
          table.insert(comments.last, 1, table.remove(tbl))
        end
        local last_key_3f = false
        for i, node in ipairs(tbl) do
          if not utils["comment?"](node) then
            last_key_3f = not last_key_3f
          elseif last_key_3f then
            add_comment_at(comments.values, next_noncomment(tbl, i), node)
          else
            add_comment_at(comments.keys, next_noncomment(tbl, i), node)
          end
        end
        for i = #tbl, 1, -1 do
          if utils["comment?"](tbl[i]) then
            table.remove(tbl, i)
          end
        end
        return comments
      end
      local function close_curly_table(tbl)
        local comments = extract_comments(tbl)
        local keys = {}
        local val = {}
        if ((#tbl % 2) ~= 0) then
          byteindex = (byteindex - 1)
          parse_error("expected even number of values in table literal")
        end
        setmetatable(val, tbl)
        for i = 1, #tbl, 2 do
          if ((tostring(tbl[i]) == ":") and utils["sym?"](tbl[(i + 1)]) and utils["sym?"](tbl[i])) then
            tbl[i] = tostring(tbl[(i + 1)])
          end
          val[tbl[i]] = tbl[(i + 1)]
          table.insert(keys, tbl[i])
        end
        tbl.comments = comments
        tbl.keys = keys
        return dispatch(val)
      end
      local function close_table(b)
        local top = table.remove(stack)
        if (top == nil) then
          parse_error(("unexpected closing delimiter " .. string.char(b)))
        end
        if (top.closer and (top.closer ~= b)) then
          parse_error(("mismatched closing delimiter " .. string.char(b) .. ", expected " .. string.char(top.closer)))
        end
        top.byteend = byteindex
        if (b == 41) then
          return close_list(top)
        elseif (b == 93) then
          return close_sequence(top)
        else
          return close_curly_table(top)
        end
      end
      local function parse_string_loop(chars, b, state)
        table.insert(chars, b)
        local state0 = nil
        do
          local _0_0 = {state, b}
          if ((type(_0_0) == "table") and (_0_0[1] == "base") and (_0_0[2] == 92)) then
            state0 = "backslash"
          elseif ((type(_0_0) == "table") and (_0_0[1] == "base") and (_0_0[2] == 34)) then
            state0 = "done"
          else
            local _ = _0_0
            state0 = "base"
          end
        end
        if (b and (state0 ~= "done")) then
          return parse_string_loop(chars, getb(), state0)
        else
          return b
        end
      end
      local function escape_char(c)
        return ({nil, nil, nil, nil, nil, nil, "\\a", "\\b", "\\t", "\\n", "\\v", "\\f", "\\r"})[c:byte()]
      end
      local function parse_string()
        table.insert(stack, {closer = 34})
        local chars = {34}
        if not parse_string_loop(chars, getb(), "base") then
          badend()
        end
        table.remove(stack)
        local raw = string.char(unpack(chars))
        local formatted = raw:gsub("[\7-\13]", escape_char)
        local _1_0 = (rawget(_G, "loadstring") or load)(("return " .. formatted))
        if (nil ~= _1_0) then
          local load_fn = _1_0
          return dispatch(load_fn())
        elseif (_1_0 == nil) then
          return parse_error(("Invalid string: " .. raw))
        end
      end
      local function parse_prefix(b)
        table.insert(stack, {bytestart = byteindex, filename = filename, line = line, prefix = prefixes[b]})
        local nextb = getb()
        if (whitespace_3f(nextb) or (true == delims[nextb])) then
          if (b ~= 35) then
            parse_error("invalid whitespace after quoting prefix")
          end
          table.remove(stack)
          dispatch(utils.sym("#"))
        end
        return ungetb(nextb)
      end
      local function parse_sym_loop(chars, b)
        if (b and sym_char_3f(b)) then
          table.insert(chars, b)
          return parse_sym_loop(chars, getb())
        else
          if b then
            ungetb(b)
          end
          return chars
        end
      end
      local function parse_number(rawstr)
        local number_with_stripped_underscores = (not rawstr:find("^_") and rawstr:gsub("_", ""))
        if rawstr:match("^%d") then
          dispatch((tonumber(number_with_stripped_underscores) or parse_error(("could not read number \"" .. rawstr .. "\""))))
          return true
        else
          local _0_0 = tonumber(number_with_stripped_underscores)
          if (nil ~= _0_0) then
            local x = _0_0
            dispatch(x)
            return true
          else
            local _ = _0_0
            return false
          end
        end
      end
      local function check_malformed_sym(rawstr)
        if (rawstr:match("^~") and (rawstr ~= "~=")) then
          return parse_error("illegal character: ~")
        elseif rawstr:match("%.[0-9]") then
          return parse_error(("can't start multisym segment with a digit: " .. rawstr), (((byteindex - #rawstr) + rawstr:find("%.[0-9]")) + 1))
        elseif (rawstr:match("[%.:][%.:]") and (rawstr ~= "..") and (rawstr ~= "$...")) then
          return parse_error(("malformed multisym: " .. rawstr), ((byteindex - #rawstr) + 1 + rawstr:find("[%.:][%.:]")))
        elseif rawstr:match(":.+[%.:]") then
          return parse_error(("method must be last component of multisym: " .. rawstr), ((byteindex - #rawstr) + rawstr:find(":.+[%.:]")))
        else
          return rawstr
        end
      end
      local function parse_sym(b)
        local bytestart = byteindex
        local rawstr = string.char(unpack(parse_sym_loop({b}, getb())))
        if (rawstr == "true") then
          return dispatch(true)
        elseif (rawstr == "false") then
          return dispatch(false)
        elseif (rawstr == "...") then
          return dispatch(utils.varg())
        elseif rawstr:match("^:.+$") then
          return dispatch(rawstr:sub(2))
        elseif not parse_number(rawstr) then
          return dispatch(utils.sym(check_malformed_sym(rawstr), {byteend = byteindex, bytestart = bytestart, filename = filename, line = line}))
        end
      end
      local function parse_loop(b)
        if not b then
        elseif (b == 59) then
          parse_comment(getb(), {";"})
        elseif (type(delims[b]) == "number") then
          open_table(b)
        elseif delims[b] then
          close_table(b)
        elseif (b == 34) then
          parse_string(b)
        elseif prefixes[b] then
          parse_prefix(b)
        elseif (sym_char_3f(b) or (b == string.byte("~"))) then
          parse_sym(b)
        else
          parse_error(("illegal character: " .. string.char(b)))
        end
        if not b then
          return nil
        elseif done_3f then
          return true, retval
        else
          return parse_loop(skip_whitespace(getb()))
        end
      end
      return parse_loop(skip_whitespace(getb()))
    end
    local function _0_()
      stack = {}
      return nil
    end
    return parse_stream, _0_
  end
  return {["string-stream"] = string_stream, ["sym-char?"] = sym_char_3f, granulate = granulate, parser = parser}
end
local utils = nil
package.preload["nvim-tree-docs.aniseed.fennel.utils"] = package.preload["nvim-tree-docs.aniseed.fennel.utils"] or function(...)
  local function stablepairs(t)
    local keys = {}
    local succ = {}
    for k in pairs(t) do
      table.insert(keys, k)
    end
    local function _0_(_241, _242)
      return (tostring(_241) < tostring(_242))
    end
    table.sort(keys, _0_)
    for i, k in ipairs(keys) do
      succ[k] = keys[(i + 1)]
    end
    local function stablenext(tbl, idx)
      local key = nil
      if (idx == nil) then
        key = keys[1]
      else
        key = succ[idx]
      end
      local value = nil
      if (key == nil) then
        value = nil
      else
        value = tbl[key]
      end
      return key, value
    end
    return stablenext, t, nil
  end
  local function map(t, f, out)
    local out0 = (out or {})
    local f0 = nil
    if (type(f) == "function") then
      f0 = f
    else
      local function _0_(_241)
        return _241[f]
      end
      f0 = _0_
    end
    for _, x in ipairs(t) do
      local _1_0 = f0(x)
      if (nil ~= _1_0) then
        local v = _1_0
        table.insert(out0, v)
      end
    end
    return out0
  end
  local function kvmap(t, f, out)
    local out0 = (out or {})
    local f0 = nil
    if (type(f) == "function") then
      f0 = f
    else
      local function _0_(_241)
        return _241[f]
      end
      f0 = _0_
    end
    for k, x in stablepairs(t) do
      local _1_0, _2_0 = f0(k, x)
      if ((nil ~= _1_0) and (nil ~= _2_0)) then
        local key = _1_0
        local value = _2_0
        out0[key] = value
      elseif (nil ~= _1_0) then
        local value = _1_0
        table.insert(out0, value)
      end
    end
    return out0
  end
  local function copy(from, to)
    local to0 = (to or {})
    for k, v in pairs((from or {})) do
      to0[k] = v
    end
    return to0
  end
  local function member_3f(x, tbl, n)
    local _0_0 = tbl[(n or 1)]
    if (_0_0 == x) then
      return true
    elseif (_0_0 == nil) then
      return nil
    else
      local _ = _0_0
      return member_3f(x, tbl, ((n or 1) + 1))
    end
  end
  local function allpairs(tbl)
    assert((type(tbl) == "table"), "allpairs expects a table")
    local t = tbl
    local seen = {}
    local function allpairs_next(_, state)
      local next_state, value = next(t, state)
      if seen[next_state] then
        return allpairs_next(nil, next_state)
      elseif next_state then
        seen[next_state] = true
        return next_state, value
      else
        local meta = getmetatable(t)
        if (meta and meta.__index) then
          t = meta.__index
          return allpairs_next(t)
        end
      end
    end
    return allpairs_next
  end
  local function deref(self)
    return self[1]
  end
  local nil_sym = nil
  local function list__3estring(self, tostring2)
    local safe, max = {}, 0
    for k in pairs(self) do
      if ((type(k) == "number") and (k > max)) then
        max = k
      end
    end
    for i = 1, max do
      safe[i] = (((self[i] == nil) and nil_sym) or self[i])
    end
    return ("(" .. table.concat(map(safe, (tostring2 or tostring)), " ", 1, max) .. ")")
  end
  local function comment_view(c)
    return c, true
  end
  local function sym_3d(a, b)
    return ((deref(a) == deref(b)) and (getmetatable(a) == getmetatable(b)))
  end
  local function sym_3c(a, b)
    return (a[1] < tostring(b))
  end
  local symbol_mt = {"SYMBOL", __eq = sym_3d, __fennelview = deref, __lt = sym_3c, __tostring = deref}
  local expr_mt = {"EXPR", __tostring = deref}
  local list_mt = {"LIST", __fennelview = list__3estring, __tostring = list__3estring}
  local comment_mt = {"COMMENT", __eq = sym_3d, __fennelview = comment_view, __lt = sym_3c, __tostring = deref}
  local sequence_marker = {"SEQUENCE"}
  local vararg = setmetatable({"..."}, {"VARARG", __fennelview = deref, __tostring = deref})
  local getenv = nil
  local function _0_()
    return nil
  end
  getenv = ((os and os.getenv) or _0_)
  local function debug_on_3f(flag)
    local level = (getenv("FENNEL_DEBUG") or "")
    return ((level == "all") or level:find(flag))
  end
  local function list(...)
    return setmetatable({...}, list_mt)
  end
  local function sym(str, _3fsource, _3fscope)
    local s = {str, ["?scope"] = _3fscope}
    for k, v in pairs((_3fsource or {})) do
      if (type(k) == "string") then
        s[k] = v
      end
    end
    return setmetatable(s, symbol_mt)
  end
  nil_sym = sym("nil")
  local function sequence(...)
    return setmetatable({...}, {sequence = sequence_marker})
  end
  local function expr(strcode, etype)
    return setmetatable({strcode, type = etype}, expr_mt)
  end
  local function comment_2a(contents, _3fsource)
    local _1_ = (_3fsource or {})
    local filename = _1_["filename"]
    local line = _1_["line"]
    return setmetatable({contents, filename = filename, line = line}, comment_mt)
  end
  local function varg()
    return vararg
  end
  local function expr_3f(x)
    return ((type(x) == "table") and (getmetatable(x) == expr_mt) and x)
  end
  local function varg_3f(x)
    return ((x == vararg) and x)
  end
  local function list_3f(x)
    return ((type(x) == "table") and (getmetatable(x) == list_mt) and x)
  end
  local function sym_3f(x)
    return ((type(x) == "table") and (getmetatable(x) == symbol_mt) and x)
  end
  local function sequence_3f(x)
    local mt = ((type(x) == "table") and getmetatable(x))
    return (mt and (mt.sequence == sequence_marker) and x)
  end
  local function comment_3f(x)
    return ((type(x) == "table") and (getmetatable(x) == comment_mt) and x)
  end
  local function table_3f(x)
    return ((type(x) == "table") and (x ~= vararg) and (getmetatable(x) ~= list_mt) and (getmetatable(x) ~= symbol_mt) and not comment_3f(x) and x)
  end
  local function multi_sym_3f(str)
    if sym_3f(str) then
      return multi_sym_3f(tostring(str))
    elseif (type(str) ~= "string") then
      return false
    else
      local parts = {}
      for part in str:gmatch("[^%.%:]+[%.%:]?") do
        local last_char = part:sub(( - 1))
        if (last_char == ":") then
          parts["multi-sym-method-call"] = true
        end
        if ((last_char == ":") or (last_char == ".")) then
          parts[(#parts + 1)] = part:sub(1, ( - 2))
        else
          parts[(#parts + 1)] = part
        end
      end
      return ((#parts > 0) and (str:match("%.") or str:match(":")) and not str:match("%.%.") and (str:byte() ~= string.byte(".")) and (str:byte(( - 1)) ~= string.byte(".")) and parts)
    end
  end
  local function quoted_3f(symbol)
    return symbol.quoted
  end
  local function walk_tree(root, f, custom_iterator)
    local function walk(iterfn, parent, idx, node)
      if f(idx, node, parent) then
        for k, v in iterfn(node) do
          walk(iterfn, node, k, v)
        end
        return nil
      end
    end
    walk((custom_iterator or pairs), nil, nil, root)
    return root
  end
  local lua_keywords = {"and", "break", "do", "else", "elseif", "end", "false", "for", "function", "if", "in", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while", "goto"}
  for i, v in ipairs(lua_keywords) do
    lua_keywords[v] = i
  end
  local function valid_lua_identifier_3f(str)
    return (str:match("^[%a_][%w_]*$") and not lua_keywords[str])
  end
  local propagated_options = {"allowedGlobals", "indent", "correlate", "useMetadata", "env", "compiler-env", "compilerEnv"}
  local function propagate_options(options, subopts)
    for _, name in ipairs(propagated_options) do
      subopts[name] = options[name]
    end
    return subopts
  end
  local root = nil
  local function _1_()
  end
  root = {chunk = nil, options = nil, reset = _1_, scope = nil}
  root["set-reset"] = function(_2_0)
    local _3_ = _2_0
    local chunk = _3_["chunk"]
    local options = _3_["options"]
    local reset = _3_["reset"]
    local scope = _3_["scope"]
    root.reset = function()
      root.chunk, root.scope, root.options, root.reset = chunk, scope, options, reset
      return nil
    end
    return root.reset
  end
  local function hook(event, ...)
    if (root.options and root.options.plugins) then
      for _, plugin in ipairs(root.options.plugins) do
        local _3_0 = plugin[event]
        if (nil ~= _3_0) then
          local f = _3_0
          f(...)
        end
      end
      return nil
    end
  end
  return {["comment?"] = comment_3f, ["debug-on?"] = debug_on_3f, ["expr?"] = expr_3f, ["list?"] = list_3f, ["lua-keywords"] = lua_keywords, ["member?"] = member_3f, ["multi-sym?"] = multi_sym_3f, ["propagate-options"] = propagate_options, ["quoted?"] = quoted_3f, ["sequence?"] = sequence_3f, ["sym?"] = sym_3f, ["table?"] = table_3f, ["valid-lua-identifier?"] = valid_lua_identifier_3f, ["varg?"] = varg_3f, ["walk-tree"] = walk_tree, allpairs = allpairs, comment = comment_2a, copy = copy, deref = deref, expr = expr, hook = hook, kvmap = kvmap, list = list, map = map, path = table.concat({"./?.fnl", "./?/init.fnl", getenv("FENNEL_PATH")}, ";"), root = root, sequence = sequence, stablepairs = stablepairs, sym = sym, varg = varg}
end
utils = require("nvim-tree-docs.aniseed.fennel.utils")
local parser = require("nvim-tree-docs.aniseed.fennel.parser")
local compiler = require("nvim-tree-docs.aniseed.fennel.compiler")
local specials = require("nvim-tree-docs.aniseed.fennel.specials")
local repl = require("nvim-tree-docs.aniseed.fennel.repl")
local view = require("nvim-tree-docs.aniseed.fennel.view")
local function eval_env(env)
  if (env == "_COMPILER") then
    local env0 = specials["make-compiler-env"](nil, compiler.scopes.compiler, {})
    local mt = getmetatable(env0)
    mt.__index = _G
    return specials["wrap-env"](env0)
  else
    return (env and specials["wrap-env"](env))
  end
end
local function eval_opts(options, str)
  local opts = utils.copy(options)
  if ((opts.allowedGlobals == nil) and not getmetatable(opts.env)) then
    opts.allowedGlobals = specials["current-global-names"](opts.env)
  end
  if (not opts.filename and not opts.source) then
    opts.source = str
  end
  if (opts.env == "_COMPILER") then
    opts.scope = compiler["make-scope"](compiler.scopes.compiler)
  end
  return opts
end
local function eval(str, options, ...)
  local opts = eval_opts(options, str)
  local env = eval_env(opts.env)
  local lua_source = compiler["compile-string"](str, opts)
  local loader = nil
  local function _0_(...)
    if opts.filename then
      return ("@" .. opts.filename)
    else
      return str
    end
  end
  loader = specials["load-code"](lua_source, env, _0_(...))
  opts.filename = nil
  return loader(...)
end
local function dofile_2a(filename, options, ...)
  local opts = utils.copy(options)
  local f = assert(io.open(filename, "rb"))
  local source = assert(f:read("*all"), ("Could not read " .. filename))
  f:close()
  opts.filename = filename
  return eval(source, opts, ...)
end
local function syntax()
  local body_3f = {"when", "with-open", "collect", "icollect", "lambda", "\206\187", "macro", "match"}
  local binding_3f = {"collect", "icollect", "each", "for", "let", "with-open"}
  local out = {}
  for k, v in pairs(compiler.scopes.global.specials) do
    local metadata = (compiler.metadata[v] or {})
    out[k] = {["binding-form?"] = utils["member?"](binding_3f, k), ["body-form?"] = metadata["fnl/body-form?"], ["special?"] = true}
  end
  for k, v in pairs(compiler.scopes.global.macros) do
    out[k] = {["binding-form?"] = utils["member?"](binding_3f, k), ["body-form?"] = utils["member?"](body_3f, k), ["macro?"] = true}
  end
  for k, v in pairs(_G) do
    local _0_0 = type(v)
    if (_0_0 == "function") then
      out[k] = {["global?"] = true}
    elseif (_0_0 == "table") then
      for k2, v2 in pairs(v) do
        if ("function" == type(v2)) then
          out[(k .. "." .. k2)] = {["function?"] = true}
        end
      end
    end
  end
  return out
end
local mod = {["comment?"] = utils["comment?"], ["compile-stream"] = compiler["compile-stream"], ["compile-string"] = compiler["compile-string"], ["list?"] = utils["list?"], ["load-code"] = specials["load-code"], ["macro-loaded"] = specials["macro-loaded"], ["macro-searchers"] = specials["macro-searchers"], ["make-searcher"] = specials["make-searcher"], ["search-module"] = specials["search-module"], ["sequence?"] = utils["sequence?"], ["string-stream"] = parser["string-stream"], ["sym-char?"] = parser["sym-char?"], ["sym?"] = utils["sym?"], comment = utils.comment, compile = compiler.compile, compile1 = compiler.compile1, compileStream = compiler["compile-stream"], compileString = compiler["compile-string"], doc = specials.doc, dofile = dofile_2a, eval = eval, gensym = compiler.gensym, granulate = parser.granulate, list = utils.list, loadCode = specials["load-code"], macroLoaded = specials["macro-loaded"], makeSearcher = specials["make-searcher"], make_searcher = specials["make-searcher"], mangle = compiler["global-mangling"], metadata = compiler.metadata, parser = parser.parser, path = utils.path, repl = repl, scope = compiler["make-scope"], searchModule = specials["search-module"], searcher = specials["make-searcher"](), sequence = utils.sequence, stringStream = parser["string-stream"], sym = utils.sym, syntax = syntax, traceback = compiler.traceback, unmangle = compiler["global-unmangling"], varg = utils.varg, version = "0.9.3-dev", view = view}
utils["fennel-module"] = mod
do
  local builtin_macros = [===[;; This module contains all the built-in Fennel macros. Unlike all the other
  ;; modules that are loaded by the old bootstrap compiler, this runs in the
  ;; compiler scope of the version of the compiler being defined.
  
  ;; The code for these macros is somewhat idiosyncratic because it cannot use any
  ;; macros which have not yet been defined.
  
  ;; TODO: some of these macros modify their arguments; we should stop doing that,
  ;; but in a way that preserves file/line metadata.
  
  (fn ->* [val ...]
    "Thread-first macro.
  Take the first value and splice it into the second form as its first argument.
  The value of the second form is spliced into the first arg of the third, etc."
    (var x val)
    (each [_ e (ipairs [...])]
      (let [elt (if (list? e) e (list e))]
        (table.insert elt 2 x)
        (set x elt)))
    x)
  
  (fn ->>* [val ...]
    "Thread-last macro.
  Same as ->, except splices the value into the last position of each form
  rather than the first."
    (var x val)
    (each [_ e (pairs [...])]
      (let [elt (if (list? e) e (list e))]
        (table.insert elt x)
        (set x elt)))
    x)
  
  (fn -?>* [val ...]
    "Nil-safe thread-first macro.
  Same as -> except will short-circuit with nil when it encounters a nil value."
    (if (= 0 (select "#" ...))
        val
        (let [els [...]
              e (table.remove els 1)
              el (if (list? e) e (list e))
              tmp (gensym)]
          (table.insert el 2 tmp)
          `(let [,tmp ,val]
             (if ,tmp
                 (-?> ,el ,(unpack els))
                 ,tmp)))))
  
  (fn -?>>* [val ...]
    "Nil-safe thread-last macro.
  Same as ->> except will short-circuit with nil when it encounters a nil value."
    (if (= 0 (select "#" ...))
        val
        (let [els [...]
              e (table.remove els 1)
              el (if (list? e) e (list e))
              tmp (gensym)]
          (table.insert el tmp)
          `(let [,tmp ,val]
             (if ,tmp
                 (-?>> ,el ,(unpack els))
                 ,tmp)))))
  
  (fn ?dot [tbl ...]
    "Nil-safe table look up.
  Same as . (dot), except will short-circuit with nil when it encounters
  a nil value in any of subsequent keys."
    (let [head (gensym :t)
          lookups `(do (var ,head ,tbl) ,head)]
      (each [_ k (ipairs [...])]
        ;; Kinda gnarly to reassign in place like this, but it emits the best lua.
        ;; With this impl, it emits a flat, concise, and readable set of if blocks.
        (table.insert lookups (# lookups) `(if (not= nil ,head)
                                             (set ,head (. ,head ,k)))))
      lookups))
  
  (fn doto* [val ...]
    "Evaluates val and splices it into the first argument of subsequent forms."
    (let [name (gensym)
          form `(let [,name ,val])]
      (each [_ elt (pairs [...])]
        (table.insert elt 2 name)
        (table.insert form elt))
      (table.insert form name)
      form))
  
  (fn when* [condition body1 ...]
    "Evaluate body for side-effects only when condition is truthy."
    (assert body1 "expected body")
    `(if ,condition
         (do
           ,body1
           ,...)))
  
  (fn with-open* [closable-bindings ...]
    "Like `let`, but invokes (v:close) on each binding after evaluating the body.
  The body is evaluated inside `xpcall` so that bound values will be closed upon
  encountering an error before propagating it."
    (let [bodyfn `(fn []
                    ,...)
          closer `(fn close-handlers# [ok# ...]
                    (if ok# ... (error ... 0)))
          traceback `(. (or package.loaded.fennel debug) :traceback)]
      (for [i 1 (length closable-bindings) 2]
        (assert (sym? (. closable-bindings i))
                "with-open only allows symbols in bindings")
        (table.insert closer 4 `(: ,(. closable-bindings i) :close)))
      `(let ,closable-bindings
         ,closer
         (close-handlers# (xpcall ,bodyfn ,traceback)))))
  
  (fn collect* [iter-tbl key-value-expr ...]
    "Returns a table made by running an iterator and evaluating an expression
  that returns key-value pairs to be inserted sequentially into the table.
  This can be thought of as a \"table comprehension\". The provided key-value
  expression must return either 2 values, or nil.
  
  For example,
    (collect [k v (pairs {:apple \"red\" :orange \"orange\"})]
      (values v k))
  returns
    {:red \"apple\" :orange \"orange\"}"
    (assert (and (sequence? iter-tbl) (>= (length iter-tbl) 2))
            "expected iterator binding table")
    (assert (not= nil key-value-expr) "expected key-value expression")
    (assert (= nil ...)
            "expected exactly one body expression. Wrap multiple expressions with do")
    `(let [tbl# {}]
       (each ,iter-tbl
         (match ,key-value-expr
           (k# v#) (tset tbl# k# v#)))
       tbl#))
  
  (fn icollect* [iter-tbl value-expr ...]
    "Returns a sequential table made by running an iterator and evaluating an
  expression that returns values to be inserted sequentially into the table.
  This can be thought of as a \"list comprehension\".
  
  For example,
    (icollect [_ v (ipairs [1 2 3 4 5])] (when (> v 2) (* v v)))
  returns
    [9 16 25]"
    (assert (and (sequence? iter-tbl) (>= (length iter-tbl) 2))
            "expected iterator binding table")
    (assert (not= nil value-expr) "expected table value expression")
    (assert (= nil ...)
            "expected exactly one body expression. Wrap multiple expressions with do")
    `(let [tbl# []]
       (each ,iter-tbl
         (tset tbl# (+ (length tbl#) 1) ,value-expr))
       tbl#))
  
  (fn partial* [f ...]
    "Returns a function with all arguments partially applied to f."
    (assert f "expected a function to partially apply")
    (let [body (list f ...)]
      (table.insert body _VARARG)
      `(fn [,_VARARG]
         ,body)))
  
  (fn pick-args* [n f]
    "Creates a function of arity n that applies its arguments to f.
  
  For example,
    (pick-args 2 func)
  expands to
    (fn [_0_ _1_] (func _0_ _1_))"
    (assert (and (= (type n) :number) (= n (math.floor n)) (>= n 0))
            (.. "Expected n to be an integer literal >= 0, got " (tostring n)))
    (let [bindings []]
      (for [i 1 n]
        (tset bindings i (gensym)))
      `(fn ,bindings
         (,f ,(unpack bindings)))))
  
  (fn pick-values* [n ...]
    "Like the `values` special, but emits exactly n values.
  
  For example,
    (pick-values 2 ...)
  expands to
    (let [(_0_ _1_) ...]
      (values _0_ _1_))"
    (assert (and (= :number (type n)) (>= n 0) (= n (math.floor n)))
            (.. "Expected n to be an integer >= 0, got " (tostring n)))
    (let [let-syms (list)
          let-values (if (= 1 (select "#" ...)) ... `(values ,...))]
      (for [i 1 n]
        (table.insert let-syms (gensym)))
      (if (= n 0) `(values)
          `(let [,let-syms ,let-values]
             (values ,(unpack let-syms))))))
  
  (fn lambda* [...]
    "Function literal with arity checking.
  Will throw an exception if a declared argument is passed in as nil, unless
  that argument name begins with ?."
    (let [args [...]
          has-internal-name? (sym? (. args 1))
          arglist (if has-internal-name? (. args 2) (. args 1))
          docstring-position (if has-internal-name? 3 2)
          has-docstring? (and (> (length args) docstring-position)
                              (= :string (type (. args docstring-position))))
          arity-check-position (- 4 (if has-internal-name? 0 1)
                                  (if has-docstring? 0 1))
          empty-body? (< (length args) arity-check-position)]
      (fn check! [a]
        (if (table? a)
            (each [_ a (pairs a)]
              (check! a))
            (let [as (tostring a)]
              (and (not (as:match "^?")) (not= as "&") (not= as "_")
                   (not= as "...")))
            (table.insert args arity-check-position
                          `(assert (not= nil ,a)
                                   (string.format "Missing argument %s on %s:%s"
                                                  ,(tostring a)
                                                  ,(or a.filename :unknown)
                                                  ,(or a.line "?"))))))
  
      (assert (= :table (type arglist)) "expected arg list")
      (each [_ a (ipairs arglist)]
        (check! a))
      (if empty-body?
          (table.insert args (sym :nil)))
      `(fn ,(unpack args))))
  
  (fn macro* [name ...]
    "Define a single macro."
    (assert (sym? name) "expected symbol for macro name")
    (local args [...])
    `(macros {,(tostring name) (fn ,(unpack args))}))
  
  (fn macrodebug* [form return?]
    "Print the resulting form after performing macroexpansion.
  With a second argument, returns expanded form as a string instead of printing."
    (let [handle (if return? `do `print)]
      `(,handle ,(view (macroexpand form _SCOPE)))))
  
  (fn import-macros* [binding1 module-name1 ...]
    "Binds a table of macros from each macro module according to a binding form.
  Each binding form can be either a symbol or a k/v destructuring table.
  Example:
    (import-macros mymacros                 :my-macros    ; bind to symbol
                   {:macro1 alias : macro2} :proj.macros) ; import by name"
    (assert (and binding1 module-name1 (= 0 (% (select "#" ...) 2)))
            "expected even number of binding/modulename pairs")
    (for [i 1 (select "#" binding1 module-name1 ...) 2]
      (let [(binding modname) (select i binding1 module-name1 ...)
            ;; generate a subscope of current scope, use require-macros
            ;; to bring in macro module. after that, we just copy the
            ;; macros from subscope to scope.
            scope (get-scope)
            subscope (fennel.scope scope)]
        (_SPECIALS.require-macros `(require-macros ,modname) subscope {} ast)
        (if (sym? binding)
            ;; bind whole table of macros to table bound to symbol
            (do
              (tset scope.macros (. binding 1) {})
              (each [k v (pairs subscope.macros)]
                (tset (. scope.macros (. binding 1)) k v)))
            ;; 1-level table destructuring for importing individual macros
            (table? binding)
            (each [macro-name [import-key] (pairs binding)]
              (assert (= :function (type (. subscope.macros macro-name)))
                      (.. "macro " macro-name " not found in module "
                          (tostring modname)))
              (tset scope.macros import-key (. subscope.macros macro-name))))))
    nil)
  
  ;;; Pattern matching
  
  (fn match-values [vals pattern unifications match-pattern]
    (let [condition `(and)
          bindings []]
      (each [i pat (ipairs pattern)]
        (let [(subcondition subbindings) (match-pattern [(. vals i)] pat
                                                        unifications)]
          (table.insert condition subcondition)
          (each [_ b (ipairs subbindings)]
            (table.insert bindings b))))
      (values condition bindings)))
  
  (fn match-table [val pattern unifications match-pattern]
    (let [condition `(and (= (type ,val) :table))
          bindings []]
      (each [k pat (pairs pattern)]
        (if (= pat `&)
            (do
              (assert (= nil (. pattern (+ k 2)))
                      "expected & rest argument before last parameter")
              (table.insert bindings (. pattern (+ k 1)))
              (table.insert bindings
                            [`(select ,k ((or table.unpack _G.unpack) ,val))]))
            (= k `&as)
            (do
              (table.insert bindings pat)
              (table.insert bindings val))
            (and (= :number (type k)) (= `&as pat))
            (do
              (assert (= nil (. pattern (+ k 2)))
                      "expected &as argument before last parameter")
              (table.insert bindings (. pattern (+ k 1)))
              (table.insert bindings val))
            ;; don't process the pattern right after &/&as; already got it
            (or (not= :number (type k)) (and (not= `&as (. pattern (- k 1)))
                                             (not= `& (. pattern (- k 1)))))
            (let [subval `(. ,val ,k)
                  (subcondition subbindings) (match-pattern [subval] pat
                                                            unifications)]
              (table.insert condition subcondition)
              (each [_ b (ipairs subbindings)]
                (table.insert bindings b)))))
      (values condition bindings)))
  
  (fn match-pattern [vals pattern unifications]
    "Takes the AST of values and a single pattern and returns a condition
  to determine if it matches as well as a list of bindings to
  introduce for the duration of the body if it does match."
    ;; we have to assume we're matching against multiple values here until we
    ;; know we're either in a multi-valued clause (in which case we know the #
    ;; of vals) or we're not, in which case we only care about the first one.
    (let [[val] vals]
      (if (or (and (sym? pattern) ; unification with outer locals (or nil)
                   (not= "_" (tostring pattern)) ; never unify _
                   (or (in-scope? pattern) (= :nil (tostring pattern))))
              (and (multi-sym? pattern) (in-scope? (. (multi-sym? pattern) 1))))
          (values `(= ,val ,pattern) [])
          ;; unify a local we've seen already
          (and (sym? pattern) (. unifications (tostring pattern)))
          (values `(= ,(. unifications (tostring pattern)) ,val) [])
          ;; bind a fresh local
          (sym? pattern)
          (let [wildcard? (: (tostring pattern) :find "^_")]
            (if (not wildcard?) (tset unifications (tostring pattern) val))
            (values (if (or wildcard? (string.find (tostring pattern) "^?")) true
                        `(not= ,(sym :nil) ,val)) [pattern val]))
          ;; guard clause
          (and (list? pattern) (= (. pattern 2) `?))
          (let [(pcondition bindings) (match-pattern vals (. pattern 1)
                                                     unifications)
                condition `(and ,(unpack pattern 3))]
            (values `(and ,pcondition
                          (let ,bindings
                            ,condition)) bindings))
          ;; multi-valued patterns (represented as lists)
          (list? pattern)
          (match-values vals pattern unifications match-pattern)
          ;; table patterns
          (= (type pattern) :table)
          (match-table val pattern unifications match-pattern)
          ;; literal value
          (values `(= ,val ,pattern) []))))
  
  (fn match-condition [vals clauses]
    "Construct the actual `if` AST for the given match values and clauses."
    (if (not= 0 (% (length clauses) 2)) ; treat odd final clause as default
        (table.insert clauses (length clauses) (sym "_")))
    (let [out `(if)]
      (for [i 1 (length clauses) 2]
        (let [pattern (. clauses i)
              body (. clauses (+ i 1))
              (condition bindings) (match-pattern vals pattern {})]
          (table.insert out condition)
          (table.insert out `(let ,bindings
                               ,body))))
      out))
  
  (fn match-val-syms [clauses]
    "How many multi-valued clauses are there? return a list of that many gensyms."
    (let [syms (list (gensym))]
      (for [i 1 (length clauses) 2]
        (let [clause (if (and (list? (. clauses i)) (= `? (. clauses i 2)))
                         (. clauses i 1)
                         (. clauses i))]
          (if (list? clause)
              (each [valnum (ipairs clause)]
                (if (not (. syms valnum))
                    (tset syms valnum (gensym)))))))
      syms))
  
  (fn match* [val ...]
    ;; Old implementation of match macro, which doesn't directly support
    ;; `where' and `or'. New syntax is implemented in `match-where',
    ;; which simply generates old syntax and feeds it to `match*'.
    (let [clauses [...]
          vals (match-val-syms clauses)]
      ;; protect against multiple evaluation of the value, bind against as
      ;; many values as we ever match against in the clauses.
      (list `let [vals val] (match-condition vals clauses))))
  
  ;; Construction of old match syntax from new syntax
  
  (fn partition-2 [seq]
    ;; Partition `seq` by 2.
    ;; If `seq` has odd amount of elements, the last one is dropped.
    ;;
    ;; Input: [1 2 3 4 5]
    ;; Output: [[1 2] [3 4]]
    (let [firsts []
          seconds []
          res []]
      (for [i 1 (length seq) 2]
        (let [first (. seq i)
              second (. seq (+ i 1))]
          (table.insert firsts (if (not= nil first) first `nil))
          (table.insert seconds (if (not= nil second) second `nil))))
      (each [i v1 (ipairs firsts)]
        (let [v2 (. seconds i)]
          (if (not= nil v2)
              (table.insert res [v1 v2]))))
      res))
  
  (fn transform-or [[_ & pats] guards]
    ;; Transforms `(or pat pats*)` lists into match `guard` patterns.
    ;;
    ;; (or pat1 pat2), guard => [(pat1 ? guard) (pat2 ? guard)]
    (let [res []]
      (each [_ pat (ipairs pats)]
        (table.insert res (list pat `? (unpack guards))))
      res))
  
  (fn transform-cond [cond]
    ;; Transforms `where` cond into sequence of `match` guards.
    ;;
    ;; pat => [pat]
    ;; (where pat guard) => [(pat ? guard)]
    ;; (where (or pat1 pat2) guard) => [(pat1 ? guard) (pat2 ? guard)]
    (if (and (list? cond) (= (. cond 1) `where))
        (let [second (. cond 2)]
          (if (and (list? second) (= (. second 1) `or))
              (transform-or second [(unpack cond 3)])
              :else
              [(list second `? (unpack cond 3))]))
        :else
        [cond]))
  
  (fn match-where [val ...]
    "Perform pattern matching on val. See reference for details.
  
  Syntax:
  
  (match data-expression
    pattern body
    (where pattern guard guards*) body
    (where (or pattern patterns*) guard guards*) body)"
    (let [conds-bodies (partition-2 [...])
          else-branch (if (not= 0 (% (select "#" ...) 2))
                          (select (select "#" ...) ...))
          match-body []]
      (each [_ [cond body] (ipairs conds-bodies)]
        (each [_ cond (ipairs (transform-cond cond))]
          (table.insert match-body cond)
          (table.insert match-body body)))
      (if else-branch
          (table.insert match-body else-branch))
      (match* val (unpack match-body))))
  
  {:-> ->*
   :->> ->>*
   :-?> -?>*
   :-?>> -?>>*
   :?. ?dot
   :doto doto*
   :when when*
   :with-open with-open*
   :collect collect*
   :icollect icollect*
   :partial partial*
   :lambda lambda*
   :pick-args pick-args*
   :pick-values pick-values*
   :macro macro*
   :macrodebug macrodebug*
   :import-macros import-macros*
   :match match-where}
  ]===]
  local module_name = "nvim-tree-docs.aniseed.fennel.macros"
  local _ = nil
  local function _0_()
    return mod
  end
  package.preload[module_name] = _0_
  _ = nil
  local env = nil
  do
    local _1_0 = specials["make-compiler-env"](nil, compiler.scopes.compiler, {})
    _1_0["utils"] = utils
    _1_0["fennel"] = mod
    env = _1_0
  end
  local built_ins = eval(builtin_macros, {allowedGlobals = false, env = env, filename = "src/fennel/macros.fnl", moduleName = module_name, scope = compiler.scopes.compiler, useMetadata = true})
  for k, v in pairs(built_ins) do
    compiler.scopes.global.macros[k] = v
  end
  compiler.scopes.global.macros["\206\187"] = compiler.scopes.global.macros.lambda
  package.preload[module_name] = nil
end
return mod


================================================
FILE: lua/nvim-tree-docs/aniseed/deps/fennelview.lua
================================================
local type_order = {["function"] = 5, boolean = 2, number = 1, string = 3, table = 4, thread = 7, userdata = 6}
local function sort_keys(_0_0, _1_0)
  local _1_ = _0_0
  local a = _1_[1]
  local _2_ = _1_0
  local b = _2_[1]
  local ta = type(a)
  local tb = type(b)
  if ((ta == tb) and ((ta == "string") or (ta == "number"))) then
    return (a < b)
  else
    local dta = type_order[ta]
    local dtb = type_order[tb]
    if (dta and dtb) then
      return (dta < dtb)
    elseif dta then
      return true
    elseif dtb then
      return false
    else
      return (ta < tb)
    end
  end
end
local function table_kv_pairs(t)
  local assoc_3f = false
  local i = 1
  local kv = {}
  local insert = table.insert
  for k, v in pairs(t) do
    if ((type(k) ~= "number") or (k ~= i)) then
      assoc_3f = true
    end
    i = (i + 1)
    insert(kv, {k, v})
  end
  table.sort(kv, sort_keys)
  if (#kv == 0) then
    return kv, "empty"
  else
    local function _2_()
      if assoc_3f then
        return "table"
      else
        return "seq"
      end
    end
    return kv, _2_()
  end
end
local function count_table_appearances(t, appearances)
  if (type(t) == "table") then
    if not appearances[t] then
      appearances[t] = 1
      for k, v in pairs(t) do
        count_table_appearances(k, appearances)
        count_table_appearances(v, appearances)
      end
    else
      appearances[t] = ((appearances[t] or 0) + 1)
    end
  end
  return appearances
end
local function save_table(t, seen)
  local seen0 = (seen or {len = 0})
  local id = (seen0.len + 1)
  if not seen0[t] then
    seen0[t] = id
    seen0.len = id
  end
  return seen0
end
local function detect_cycle(t, seen, _3fk)
  if ("table" == type(t)) then
    seen[t] = true
    local _2_0, _3_0 = next(t, _3fk)
    if ((nil ~= _2_0) and (nil ~= _3_0)) then
      local k = _2_0
      local v = _3_0
      return (seen[k] or detect_cycle(k, seen) or seen[v] or detect_cycle(v, seen) or detect_cycle(t, seen, k))
    end
  end
end
local function visible_cycle_3f(t, options)
  return (options["detect-cycles?"] and detect_cycle(t, {}) and save_table(t, options.seen) and (1 < (options.appearances[t] or 0)))
end
local function table_indent(t, indent, id)
  local opener_length = nil
  if id then
    opener_length = (#tostring(id) + 2)
  else
    opener_length = 1
  end
  return (indent + opener_length)
end
local pp = nil
local function concat_table_lines(elements, options, multiline_3f, indent, table_type, prefix)
  local indent_str = ("\n" .. string.rep(" ", indent))
  local open = nil
  local function _2_()
    if ("seq" == table_type) then
      return "["
    else
      return "{"
    end
  end
  open = ((prefix or "") .. _2_())
  local close = nil
  if ("seq" == table_type) then
    close = "]"
  else
    close = "}"
  end
  local oneline = (open .. table.concat(elements, " ") .. close)
  if (not options["one-line?"] and (multiline_3f or ((indent + #oneline) > options["line-length"]))) then
    return (open .. table.concat(elements, indent_str) .. close)
  else
    return oneline
  end
end
local function pp_associative(t, kv, options, indent, key_3f)
  local multiline_3f = false
  local id = options.seen[t]
  if (options.level >= options.depth) then
    return "{...}"
  elseif (id and options["detect-cycles?"]) then
    return ("@" .. id .. "{...}")
  else
    local visible_cycle_3f0 = visible_cycle_3f(t, options)
    local id0 = (visible_cycle_3f0 and options.seen[t])
    local indent0 = table_indent(t, indent, id0)
    local slength = nil
    local function _3_()
      local _2_0 = rawget(_G, "utf8")
      if _2_0 then
        return _2_0.len
      else
        return _2_0
      end
    end
    local function _4_(_241)
      return #_241
    end
    slength = ((options["utf8?"] and _3_()) or _4_)
    local prefix = nil
    if visible_cycle_3f0 then
      prefix = ("@" .. id0)
    else
      prefix = ""
    end
    local items = nil
    do
      local tbl_0_ = {}
      for _, _6_0 in pairs(kv) do
        local _7_ = _6_0
        local k = _7_[1]
        local v = _7_[2]
        local _8_
        do
          local k0 = pp(k, options, (indent0 + 1), true)
          local v0 = pp(v, options, (indent0 + slength(k0) + 1))
          multiline_3f = (multiline_3f or k0:find("\n") or v0:find("\n"))
          _8_ = (k0 .. " " .. v0)
        end
        tbl_0_[(#tbl_0_ + 1)] = _8_
      end
      items = tbl_0_
    end
    return concat_table_lines(items, options, multiline_3f, indent0, "table", prefix)
  end
end
local function pp_sequence(t, kv, options, indent)
  local multiline_3f = false
  local id = options.seen[t]
  if (options.level >= options.depth) then
    return "[...]"
  elseif (id and options["detect-cycles?"]) then
    return ("@" .. id .. "[...]")
  else
    local visible_cycle_3f0 = visible_cycle_3f(t, options)
    local id0 = (visible_cycle_3f0 and options.seen[t])
    local indent0 = table_indent(t, indent, id0)
    local prefix = nil
    if visible_cycle_3f0 then
      prefix = ("@" .. id0)
    else
      prefix = ""
    end
    local items = nil
    do
      local tbl_0_ = {}
      for _, _3_0 in pairs(kv) do
        local _4_ = _3_0
        local _0 = _4_[1]
        local v = _4_[2]
        local _5_
        do
          local v0 = pp(v, options, indent0)
          multiline_3f = (multiline_3f or v0:find("\n"))
          _5_ = v0
        end
        tbl_0_[(#tbl_0_ + 1)] = _5_
      end
      items = tbl_0_
    end
    return concat_table_lines(items, options, multiline_3f, indent0, "seq", prefix)
  end
end
local function concat_lines(lines, options, indent, force_multi_line_3f)
  if (#lines == 0) then
    if options["empty-as-sequence?"] then
      return "[]"
    else
      return "{}"
    end
  else
    local oneline = nil
    local _2_
    do
      local tbl_0_ = {}
      for _, line in ipairs(lines) do
        tbl_0_[(#tbl_0_ + 1)] = line:gsub("^%s+", "")
      end
      _2_ = tbl_0_
    end
    oneline = table.concat(_2_, " ")
    if (not options["one-line?"] and (force_multi_line_3f or oneline:find("\n") or ((indent + #oneline) > options["line-length"]))) then
      return table.concat(lines, ("\n" .. string.rep(" ", indent)))
    else
      return oneline
    end
  end
end
local function pp_metamethod(t, metamethod, options, indent)
  if (options.level >= options.depth) then
    if options["empty-as-sequence?"] then
      return "[...]"
    else
      return "{...}"
    end
  else
    local _ = nil
    local function _2_(_241)
      return visible_cycle_3f(_241, options)
    end
    options["visible-cycle?"] = _2_
    _ = nil
    local lines, force_multi_line_3f = metamethod(t, pp, options, indent)
    options["visible-cycle?"] = nil
    local _3_0 = type(lines)
    if (_3_0 == "string") then
      return lines
    elseif (_3_0 == "table") then
      return concat_lines(lines, options, indent, force_multi_line_3f)
    else
      local _0 = _3_0
      return error("__fennelview metamethod must return a table of lines")
    end
  end
end
local function pp_table(x, options, indent)
  options.level = (options.level + 1)
  local x0 = nil
  do
    local _2_0 = nil
    if options["metamethod?"] then
      local _3_0 = x
      if _3_0 then
        local _4_0 = getmetatable(_3_0)
        if _4_0 then
          _2_0 = _4_0.__fennelview
        else
          _2_0 = _4_0
        end
      else
        _2_0 = _3_0
      end
    else
    _2_0 = nil
    end
    if (nil ~= _2_0) then
      local metamethod = _2_0
      x0 = pp_metamethod(x, metamethod, options, indent)
    else
      local _ = _2_0
      local _4_0, _5_0 = table_kv_pairs(x)
      if (true and (_5_0 == "empty")) then
        local _0 = _4_0
        if options["empty-as-sequence?"] then
          x0 = "[]"
        else
          x0 = "{}"
        end
      elseif ((nil ~= _4_0) and (_5_0 == "table")) then
        local kv = _4_0
        x0 = pp_associative(x, kv, options, indent)
      elseif ((nil ~= _4_0) and (_5_0 == "seq")) then
        local kv = _4_0
        x0 = pp_sequence(x, kv, options, indent)
      else
      x0 = nil
      end
    end
  end
  options.level = (options.level - 1)
  return x0
end
local function number__3estring(n)
  local _2_0 = string.gsub(tostring(n), ",", ".")
  return _2_0
end
local function colon_string_3f(s)
  return s:find("^[-%w?^_!$%&*+./@|<=>]+$")
end
local function pp_string(str, options, indent)
  local escs = nil
  local _2_
  if (options["escape-newlines?"] and (#str < (options["line-length"] - indent))) then
    _2_ = "\\n"
  else
    _2_ = "\n"
  end
  local function _4_(_241, _242)
    return ("\\%03d"):format(_242:byte())
  end
  escs = setmetatable({["\""] = "\\\"", ["\11"] = "\\v", ["\12"] = "\\f", ["\13"] = "\\r", ["\7"] = "\\a", ["\8"] = "\\b", ["\9"] = "\\t", ["\\"] = "\\\\", ["\n"] = _2_}, {__index = _4_})
  return ("\"" .. str:gsub("[%c\\\"]", escs) .. "\"")
end
local function make_options(t, options)
  local defaults = {["detect-cycles?"] = true, ["empty-as-sequence?"] = false, ["escape-newlines?"] = false, ["line-length"] = 80, ["metamethod?"] = true, ["one-line?"] = false, ["prefer-colon?"] = false, ["utf8?"] = true, depth = 128}
  local overrides = {appearances = count_table_appearances(t, {}), level = 0, seen = {len = 0}}
  for k, v in pairs((options or {})) do
    defaults[k] = v
  end
  for k, v in pairs(overrides) do
    defaults[k] = v
  end
  return defaults
end
local function _2_(x, options, indent, colon_3f)
  local indent0 = (indent or 0)
  local options0 = (options or make_options(x))
  local tv = type(x)
  local function _4_()
    local _3_0 = getmetatable(x)
    if _3_0 then
      return _3_0.__fennelview
    else
      return _3_0
    end
  end
  if ((tv == "table") or ((tv == "userdata") and _4_())) then
    return pp_table(x, options0, indent0)
  elseif (tv == "number") then
    return number__3estring(x)
  else
    local function _5_()
      if (colon_3f ~= nil) then
        return colon_3f
      elseif ("function" == type(options0["prefer-colon?"])) then
        return options0["prefer-colon?"](x)
      else
        return options0["prefer-colon?"]
      end
    end
    if ((tv == "string") and colon_string_3f(x) and _5_()) then
      return (":" .. x)
    elseif (tv == "string") then
      return pp_string(x, options0, indent0)
    elseif ((tv == "boolean") or (tv == "nil")) then
      return tostring(x)
    else
      return ("#<" .. tostring(x) .. ">")
    end
  end
end
pp = _2_
local function view(x, options)
  return pp(x, make_options(x, options), 0)
end
return view


================================================
FILE: lua/nvim-tree-docs/aniseed/deps/nvim.lua
================================================
-- Bring vim into local scope.
local vim = vim
local api = vim.api
local inspect = vim.inspect

local function extend(t, o)
  local mt = getmetatable(t)
  for k, v in pairs(o) do
    rawset(mt, k, v)
  end
  return t
end

-- Equivalent to `echo vim.inspect(...)`
local function nvim_print(...)
  if select("#", ...) == 1 then
    api.nvim_out_write(inspect((...)))
  else
    api.nvim_out_write(inspect {...})
  end
  api.nvim_out_write("\n")
end

--- Equivalent to `echo` EX command
local function nvim_echo(...)
  for i = 1, select("#", ...) do
    local part = select(i, ...)
    api.nvim_out_write(tostring(part))
    -- vim.api.nvim_out_write("\n")
    api.nvim_out_write(" ")
  end
  api.nvim_out_write("\n")
end

local window_options = {
            arab = true;       arabic = true;   breakindent = true; breakindentopt = true;
             bri = true;       briopt = true;            cc = true;           cocu = true;
            cole = true;  colorcolumn = true; concealcursor = true;   conceallevel = true;
             crb = true;          cuc = true;           cul = true;     cursorbind = true;
    cursorcolumn = true;   cursorline = true;          diff = true;            fcs = true;
             fdc = true;          fde = true;           fdi = true;            fdl = true;
             fdm = true;          fdn = true;           fdt = true;            fen = true;
       fillchars = true;          fml = true;           fmr = true;     foldcolumn = true;
      foldenable = true;     foldexpr = true;    foldignore = true;      foldlevel = true;
      foldmarker = true;   foldmethod = true;  foldminlines = true;    foldnestmax = true;
        foldtext = true;          lbr = true;           lcs = true;      linebreak = true;
            list = true;    listchars = true;            nu = true;         number = true;
     numberwidth = true;          nuw = true; previewwindow = true;            pvw = true;
  relativenumber = true;    rightleft = true;  rightleftcmd = true;             rl = true;
             rlc = true;          rnu = true;           scb = true;            scl = true;
             scr = true;       scroll = true;    scrollbind = true;     signcolumn = true;
           spell = true;   statusline = true;           stl = true;            wfh = true;
             wfw = true;        winbl = true;      winblend = true;   winfixheight = true;
     winfixwidth = true; winhighlight = true;         winhl = true;           wrap = true;
}

local function validate(conf)
  assert(type(conf) == 'table')
  local type_names = {
    t='table', s='string', n='number', b='boolean', f='function', c='callable',
    ['table']='table', ['string']='string', ['number']='number',
    ['boolean']='boolean', ['function']='function', ['callable']='callable',
    ['nil']='nil', ['thread']='thread', ['userdata']='userdata',
  }
  for k, v in pairs(conf) do
    if not (v[3] and v[1] == nil) and type(v[1]) ~= type_names[v[2]] then
      error(string.format("validation_failed: %q: expected %s, received %s", k, type_names[v[2]], type(v[1])))
    end
  end
  return true
end

local function make_meta_accessor(get, set, del)
  validate {
    get = {get, 'f'};
    set = {set, 'f'};
    del = {del, 'f', true};
  }
  local mt = {}
  if del then
    function mt:__newindex(k, v)
      if v == nil then
        return del(k)
      end
      return set(k, v)
    end
  else
    function mt:__newindex(k, v)
      return set(k, v)
    end
  end
  function mt:__index(k)
    return get(k)
  end
  return setmetatable({}, mt)
end

local function pcall_ret(status, ...)
  if status then return ... end
end

local function nil_wrap(fn)
  return function(...)
    return pcall_ret(pcall(fn, ...))
  end
end

local fn = setmetatable({}, {
  __index = function(t, k)
    local f = function(...) return api.nvim_call_function(k, {...}) end
    rawset(t, k, f)
    return f
  end
})

local function getenv(k)
  local v = fn.getenv(k)
  if v == vim.NIL then
    return nil
  end
  return v
end

local function new_win_accessor(winnr)
  local function get(k)
    if winnr == nil and type(k) == 'number' then
      return new_win_accessor(k)
    end
    return api.nvim_win_get_var(winnr or 0, k)
  end
  local function set(k, v) return api.nvim_win_set_var(winnr or 0, k, v) end
  local function del(k)    return api.nvim_win_del_var(winnr or 0, k) end
  return make_meta_accessor(nil_wrap(get), set, del)
end

local function new_win_opt_accessor(winnr)
  local function get(k)
    if winnr == nil and type(k) == 'number' then
      return new_win_opt_accessor(k)
    end
    return api.nvim_win_get_option(winnr or 0, k)
  end
  local function set(k, v) return api.nvim_win_set_option(winnr or 0, k, v) end
  return make_meta_accessor(nil_wrap(get), set)
end

local function new_buf_accessor(bufnr)
  local function get(k)
    if bufnr == nil and type(k) == 'number' then
      return new_buf_accessor(k)
    end
    return api.nvim_buf_get_var(bufnr or 0, k)
  end
  local function set(k, v) return api.nvim_buf_set_var(bufnr or 0, k, v) end
  local function del(k)    return api.nvim_buf_del_var(bufnr or 0, k) end
  return make_meta_accessor(nil_wrap(get), set, del)
end

local function new_buf_opt_accessor(bufnr)
  local function get(k)
    if window_options[k] then
      return api.nvim_err_writeln(k.." is a window option, not a buffer option")
    end
    if bufnr == nil and type(k) == 'number' then
      return new_buf_opt_accessor(k)
    end
    return api.nvim_buf_get_option(bufnr or 0, k)
  end
  local function set(k, v)
    if window_options[k] then
      return api.nvim_err_writeln(k.." is a window option, not a buffer option")
    end
    return api.nvim_buf_set_option(bufnr or 0, k, v)
  end
  return make_meta_accessor(nil_wrap(get), set)
end

-- `nvim.$method(...)` redirects to `nvim.api.nvim_$method(...)`
-- `nvim.fn.$method(...)` redirects to `vim.api.nvim_call_function($method, {...})`
-- TODO `nvim.ex.$command(...)` is approximately `:$command {...}.join(" ")`
-- `nvim.print(...)` is approximately `echo vim.inspect(...)`
-- `nvim.echo(...)` is approximately `echo table.concat({...}, '\n')`
-- Both methods cache the inital lookup in the metatable, but there is api small overhead regardless.
return setmetatable({
  print = nvim_print;
  echo = nvim_echo;
  fn = rawget(vim, "fn") or fn;
  validate = validate;
  g = rawget(vim, 'g') or make_meta_accessor(nil_wrap(api.nvim_get_var), api.nvim_set_var, api.nvim_del_var);
  v = rawget(vim, 'v') or make_meta_accessor(nil_wrap(api.nvim_get_vvar), api.nvim_set_vvar);
  o = rawget(vim, 'o') or make_meta_accessor(api.nvim_get_option, api.nvim_set_option);
  w = new_win_accessor(nil);
  b = new_buf_accessor(nil);
  env = rawget(vim, "env") or make_meta_accessor(getenv, fn.setenv);
  wo = rawget(vim, "wo") or new_win_opt_accessor(nil);
  bo = rawget(vim, "bo") or new_buf_opt_accessor(nil);
  buf = {
    line = api.nvim_get_current_line;
    nr = api.nvim_get_current_buf;
  };
  ex = setmetatable({}, {
    __index = function(t, k)
      local command = k:gsub("_$", "!")
      local f = function(...)
        return api.nvim_command(table.concat(vim.tbl_flatten {command, ...}, " "))
      end
      rawset(t, k, f)
      return f
    end
  });
}, {
  __index = function(t, k)
    local f = api['nvim_'..k]
    if f then
      rawset(t, k, f)
    end
    return f
  end
})
-- vim:et ts=2 sw=2


================================================
FILE: lua/nvim-tree-docs/aniseed/env.lua
================================================
local _2afile_2a = "fnl/aniseed/env.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.env"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.compile"), autoload("nvim-tree-docs.aniseed.fennel"), autoload("nvim-tree-docs.aniseed.fs"), autoload("nvim-tree-docs.aniseed.nvim")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {compile = "nvim-tree-docs.aniseed.compile", fennel = "nvim-tree-docs.aniseed.fennel", fs = "nvim-tree-docs.aniseed.fs", nvim = "nvim-tree-docs.aniseed.nvim"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local compile = _local_0_[1]
local fennel = _local_0_[2]
local fs = _local_0_[3]
local nvim = _local_0_[4]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.env"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local config_dir
do
  local v_0_ = nvim.fn.stdpath("config")
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["config-dir"] = v_0_
  config_dir = v_0_
end
local quiet_require
do
  local v_0_
  local function quiet_require0(m)
    local ok_3f, err = nil, nil
    local function _3_()
      return require(m)
    end
    ok_3f, err = pcall(_3_)
    if (not ok_3f and not err:find(("module '" .. m .. "' not found"))) then
      return nvim.ex.echoerr(err)
    end
  end
  v_0_ = quiet_require0
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["quiet-require"] = v_0_
  quiet_require = v_0_
end
local init
do
  local v_0_
  do
    local v_0_0
    local function init0(opts)
      local opts0
      if ("table" == type(opts)) then
        opts0 = opts
      else
        opts0 = {}
      end
      local glob_expr = "**/*.fnl"
      local fnl_dir = (opts0.input or (config_dir .. fs["path-sep"] .. "fnl"))
      local lua_dir = (opts0.output or (config_dir .. fs["path-sep"] .. "lua"))
      package.path = (package.path .. ";" .. lua_dir .. fs["path-sep"] .. "?.lua")
      local function _4_(path)
        if fs["macro-file-path?"](path) then
          return path
        else
          return string.gsub(path, ".fnl$", ".lua")
        end
      end
      if (((false ~= opts0.compile) or os.getenv("ANISEED_ENV_COMPILE")) and fs["glob-dir-newer?"](fnl_dir, lua_dir, glob_expr, _4_)) then
        fennel["add-path"]((fnl_dir .. fs["path-sep"] .. "?.fnl"))
        compile.glob(glob_expr, fnl_dir, lua_dir, opts0)
      end
      return quiet_require((opts0.module or "init"))
    end
    v_0_0 = init0
    _0_["init"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["init"] = v_0_
  init = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/eval.lua
================================================
local _2afile_2a = "fnl/aniseed/eval.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.eval"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.core"), autoload("nvim-tree-docs.aniseed.compile"), autoload("nvim-tree-docs.aniseed.fennel"), autoload("nvim-tree-docs.aniseed.fs"), autoload("nvim-tree-docs.aniseed.nvim")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {a = "nvim-tree-docs.aniseed.core", compile = "nvim-tree-docs.aniseed.compile", fennel = "nvim-tree-docs.aniseed.fennel", fs = "nvim-tree-docs.aniseed.fs", nvim = "nvim-tree-docs.aniseed.nvim"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local a = _local_0_[1]
local compile = _local_0_[2]
local fennel = _local_0_[3]
local fs = _local_0_[4]
local nvim = _local_0_[5]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.eval"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local str
do
  local v_0_
  do
    local v_0_0
    local function str0(code, opts)
      local fnl = fennel.impl()
      local function _3_()
        return fnl.eval(compile["macros-prefix"](code, opts), a.merge({["compiler-env"] = _G}, opts))
      end
      return xpcall(_3_, fnl.traceback)
    end
    v_0_0 = str0
    _0_["str"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["str"] = v_0_
  str = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/fennel.lua
================================================
local _2afile_2a = "fnl/aniseed/fennel.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.fennel"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.fs"), autoload("nvim-tree-docs.aniseed.nvim")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {fs = "nvim-tree-docs.aniseed.fs", nvim = "nvim-tree-docs.aniseed.nvim"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local fs = _local_0_[1]
local nvim = _local_0_[2]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.fennel"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local sync_rtp
do
  local v_0_
  do
    local v_0_0
    local function sync_rtp0(compiler)
      local sep = fs["path-sep"]
      local fnl_suffix = (sep .. "fnl" .. sep .. "?.fnl")
      local rtp = nvim.o.runtimepath
      local fnl_path = (rtp:gsub(",", (fnl_suffix .. ";")) .. fnl_suffix)
      local lua_path = fnl_path:gsub((sep .. "fnl" .. sep), (sep .. "lua" .. sep))
      do end (compiler)["path"] = (fnl_path .. ";" .. lua_path)
      return nil
    end
    v_0_0 = sync_rtp0
    _0_["sync-rtp"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["sync-rtp"] = v_0_
  sync_rtp = v_0_
end
local state
do
  local v_0_ = {["compiler-loaded?"] = false}
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["state"] = v_0_
  state = v_0_
end
local impl
do
  local v_0_
  do
    local v_0_0
    local function impl0()
      local compiler = require("nvim-tree-docs.aniseed.deps.fennel")
      if not state["compiler-loaded?"] then
        state["compiler-loaded?"] = true
        sync_rtp(compiler)
      end
      return compiler
    end
    v_0_0 = impl0
    _0_["impl"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["impl"] = v_0_
  impl = v_0_
end
local add_path
do
  local v_0_
  do
    local v_0_0
    local function add_path0(path)
      local fnl = impl()
      do end (fnl)["path"] = (fnl.path .. ";" .. path)
      return nil
    end
    v_0_0 = add_path0
    _0_["add-path"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["add-path"] = v_0_
  add_path = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/fs.lua
================================================
local _2afile_2a = "fnl/aniseed/fs.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.fs"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.core"), autoload("nvim-tree-docs.aniseed.nvim")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {a = "nvim-tree-docs.aniseed.core", nvim = "nvim-tree-docs.aniseed.nvim"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local a = _local_0_[1]
local nvim = _local_0_[2]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.fs"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local path_sep
do
  local v_0_
  do
    local v_0_0
    do
      local os = string.lower(jit.os)
      if (("linux" == os) or ("osx" == os) or ("bsd" == os)) then
        v_0_0 = "/"
      else
        v_0_0 = "\\"
      end
    end
    _0_["path-sep"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["path-sep"] = v_0_
  path_sep = v_0_
end
local basename
do
  local v_0_
  do
    local v_0_0
    local function basename0(path)
      return nvim.fn.fnamemodify(path, ":h")
    end
    v_0_0 = basename0
    _0_["basename"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["basename"] = v_0_
  basename = v_0_
end
local mkdirp
do
  local v_0_
  do
    local v_0_0
    local function mkdirp0(dir)
      return nvim.fn.mkdir(dir, "p")
    end
    v_0_0 = mkdirp0
    _0_["mkdirp"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["mkdirp"] = v_0_
  mkdirp = v_0_
end
local relglob
do
  local v_0_
  do
    local v_0_0
    local function relglob0(dir, expr)
      local dir_len = a.inc(string.len(dir))
      local function _3_(_241)
        return string.sub(_241, dir_len)
      end
      return a.map(_3_, nvim.fn.globpath(dir, expr, true, true))
    end
    v_0_0 = relglob0
    _0_["relglob"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["relglob"] = v_0_
  relglob = v_0_
end
local glob_dir_newer_3f
do
  local v_0_
  do
    local v_0_0
    local function glob_dir_newer_3f0(a_dir, b_dir, expr, b_dir_path_fn)
      local newer_3f = false
      for _, path in ipairs(relglob(a_dir, expr)) do
        if (nvim.fn.getftime((a_dir .. path)) > nvim.fn.getftime((b_dir .. b_dir_path_fn(path)))) then
          newer_3f = true
        end
      end
      return newer_3f
    end
    v_0_0 = glob_dir_newer_3f0
    _0_["glob-dir-newer?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["glob-dir-newer?"] = v_0_
  glob_dir_newer_3f = v_0_
end
local macro_file_path_3f
do
  local v_0_
  do
    local v_0_0
    local function macro_file_path_3f0(path)
      return string.match(path, "macros.fnl$")
    end
    v_0_0 = macro_file_path_3f0
    _0_["macro-file-path?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["macro-file-path?"] = v_0_
  macro_file_path_3f = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/macros.fnl
================================================
;; All of Aniseed's macros in one place.
;; Can't be compiled to Lua directly.

;; Automatically loaded through require-macros for all Aniseed based evaluations.

(local module-sym (gensym))

(fn sorted-each [f x]
  (let [acc []]
    (each [k v (pairs x)]
      (table.insert acc [k v]))
    (table.sort
      acc
      (fn [a b]
        (< (. a 1) (. b 1))))
    (each [_ [k v] (ipairs acc)]
      (f k v))))

(fn module [name new-local-fns initial-mod]
  `(-> [(local ,module-sym
          (let [name# ,(tostring name)
                module# (let [x# (. package.loaded name#)]
                          (if (= :table (type x#))
                            x#
                            ,(or initial-mod {})))]
            (tset module# :aniseed/module name#)
            (tset module# :aniseed/locals (or (. module# :aniseed/locals) {}))
            (tset module# :aniseed/local-fns (or (. module# :aniseed/local-fns) {}))
            (tset package.loaded name# module#)
            module#))

        ,module-sym

        ;; Meta! Autoload the autoload function, so it's only loaded when used.
        (local ,(sym :autoload)
          (fn [...] ((. (require :aniseed.autoload) :autoload) ...)))

        ,(let [aliases []
               vals []
               effects []
               pkg (let [x (. package.loaded (tostring name))]
                     (when (= :table (type x))
                       x))
               locals (-?> pkg (. :aniseed/locals))
               local-fns (or (and (not new-local-fns)
                                  (?. pkg :aniseed/local-fns))
                             {})]

           (when new-local-fns
             (each [action binds (pairs new-local-fns)]
               (let [action-str (tostring action)
                     current (or (. local-fns action-str) {})]
                 (tset local-fns action-str current)
                 (each [alias module (pairs binds)]
                   (if (= :number (type alias))
                     (tset current (tostring module) true)
                     (tset current (tostring alias) (tostring module)))))))

           (sorted-each
             (fn [action binds]
               (sorted-each
                 (fn [alias-or-val val]
                   (if (= true val)

                     ;; {require-macros [bar]}
                     (table.insert effects `(,(sym action) ,alias-or-val))

                     ;; {require {foo bar}}
                     (do
                       (table.insert aliases (sym alias-or-val))
                       (table.insert vals `(,(sym action) ,val)))))

                 binds))
             local-fns)

           (when locals
             (sorted-each
               (fn [alias val]
                 (table.insert aliases (sym alias))
                 (table.insert vals `(. ,module-sym :aniseed/locals ,alias)))
               locals))

           `[,effects
             (local ,aliases
               (let [(ok?# val#)
                     (pcall
                       (fn [] ,vals))]
                 (if ok?#
                   (do
                     (tset ,module-sym :aniseed/local-fns ,local-fns)
                     val#)
                   (print val#))))
             (local ,(sym "*module*") ,module-sym)
             (local ,(sym "*module-name*") ,(tostring name))])]
       (. 2)))

(fn def- [name value]
  `(local ,name
     (let [v# ,value
           t# (. ,module-sym :aniseed/locals)]
       (tset t# ,(tostring name) v#)
       v#)))

(fn def [name value]
  `(def- ,name
     (do
       (let [v# ,value]
         (tset ,module-sym ,(tostring name) v#)
         v#))))

(fn defn- [name ...]
  `(def- ,name (fn ,name ,...)))

(fn defn [name ...]
  `(def ,name (fn ,name ,...)))

(fn defonce- [name value]
  `(def- ,name
     (or (. ,module-sym :aniseed/locals ,(tostring name))
         ,value)))

(fn defonce [name value]
  `(def ,name
     (or (. ,module-sym ,(tostring name))
         ,value)))

(fn deftest [name ...]
  `(let [tests# (or (. ,module-sym :aniseed/tests) {})]
     (tset tests# ,(tostring name) (fn [,(sym :t)] ,...))
     (tset ,module-sym :aniseed/tests tests#)))

(fn time [...]
  `(let [start# (vim.loop.hrtime)
         result# (do ,...)
         end# (vim.loop.hrtime)]
     (print (.. "Elapsed time: " (/ (- end# start#) 1000000) " msecs"))
     result#))

{:module module
 :def- def- :def def
 :defn- defn- :defn defn
 :defonce- defonce- :defonce defonce
 :deftest deftest
 :time time}


================================================
FILE: lua/nvim-tree-docs/aniseed/nvim/util.lua
================================================
local _2afile_2a = "fnl/aniseed/nvim/util.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.nvim.util"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.nvim")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {nvim = "nvim-tree-docs.aniseed.nvim"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local nvim = _local_0_[1]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.nvim.util"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local normal
do
  local v_0_
  do
    local v_0_0
    local function normal0(keys)
      return nvim.ex.silent(("exe \"normal! " .. keys .. "\""))
    end
    v_0_0 = normal0
    _0_["normal"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["normal"] = v_0_
  normal = v_0_
end
local fn_bridge
do
  local v_0_
  do
    local v_0_0
    local function fn_bridge0(viml_name, mod, lua_name, opts)
      local _let_0_ = (opts or {})
      local range = _let_0_["range"]
      local _return = _let_0_["return"]
      local _3_
      if range then
        _3_ = " range"
      else
        _3_ = ""
      end
      local _5_
      if (_return ~= false) then
        _5_ = "return"
      else
        _5_ = "call"
      end
      local _7_
      if range then
        _7_ = "\" . a:firstline . \", \" . a:lastline . \", "
      else
        _7_ = ""
      end
      return nvim.ex.function_((viml_name .. "(...)" .. _3_ .. "\n          " .. _5_ .. " luaeval(\"require('" .. mod .. "')['" .. lua_name .. "'](" .. _7_ .. "unpack(_A))\", a:000)\n          endfunction"))
    end
    v_0_0 = fn_bridge0
    _0_["fn-bridge"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["fn-bridge"] = v_0_
  fn_bridge = v_0_
end
local with_out_str
do
  local v_0_
  do
    local v_0_0
    local function with_out_str0(f)
      nvim.ex.redir("=> g:aniseed_nvim_util_out_str")
      do
        local ok_3f, err = pcall(f)
        nvim.ex.redir("END")
        nvim.ex.echon("")
        nvim.ex.redraw()
        if not ok_3f then
          error(err)
        end
      end
      return string.gsub(nvim.g.aniseed_nvim_util_out_str, "^(\n?)(.*)$", "%2%1")
    end
    v_0_0 = with_out_str0
    _0_["with-out-str"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["with-out-str"] = v_0_
  with_out_str = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/nvim.lua
================================================
local _2afile_2a = "fnl/aniseed/nvim.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.nvim"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = require("nvim-tree-docs.aniseed.deps.nvim")
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.nvim"
return ({nil, _0_, nil, {{}, nil, nil, nil}})[2]


================================================
FILE: lua/nvim-tree-docs/aniseed/string.lua
================================================
local _2afile_2a = "fnl/aniseed/string.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.string"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.core")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {a = "nvim-tree-docs.aniseed.core"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local a = _local_0_[1]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.string"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local join
do
  local v_0_
  do
    local v_0_0
    local function join0(...)
      local args = {...}
      local function _3_(...)
        if (2 == a.count(args)) then
          return args
        else
          return {"", a.first(args)}
        end
      end
      local _let_0_ = _3_(...)
      local sep = _let_0_[1]
      local xs = _let_0_[2]
      local len = a.count(xs)
      local result = {}
      if (len > 0) then
        for i = 1, len do
          local x = xs[i]
          local _4_
          if ("string" == type(x)) then
            _4_ = x
          elseif (nil == x) then
            _4_ = x
          else
            _4_ = a["pr-str"](x)
          end
          if _4_ then
            table.insert(result, _4_)
          else
          end
        end
      end
      return table.concat(result, sep)
    end
    v_0_0 = join0
    _0_["join"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["join"] = v_0_
  join = v_0_
end
local split
do
  local v_0_
  do
    local v_0_0
    local function split0(s, pat)
      local done_3f = false
      local acc = {}
      local index = 1
      while not done_3f do
        local start, _end = string.find(s, pat, index)
        if ("nil" == type(start)) then
          table.insert(acc, string.sub(s, index))
          done_3f = true
        else
          table.insert(acc, string.sub(s, index, (start - 1)))
          index = (_end + 1)
        end
      end
      return acc
    end
    v_0_0 = split0
    _0_["split"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["split"] = v_0_
  split = v_0_
end
local blank_3f
do
  local v_0_
  do
    local v_0_0
    local function blank_3f0(s)
      return (a["empty?"](s) or not string.find(s, "[^%s]"))
    end
    v_0_0 = blank_3f0
    _0_["blank?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["blank?"] = v_0_
  blank_3f = v_0_
end
local triml
do
  local v_0_
  do
    local v_0_0
    local function triml0(s)
      return string.gsub(s, "^%s*(.-)", "%1")
    end
    v_0_0 = triml0
    _0_["triml"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["triml"] = v_0_
  triml = v_0_
end
local trimr
do
  local v_0_
  do
    local v_0_0
    local function trimr0(s)
      return string.gsub(s, "(.-)%s*$", "%1")
    end
    v_0_0 = trimr0
    _0_["trimr"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["trimr"] = v_0_
  trimr = v_0_
end
local trim
do
  local v_0_
  do
    local v_0_0
    local function trim0(s)
      return string.gsub(s, "^%s*(.-)%s*$", "%1")
    end
    v_0_0 = trim0
    _0_["trim"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["trim"] = v_0_
  trim = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/test.lua
================================================
local _2afile_2a = "fnl/aniseed/test.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.test"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.core"), autoload("nvim-tree-docs.aniseed.fs"), autoload("nvim-tree-docs.aniseed.nvim"), autoload("nvim-tree-docs.aniseed.string")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {a = "nvim-tree-docs.aniseed.core", fs = "nvim-tree-docs.aniseed.fs", nvim = "nvim-tree-docs.aniseed.nvim", str = "nvim-tree-docs.aniseed.string"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local a = _local_0_[1]
local fs = _local_0_[2]
local nvim = _local_0_[3]
local str = _local_0_[4]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.test"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local ok_3f
do
  local v_0_
  do
    local v_0_0
    local function ok_3f0(_3_)
      local _arg_0_ = _3_
      local tests = _arg_0_["tests"]
      local tests_passed = _arg_0_["tests-passed"]
      return (tests == tests_passed)
    end
    v_0_0 = ok_3f0
    _0_["ok?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["ok?"] = v_0_
  ok_3f = v_0_
end
local display_results
do
  local v_0_
  do
    local v_0_0
    local function display_results0(results, prefix)
      do
        local _let_0_ = results
        local assertions = _let_0_["assertions"]
        local assertions_passed = _let_0_["assertions-passed"]
        local tests = _let_0_["tests"]
        local tests_passed = _let_0_["tests-passed"]
        local _3_
        if ok_3f(results) then
          _3_ = "OK"
        else
          _3_ = "FAILED"
        end
        a.println((prefix .. " " .. _3_ .. " " .. tests_passed .. "/" .. tests .. " tests and " .. assertions_passed .. "/" .. assertions .. " assertions passed"))
      end
      return results
    end
    v_0_0 = display_results0
    _0_["display-results"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["display-results"] = v_0_
  display_results = v_0_
end
local run
do
  local v_0_
  do
    local v_0_0
    local function run0(mod_name)
      local mod = package.loaded[mod_name]
      local tests = (a["table?"](mod) and mod["aniseed/tests"])
      if a["table?"](tests) then
        local results = {["assertions-passed"] = 0, ["tests-passed"] = 0, assertions = 0, tests = #tests}
        for label, f in pairs(tests) do
          local test_failed = false
          a.update(results, "tests", a.inc)
          do
            local prefix = ("[" .. mod_name .. "/" .. label .. "]")
            local fail
            local function _3_(desc, ...)
              test_failed = true
              local function _4_(...)
                if desc then
                  return (" (" .. desc .. ")")
                else
                  return ""
                end
              end
              return a.println((str.join({prefix, " ", ...}) .. _4_(...)))
            end
            fail = _3_
            local begin
            local function _4_()
              return a.update(results, "assertions", a.inc)
            end
            begin = _4_
            local pass
            local function _5_()
              return a.update(results, "assertions-passed", a.inc)
            end
            pass = _5_
            local t
            local function _6_(e, r, desc)
              begin()
              if (e == r) then
                return pass()
              else
                return fail(desc, "Expected '", a["pr-str"](e), "' but received '", a["pr-str"](r), "'")
              end
            end
            local function _7_(r, desc)
              begin()
              if r then
                return pass()
              else
                return fail(desc, "Expected truthy result but received '", a["pr-str"](r), "'")
              end
            end
            local function _8_(e, r, desc)
              begin()
              local se = a["pr-str"](e)
              local sr = a["pr-str"](r)
              if (se == sr) then
                return pass()
              else
                return fail(desc, "Expected (with pr) '", se, "' but received '", sr, "'")
              end
            end
            t = {["="] = _6_, ["ok?"] = _7_, ["pr="] = _8_}
            local _9_, _10_ = nil, nil
            local function _11_()
              return f(t)
            end
            _9_, _10_ = pcall(_11_)
            if ((_9_ == false) and (nil ~= _10_)) then
              local err = _10_
              fail("Exception: ", err)
            end
          end
          if not test_failed then
            a.update(results, "tests-passed", a.inc)
          end
        end
        return display_results(results, ("[" .. mod_name .. "]"))
      end
    end
    v_0_0 = run0
    _0_["run"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["run"] = v_0_
  run = v_0_
end
local run_all
do
  local v_0_
  do
    local v_0_0
    local function run_all0()
      local function _3_(totals, results)
        for k, v in pairs(results) do
          totals[k] = (v + totals[k])
        end
        return totals
      end
      return display_results(a.reduce(_3_, {["assertions-passed"] = 0, ["tests-passed"] = 0, assertions = 0, tests = 0}, a.filter(a["table?"], a.map(run, a.keys(package.loaded)))), "[total]")
    end
    v_0_0 = run_all0
    _0_["run-all"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["run-all"] = v_0_
  run_all = v_0_
end
local suite
do
  local v_0_
  do
    local v_0_0
    local function suite0()
      do
        local sep = fs["path-sep"]
        local function _3_(path)
          return require(string.gsub(string.match(path, ("^test" .. sep .. "fnl" .. sep .. "(.-).fnl$")), sep, "."))
        end
        a["run!"](_3_, nvim.fn.globpath(("test" .. sep .. "fnl"), "**/*-test.fnl", false, true))
      end
      if ok_3f(run_all()) then
        return nvim.ex.q()
      else
        return nvim.ex.cq()
      end
    end
    v_0_0 = suite0
    _0_["suite"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["suite"] = v_0_
  suite = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/aniseed/view.lua
================================================
local _2afile_2a = "fnl/aniseed/view.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.aniseed.view"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.aniseed.view"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local serialise
do
  local v_0_
  do
    local v_0_0
    local function _3_(...)
      return require("nvim-tree-docs.aniseed.deps.fennelview")(...)
    end
    v_0_0 = _3_
    _0_["serialise"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["serialise"] = v_0_
  serialise = v_0_
end
return nil


================================================
FILE: lua/nvim-tree-docs/collector.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/collector.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.collector"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.aniseed.core")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {core = "nvim-tree-docs.aniseed.core"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local core = _local_0_[1]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.collector"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local collector_metatable
do
  local v_0_
  local function _3_(tbl, key)
    if (type(key) == "number") then
      local id = tbl.__order[key]
      if id then
        return tbl.__entries[id]
      else
        return nil
      end
    else
      return rawget(tbl, key)
    end
  end
  v_0_ = {__index = _3_}
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["collector-metatable"] = v_0_
  collector_metatable = v_0_
end
local new_collector
do
  local v_0_
  do
    local v_0_0
    local function new_collector0()
      return setmetatable({__entries = {}, __order = {}}, collector_metatable)
    end
    v_0_0 = new_collector0
    _0_["new-collector"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["new-collector"] = v_0_
  new_collector = v_0_
end
local is_collector
do
  local v_0_
  do
    local v_0_0
    local function is_collector0(value)
      return ((type(value) == "table") and (type(value.__entries) == "table"))
    end
    v_0_0 = is_collector0
    _0_["is-collector"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["is-collector"] = v_0_
  is_collector = v_0_
end
local is_collector_empty
do
  local v_0_
  do
    local v_0_0
    local function is_collector_empty0(collector)
      return (#collector.__order == 0)
    end
    v_0_0 = is_collector_empty0
    _0_["is-collector-empty"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["is-collector-empty"] = v_0_
  is_collector_empty = v_0_
end
local iterate_collector
do
  local v_0_
  do
    local v_0_0
    local function iterate_collector0(collector)
      local i = 1
      local function _3_()
        local id = collector.__order[i]
        if id then
          i = (i + 1)
          return {entry = collector.__entries[id], index = (i - 1)}
        else
          return nil
        end
      end
      return _3_
    end
    v_0_0 = iterate_collector0
    _0_["iterate-collector"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["iterate-collector"] = v_0_
  iterate_collector = v_0_
end
local get_node_id
do
  local v_0_
  do
    local v_0_0
    local function get_node_id0(node)
      local srow, scol, erow, ecol = node:range()
      return string.format("%d_%d_%d_%d", srow, scol, erow, ecol)
    end
    v_0_0 = get_node_id0
    _0_["get-node-id"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-node-id"] = v_0_
  get_node_id = v_0_
end
local collect_
do
  local v_0_
  do
    local v_0_0
    local function collect_0(collector, entry, _match, key, add_fn)
      if _match.definition then
        if not entry[key] then
          entry[key] = new_collector()
        end
        return add_fn(entry[key], key, _match, collect)
      elseif not entry[key] then
        entry[key] = _match
        return nil
      elseif ((key == "start_point") and _match.node) then
        local _, _0, current_start = (entry[key].node):start()
        local _1, _2, new_start = (_match.node):start()
        if (new_start < current_start) then
          entry[key] = _match
          return nil
        end
      elseif ((key == "end_point") and _match.node) then
        local _, _0, current_end = (entry[key].node):end_()
        local _1, _2, new_end = (_match.node):end_()
        if (new_end > current_end) then
          entry[key] = _match
          return nil
        end
      end
    end
    v_0_0 = collect_0
    _0_["collect_"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["collect_"] = v_0_
  collect_ = v_0_
end
local add_match
do
  local v_0_
  do
    local v_0_0
    local function add_match0(collector, kind, _match)
      if (_match and _match.definition) then
        local _def = _match.definition
        local def_node = _def.node
        local node_id = get_node_id(def_node)
        if not collector.__entries[node_id] then
          local order_index = 1
          local _, _0, def_start_byte = def_node:start()
          local entry_keys = core.keys(collector.__entries)
          local done = false
          local i = 1
          while not done do
            local entry
            do
              local _3_ = entry_keys[i]
              if _3_ then
                entry = collector.__entries[_3_]
              else
                entry = _3_
              end
            end
            if not entry then
              done = true
            else
              local _1, _2, start_byte = (entry.definition.node):start()
              if (def_start_byte < start_byte) then
                done = true
              else
                order_index = (order_index + 1)
                i = (i + 1)
              end
            end
          end
          table.insert(collector.__order, order_index, node_id)
          do end (collector.__entries)[node_id] = {definition = _def, kind = kind}
        end
        for key, submatch in pairs(_match) do
          if (key ~= "definition") then
            collect_(collector, collector.__entries[node_id], submatch, key, add_match0)
          end
        end
        return nil
      end
    end
    v_0_0 = add_match0
    _0_["add-match"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["add-match"] = v_0_
  add_match = v_0_
end
return nil

================================================
FILE: lua/nvim-tree-docs/editing.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/editing.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.editing"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-treesitter.ts_utils"), autoload("vim.treesitter.query")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {["ts-utils"] = "nvim-treesitter.ts_utils", tsq = "vim.treesitter.query"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local ts_utils = _local_0_[1]
local tsq = _local_0_[2]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.editing"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local ns
do
  local v_0_ = vim.api.nvim_create_namespace("doc-edit")
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["ns"] = v_0_
  ns = v_0_
end
local get_doc_comment_data
do
  local v_0_
  do
    local v_0_0
    local function get_doc_comment_data0(args)
      local _let_0_ = args
      local bufnr = _let_0_["bufnr"]
      local doc_lang = _let_0_["doc-lang"]
      local lang = _let_0_["lang"]
      local node = _let_0_["node"]
      local doc_lines = ts_utils.get_node_text(node, bufnr)
      local doc_string = table.concat(doc_lines, "\n")
      local parser = vim.treesitter.get_string_parser(doc_string, doc_lang)
      local query = tsq.get_query(doc_lang, "edits")
      local iter = query:iter_matches(parser:parse():root(), doc_string, 1, (#doc_string + 1))
      local result = {}
      local item = {iter()}
      while item[1] do
        local _let_1_ = item
        local pattern_id = _let_1_[1]
        local matches = _let_1_[2]
        for id, match_node in pairs(matches) do
          local match_name = query.captures[id]
          if not result[match_name] then
            result[match_name] = {}
          end
          table.insert(result[match_name], match_node)
        end
        item = {iter()}
      end
      return result
    end
    v_0_0 = get_doc_comment_data0
    _0_["get-doc-comment-data"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-doc-comment-data"] = v_0_
  get_doc_comment_data = v_0_
end
local edit_doc
do
  local v_0_
  do
    local v_0_0
    local function edit_doc0(args)
      local _let_0_ = args
      local bufnr = _let_0_["bufnr"]
      local doc_node = _let_0_["node"]
      local _let_1_ = get_doc_comment_data(args)
      local edit = _let_1_["edit"]
      local sr = doc_node:range()
      vim.api.nvim_buf_clear_namespace(bufnr, ns, 0, -1)
      for _, node in ipairs(edit) do
        local dsr, dsc, der, dec = node:range()
        ts_utils.highlight_range({(dsr + sr), dsc, (der + sr), dec}, bufnr, ns, "Visual")
      end
      return nil
    end
    v_0_0 = edit_doc0
    _0_["edit-doc"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["edit-doc"] = v_0_
  edit_doc = v_0_
end
return nil

================================================
FILE: lua/nvim-tree-docs/internal.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/internal.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.internal"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-tree-docs.collector"), autoload("nvim-treesitter.configs"), autoload("nvim-tree-docs.aniseed.core"), autoload("nvim-tree-docs.editing"), autoload("nvim-treesitter.query"), autoload("nvim-tree-docs.template"), autoload("nvim-treesitter.ts_utils"), autoload("nvim-tree-docs.utils")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {["ts-utils"] = "nvim-treesitter.ts_utils", collectors = "nvim-tree-docs.collector", configs = "nvim-treesitter.configs", core = "nvim-tree-docs.aniseed.core", editing = "nvim-tree-docs.editing", queries = "nvim-treesitter.query", templates = "nvim-tree-docs.template", utils = "nvim-tree-docs.utils"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local collectors = _local_0_[1]
local configs = _local_0_[2]
local core = _local_0_[3]
local editing = _local_0_[4]
local queries = _local_0_[5]
local templates = _local_0_[6]
local ts_utils = _local_0_[7]
local utils = _local_0_[8]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.internal"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local language_specs
do
  local v_0_ = {javascript = "jsdoc", lua = "luadoc", typescript = "tsdoc"}
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["language-specs"] = v_0_
  language_specs = v_0_
end
local doc_cache
do
  local v_0_ = {}
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["doc-cache"] = v_0_
  doc_cache = v_0_
end
local get_spec_for_lang
do
  local v_0_
  do
    local v_0_0
    local function get_spec_for_lang0(lang)
      local spec = language_specs[lang]
      if not spec then
        error(string.format("No language spec configured for %s", lang))
      end
      return spec
    end
    v_0_0 = get_spec_for_lang0
    _0_["get-spec-for-lang"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-spec-for-lang"] = v_0_
  get_spec_for_lang = v_0_
end
local get_spec_config
do
  local v_0_
  do
    local v_0_0
    local function get_spec_config0(lang, spec)
      local spec_def = templates["get-spec"](lang, spec)
      local module_config = configs.get_module("tree_docs")
      local spec_default_config = spec_def.config
      local lang_config = utils.get({"lang_config", lang, spec}, module_config, {})
      local spec_config = utils.get({"spec_config", spec}, module_config, {})
      return vim.tbl_deep_extend("force", spec_default_config, spec_config, lang_config)
    end
    v_0_0 = get_spec_config0
    _0_["get-spec-config"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-spec-config"] = v_0_
  get_spec_config = v_0_
end
local get_spec_for_buf
do
  local v_0_
  do
    local v_0_0
    local function get_spec_for_buf0(bufnr_3f)
      local bufnr = (bufnr_3f or vim.api.nvim_get_current_buf())
      return get_spec_for_lang(vim.api.nvim_buf_get_option(bufnr, "ft"))
    end
    v_0_0 = get_spec_for_buf0
    _0_["get-spec-for-buf"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-spec-for-buf"] = v_0_
  get_spec_for_buf = v_0_
end
local generate_docs
do
  local v_0_
  do
    local v_0_0
    local function generate_docs0(data_list, bufnr_3f, lang_3f)
      local bufnr = utils["get-bufnr"](bufnr_3f)
      local lang = (lang_3f or vim.api.nvim_buf_get_option(bufnr, "ft"))
      local spec_name = get_spec_for_lang(lang)
      local spec = templates["get-spec"](lang, spec_name)
      local spec_config = get_spec_config(lang, spec_name)
      local edits = {}
      local marks = {}
      local function _3_(_241, _242)
        local _, _0, start_byte_a = utils["get-start-position"](_241)
        local _1, _2, start_byte_b = utils["get-start-position"](_242)
        return (start_byte_a < start_byte_b)
      end
      table.sort(data_list, _3_)
      local line_offset = 0
      for _, doc_data in ipairs(data_list) do
        local node_sr, node_sc = utils["get-start-position"](doc_data)
        local node_er, node_ec = utils["get-end-position"](doc_data)
        local content_lines = utils["get-buf-content"](node_sr, node_sc, node_er, node_ec, bufnr)
        local replaced_count = ((node_er + 1) - node_sr)
        local result = templates["process-template"](doc_data, {["start-col"] = node_sc, ["start-line"] = (node_sr + line_offset), bufnr = bufnr, config = spec_config, content = content_lines, kind = doc_data.kind, spec = spec})
        table.insert(edits, {newText = (table.concat(result.content, "\n") .. "\n"), range = {["end"] = {character = 0, line = (node_er + 1)}, start = {character = 0, line = node_sr}}})
        vim.list_extend(marks, result.marks)
        line_offset = ((line_offset + #result.content) - replaced_count)
      end
      return vim.lsp.util.apply_text_edits(edits, bufnr)
    end
    v_0_0 = generate_docs0
    _0_["generate-docs"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["generate-docs"] = v_0_
  generate_docs = v_0_
end
local collect_docs
do
  local v_0_
  do
    local v_0_0
    local function collect_docs0(bufnr_3f)
      local bufnr = utils["get-bufnr"](bufnr_3f)
      if (utils.get({bufnr, "tick"}, doc_cache) == vim.api.nvim_buf_get_changedtick(bufnr)) then
        return utils.get({bufnr, "docs"}, doc_cache)
      else
        local collector = collectors["new-collector"]()
        local doc_matches = queries.collect_group_results(bufnr, "docs")
        for _, item in ipairs(doc_matches) do
          for kind, _match in pairs(item) do
            collectors["add-match"](collector, kind, _match)
          end
        end
        doc_cache[bufnr] = {docs = collector, tick = vim.api.nvim_buf_get_changedtick(bufnr)}
        return collector
      end
    end
    v_0_0 = collect_docs0
    _0_["collect-docs"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["collect-docs"] = v_0_
  collect_docs = v_0_
end
local get_doc_data_for_node
do
  local v_0_
  do
    local v_0_0
    local function get_doc_data_for_node0(node, bufnr_3f)
      local current = nil
      local last_start = nil
      local last_end = nil
      local doc_data = collect_docs(bufnr_3f)
      local _, _0, node_start = node:start()
      for iter_item in collectors["iterate-collector"](doc_data) do
        local is_more_specific = true
        local _let_0_ = iter_item
        local doc_def = _let_0_["entry"]
        local _1, _2, start = utils["get-start-position"](doc_def)
        local _3, _4, _end = utils["get-end-position"](doc_def)
        local is_in_range = ((node_start >= start) and (node_start < _end))
        if (last_start and last_end) then
          is_more_specific = ((start >= last_start) and (_end <= last_end))
        end
        if (is_in_range and is_more_specific) then
          last_start = start
          last_end = _end
          current = doc_def
        end
      end
      return current
    end
    v_0_0 = get_doc_data_for_node0
    _0_["get-doc-data-for-node"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-doc-data-for-node"] = v_0_
  get_doc_data_for_node = v_0_
end
local doc_node
do
  local v_0_
  do
    local v_0_0
    local function doc_node0(node, bufnr_3f, lang_3f)
      if node then
        local doc_data = get_doc_data_for_node(node, bufnr_3f)
        return generate_docs({doc_data}, bufnr_3f, lang_3f)
      end
    end
    v_0_0 = doc_node0
    _0_["doc-node"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["doc-node"] = v_0_
  doc_node = v_0_
end
local doc_node_at_cursor
do
  local v_0_
  do
    local v_0_0
    local function doc_node_at_cursor0()
      return doc_node(ts_utils.get_node_at_cursor())
    end
    v_0_0 = doc_node_at_cursor0
    _0_["doc-node-at-cursor"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["doc-node-at-cursor"] = v_0_
  doc_node_at_cursor = v_0_
end
local get_docs_from_position
do
  local v_0_
  do
    local v_0_0
    local function get_docs_from_position0(args)
      local _let_0_ = args
      local bufnr_3f = _let_0_["bufnr"]
      local end_line = _let_0_["end-line"]
      local inclusion_3f = _let_0_["inclusion"]
      local position = _let_0_["position"]
      local start_line = _let_0_["start-line"]
      local is_edit_type_3f = (position == "edit")
      local doc_data = collect_docs(bufnr_3f)
      local result = {}
      for item in collectors["iterate-collector"](doc_data) do
        local _let_1_ = item
        local _def = _let_1_["entry"]
        local start_r
        if is_edit_type_3f then
          start_r = utils["get-edit-start-position"](_def)
        else
          start_r = utils["get-start-position"](_def)
        end
        local end_r
        if is_edit_type_3f then
          end_r = utils["get-edit-end-position"](_def)
        else
          end_r = utils["get-end-position"](_def)
        end
        local _5_
        if inclusion_3f then
          _5_ = ((start_line >= start_r) and (end_line <= end_r))
        else
          _5_ = ((start_r >= start_line) and (end_r <= end_line))
        end
        if _5_ then
          table.insert(result, _def)
        end
      end
      return result
    end
    v_0_0 = get_docs_from_position0
    _0_["get-docs-from-position"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-docs-from-position"] = v_0_
  get_docs_from_position = v_0_
end
local get_docs_in_range
do
  local v_0_
  do
    local v_0_0
    local function get_docs_in_range0(args)
      return get_docs_from_position(vim.tbl_extend("force", args, {inclusion = false, position = nil}))
    end
    v_0_0 = get_docs_in_range0
    _0_["get-docs-in-range"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-docs-in-range"] = v_0_
  get_docs_in_range = v_0_
end
local get_docs_at_range
do
  local v_0_
  do
    local v_0_0
    local function get_docs_at_range0(args)
      return get_docs_from_position(vim.tbl_extend("force", args, {inclusion = true, position = "edit"}))
    end
    v_0_0 = get_docs_at_range0
    _0_["get-docs-at-range"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-docs-at-range"] = v_0_
  get_docs_at_range = v_0_
end
local get_docs_from_selection
do
  local v_0_
  do
    local v_0_0
    local function get_docs_from_selection0()
      local _, start, _0, _1 = unpack(vim.fn.getpos("'<"))
      local _2, _end, _3, _4 = unpack(vim.fn.getpos("'>"))
      return get_docs_in_range({["end-line"] = (_end - 1), ["start-line"] = (start - 1)})
    end
    v_0_0 = get_docs_from_selection0
    _0_["get-docs-from-selection"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-docs-from-selection"] = v_0_
  get_docs_from_selection = v_0_
end
local doc_all_in_range
do
  local v_0_
  do
    local v_0_0
    local function doc_all_in_range0()
      return generate_docs(get_docs_from_selection())
    end
    v_0_0 = doc_all_in_range0
    _0_["doc-all-in-range"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["doc-all-in-range"] = v_0_
  doc_all_in_range = v_0_
end
local edit_doc_at_cursor
do
  local v_0_
  do
    local v_0_0
    local function edit_doc_at_cursor0()
      local _let_0_ = vim.api.nvim_win_get_cursor(0)
      local row = _let_0_[1]
      local doc_data = get_docs_at_range({["end-line"] = (row - 1), ["start-line"] = (row - 1)})
      local bufnr = vim.api.nvim_get_current_buf()
      local lang = vim.api.nvim_buf_get_option(bufnr, "ft")
      local spec_name = get_spec_for_lang(lang)
      local spec = templates["get-spec"](lang, spec_name)
      local doc_lang = spec["doc-lang"]
      local doc_entry
      do
        local _3_ = doc_data
        if _3_ then
          local _4_ = (_3_)[1]
          if _4_ then
            doc_entry = (_4_).doc
          else
            doc_entry = _4_
          end
        else
          doc_entry = _3_
        end
      end
      if (core["table?"](doc_entry) and doc_entry.node and doc_lang) then
        return editing["edit-doc"]({["doc-lang"] = doc_lang, ["spec-name"] = spec_name, bufnr = bufnr, lang = lang, node = doc_entry.node})
      end
    end
    v_0_0 = edit_doc_at_cursor0
    _0_["edit-doc-at-cursor"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["edit-doc-at-cursor"] = v_0_
  edit_doc_at_cursor = v_0_
end
local attach
do
  local v_0_
  do
    local v_0_0
    local function attach0(bufnr_3f)
      local bufnr = utils["get-bufnr"](bufnr_3f)
      local config = configs.get_module("tree_docs")
      for _fn, mapping in pairs(config.keymaps) do
        local mode = "n"
        if (_fn == "doc_all_in_range") then
          mode = "v"
        end
        if mapping then
          vim.api.nvim_buf_set_keymap(bufnr, mode, mapping, string.format(":lua require 'nvim-tree-docs.internal'.%s()<CR>", _fn), {silent = true})
        end
      end
      return nil
    end
    v_0_0 = attach0
    _0_["attach"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["attach"] = v_0_
  attach = v_0_
end
local detach
do
  local v_0_
  do
    local v_0_0
    local function detach0(bufnr_3f)
      local bufnr = utils["get-bufnr"](bufnr_3f)
      local config = configs.get_module("tree_docs")
      for _fn, mapping in pairs(config.keymaps) do
        local mode = "n"
        if (_fn == "doc_all_in_range") then
          mode = "v"
        end
        if mapping then
          vim.api.nvim_buf_del_keymap(bufnr, mode, mapping)
        end
      end
      return nil
    end
    v_0_0 = detach0
    _0_["detach"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["detach"] = v_0_
  detach = v_0_
end
local doc_node_at_cursor0
do
  local v_0_
  do
    local v_0_0 = doc_node_at_cursor
    _0_["doc_node_at_cursor"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["doc_node_at_cursor"] = v_0_
  doc_node_at_cursor0 = v_0_
end
local doc_node0
do
  local v_0_
  do
    local v_0_0 = doc_node
    _0_["doc_node"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["doc_node"] = v_0_
  doc_node0 = v_0_
end
local doc_all_in_range0
do
  local v_0_
  do
    local v_0_0 = doc_all_in_range
    _0_["doc_all_in_range"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["doc_all_in_range"] = v_0_
  doc_all_in_range0 = v_0_
end
local edit_doc_at_cursor0
do
  local v_0_
  do
    local v_0_0 = edit_doc_at_cursor
    _0_["edit_doc_at_cursor"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["edit_doc_at_cursor"] = v_0_
  edit_doc_at_cursor0 = v_0_
end
return nil

================================================
FILE: lua/nvim-tree-docs/macros.fnl
================================================
(local modsym (gensym))

(fn doc-spec [config]
  "Defines a documentation specification"
  (assert config.lang "A language is required")
  (assert config.spec "A specification name is required")
  `(local ,modsym
     (let [mod-name# (.. ,(tostring config.lang) "." ,(tostring config.spec))
           template-mod# (require "nvim-tree-docs.template")
           module# {:templates {}
                    :utils {}
                    :processors {}
                    :doc-lang ,(tostring config.doc-lang)
                    :config (vim.tbl_deep_extend
                              "force"
                              {:slots {}
                               :processors {}}
                              ,(or config.config {}))
                    :inherits nil
                    :spec ,(tostring config.spec)
                    :lang ,(tostring config.lang)
                    :module mod-name#
                    :__build template-mod#.build-line}]
       (template-mod#.extend-spec module# :base.base)
       (template-mod#.extend-spec module# ,(if config.extends (tostring config.extends) nil))
       (tset (. template-mod# :loaded-specs)
             mod-name#
             module#)
       module#)))

(fn util [name parameters ...]
  "Defines a util function as part of this specification.
  These can be used in templates as well as any specification
  That extends this specification."
  `(tset (. ,modsym :utils) ,(tostring name) (fn ,parameters ,...)))

(fn template [kind ...]
  "Defines a template for a given 'kind'.
  The kind correlates with the query matches."
  (let [slots (let [results []]
                (each [_ slot (ipairs [...])]
                  (table.insert results (tostring slot)))
                results)]
    `(tset (. ,modsym :templates) ,(tostring kind) ,slots)))

(fn %= [key tbl default]
  "Get a nodes text content. A key is provided and will
  access the root context or the provided table."
  `($.get-text (. ,(or tbl `$) ,(tostring key)) ,default))

(fn %- [...]
  "Builds a line of output."
  `((. ,modsym :__build) ,...))

(fn %^ [content kind]
  "Marks content for the builder"
  `{:content ,content :mark ,kind})

(fn %! [content]
  "Marks a tab stop for the builder"
  `{:content ,content :mark :tabstop})

(fn %> [util-name ...]
  "Invokes a util function on this specification.
  This will invoke any inherited utils as well."
  `((. (. ,modsym :utils) ,(tostring util-name)) ,...))

(fn processor [...]
  (let [processor {}
        forms [...]
        has-name (not= (% (length forms) 2) 0)]
    (var hook nil)
    (var callback nil)
    (var name :__default)
    (when has-name
      (do
        (set name (. forms 1))
        (table.remove forms 1)))
    (each [_ form (ipairs forms)]
      (if hook
        (set callback form)
        (set hook (tostring form)))
      (if (and hook callback)
        (do
          (tset processor hook form)
          (set hook nil)
          (set callback nil))))
    `(tset (. ,modsym :processors) ,(tostring name) ,processor)))

(fn post-processor [name bindings ...]
  `(tset (. ,modsym :post-processors) ,name (fn ,bindings ,...)))

(fn log [...]
  `(let [result# ,...]
     (print (vim.inspect result#))
     result#))

{: template
 : util
 : %=
 : %>
 : %-
 : %^
 : %!
 : log
 : post-processor
 : processor
 : doc-spec}


================================================
FILE: lua/nvim-tree-docs/main.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/main.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.main"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _1_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _1_
local function _2_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _2_()
    return {autoload("nvim-treesitter.query"), autoload("nvim-treesitter")}
  end
  ok_3f_0_, val_0_ = pcall(_2_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {queries = "nvim-treesitter.query", ts = "nvim-treesitter"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _2_(...)
local queries = _local_0_[1]
local ts = _local_0_[2]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.main"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local init
do
  local v_0_
  do
    local v_0_0
    local function init0()
      local function _3_(_241)
        return (queries.get_query(_241, "docs") ~= nil)
      end
      return ts.define_modules({tree_docs = {is_supported = _3_, keymaps = {doc_all_in_range = "gdd", doc_node_at_cursor = "gdd", edit_doc_at_cursor = "gde"}, module_path = "nvim-tree-docs.internal"}})
    end
    v_0_0 = init0
    _0_["init"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["init"] = v_0_
  init = v_0_
end
return nil

================================================
FILE: lua/nvim-tree-docs/specs/base/base.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/specs/base/base.fnl"
local _1_
do
  local mod_name_0_ = ("base" .. "." .. "base")
  local template_mod_0_ = require("nvim-tree-docs.template")
  local module_0_ = {["doc-lang"] = "nil", __build = template_mod_0_["build-line"], config = vim.tbl_deep_extend("force", {processors = {}, slots = {}}, {}), inherits = nil, lang = "base", module = mod_name_0_, processors = {}, spec = "base", templates = {}, utils = {}}
  template_mod_0_["extend-spec"](module_0_, "base.base")
  template_mod_0_["extend-spec"](module_0_)
  do end ((template_mod_0_)["loaded-specs"])[mod_name_0_] = module_0_
  _1_ = module_0_
end
local function _2_(slot_indexes, slot_config)
  local expanded = {}
  for ps_name, enabled in pairs(slot_config) do
    if (enabled and not slot_indexes[ps_name]) then
      table.insert(expanded, ps_name)
    end
  end
  return expanded
end
(_1_).processors["%rest%"] = {expand = _2_, implicit = true}
local function _3_(_241)
  return _241.content
end
local function _4_()
  return 0
end
(_1_).processors["%content%"] = {build = _3_, implicit = true, indent = _4_}
return nil

================================================
FILE: lua/nvim-tree-docs/specs/javascript/jsdoc.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/specs/javascript/jsdoc.fnl"
local _1_
do
  local mod_name_0_ = ("javascript" .. "." .. "jsdoc")
  local template_mod_0_ = require("nvim-tree-docs.template")
  local module_0_ = {["doc-lang"] = "jsdoc", __build = template_mod_0_["build-line"], config = vim.tbl_deep_extend("force", {processors = {}, slots = {}}, {empty_line_after_description = false, include_types = true, slots = {["function"] = {["function"] = true, example = false, export = true, generator = true, param = true, returns = true, template = true, yields = true}, class = {class = true, example = false, export = true, extends = true}, member = {memberof = true, type = true}, method = {example = false, generator = true, memberof = true, param = true, returns = true, yields = true}, module = {module = true}, variable = {export = true, type = true}}}), inherits = nil, lang = "javascript", module = mod_name_0_, processors = {}, spec = "jsdoc", templates = {}, utils = {}}
  template_mod_0_["extend-spec"](module_0_, "base.base")
  template_mod_0_["extend-spec"](module_0_)
  do end ((template_mod_0_)["loaded-specs"])[mod_name_0_] = module_0_
  _1_ = module_0_
end
(_1_).templates["function"] = {"doc-start", "description", "function", "generator", "yields", "%rest%", "param", "returns", "example", "doc-end", "%content%"}
(_1_).templates["variable"] = {"doc-start", "description", "%rest%", "doc-end", "%content%"}
(_1_).templates["method"] = {"doc-start", "description", "memberof", "%rest%", "param", "returns", "example", "doc-end", "%content%"}
(_1_).templates["class"] = {"doc-start", "description", "class", "extends", "%rest%", "example", "doc-end", "%content%"}
(_1_).templates["member"] = {"doc-start", "description", "memberof", "%rest%", "doc-end", "%content%"}
(_1_).templates["module"] = {"doc-start", "description", "module", "%rest%", "doc-end"}
local function _2_()
  return "/**"
end
(_1_).processors["doc-start"] = {build = _2_, implicit = true}
local function _3_()
  return " */"
end
(_1_).processors["doc-end"] = {build = _3_, implicit = true}
local function _4_(_241)
  local type_str = ((_1_).utils)["get-marked-type"](_241, " ")
  return (_1_).__build(" * @returns", type_str, {content = "The result", mark = "tabstop"})
end
local function _5_(_241)
  return _241.return_statement
end
(_1_).processors["returns"] = {build = _4_, when = _5_}
local function _6_(_241)
  return (_1_).__build(" * @function ", _241["get-text"]((_241).name))
end
local function _7_(_241)
  return not _241.generator
end
(_1_).processors["function"] = {build = _6_, when = _7_}
local function _8_()
  local filename = vim.fn.expand("%:t:r")
  return (_1_).__build(" * @module ", {content = filename, mark = "tabstop"})
end
(_1_).processors["module"] = {build = _8_}
local function _9_(_241)
  return ((_1_).utils)["build-generics"](_241, "template")
end
local function _10_(_241)
  return _241.generics
end
(_1_).processors["template"] = {build = _9_, when = _10_}
local function _11_(_241)
  return ((_1_).utils)["build-generics"](_241, "typeParam")
end
local function _12_(_241)
  return _241.generics
end
(_1_).processors["typeParam"] = {build = _11_, when = _12_}
local function _13_(_241)
  return (_1_).__build(" * @extends ", _241["get-text"]((_241).extends))
end
local function _14_(_241)
  return _241.extends
end
(_1_).processors["extends"] = {build = _13_, when = _14_}
local function _15_(_241)
  return (_1_).__build(" * @class ", _241["get-text"]((_241).name))
end
(_1_).processors["class"] = {build = _15_}
local function _16_(_241)
  return _241.generator
end
(_1_).processors["generator"] = {when = _16_}
local function _17_(_241)
  return (_1_).__build(" * @yields", ((_1_).utils)["get-marked-type"](_241, ""))
end
local function _18_(_241)
  return _241.yields
end
(_1_).processors["yields"] = {build = _17_, when = _18_}
local function _19_(_241, _242)
  local description = (_1_).__build(" * ", {content = ("The " .. _241["get-text"]((_241).name) .. " " .. _242.name), mark = "tabstop"})
  local _let_0_ = _242
  local index = _let_0_["index"]
  local processors = _let_0_["processors"]
  local next_ps = processors[(index + 1)]
  if ((next_ps == "doc-end") or not _241.conf("empty_line_after_description")) then
    return description
  else
    return {description, " *"}
  end
end
(_1_).processors["description"] = {build = _19_, implicit = true}
local function _20_(_241)
  local type_str = ((_1_).utils)["get-marked-type"](_241, " ")
  return (_1_).__build(" * @type", type_str)
end
local function _21_(_241)
  return _241.type
end
(_1_).processors["type"] = {build = _20_, when = _21_}
local function _22_(_241)
  return _241.export
end
(_1_).processors["export"] = {when = _22_}
local function _23_(_241)
  local result = {}
  for param in _241.iter(_241.parameters) do
    local param_name = ((_1_).utils)["get-param-name"](_241, param.entry)
    local type_str = ((_1_).utils)["get-marked-type"](_241, " ")
    local name = _241["get-text"](param.entry.name)
    table.insert(result, (_1_).__build(" * @param", type_str, param_name, " - ", {content = ("The " .. name .. " param"), mark = "tabstop"}))
  end
  return result
end
local function _24_(_241)
  return (_241.parameters and not _241["empty?"](_241.parameters))
end
(_1_).processors["param"] = {build = _23_, when = _24_}
local function _25_(_241)
  return (_1_).__build(" * @memberof ", _241["get-text"]((_241).class))
end
local function _26_(_241)
  return _241.class
end
(_1_).processors["memberof"] = {build = _25_, when = _26_}
local function _27_(_241, _242)
  return (_1_).__build(" * @", _242.name)
end
(_1_).processors["__default"] = {build = _27_}
local function _28_(_24, param)
  if param.default_value then
    return string.format("%s=%s", _24["get-text"](param.name), _24["get-text"](param.default_value))
  else
    return _24["get-text"](param.name)
  end
end
(_1_).utils["get-param-name"] = _28_
local function _29_(_24, not_found_3f)
  if _24.conf("include_types") then
    return " {any} "
  else
    return (not_found_3f or "")
  end
end
(_1_).utils["get-marked-type"] = _29_
local function _30_(_24, tag)
  local result = {}
  for generic in _24.iter(_24.generics) do
    local name = _24["get-text"](generic.entry.name)
    table.insert(result, (_1_).__build(" * @", tag, " ", name, " ", {content = ("The " .. name .. " type"), mark = "tabstop"}))
  end
  return result
end
(_1_).utils["build-generics"] = _30_
return nil

================================================
FILE: lua/nvim-tree-docs/specs/lua/luadoc.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/specs/lua/luadoc.fnl"
local _1_
do
  local mod_name_0_ = ("lua" .. "." .. "luadoc")
  local template_mod_0_ = require("nvim-tree-docs.template")
  local module_0_ = {["doc-lang"] = "nil", __build = template_mod_0_["build-line"], config = vim.tbl_deep_extend("force", {processors = {}, slots = {}}, {slots = {["function"] = {param = true, returns = true}, variable = {}}}), inherits = nil, lang = "lua", module = mod_name_0_, processors = {}, spec = "luadoc", templates = {}, utils = {}}
  template_mod_0_["extend-spec"](module_0_, "base.base")
  template_mod_0_["extend-spec"](module_0_)
  do end ((template_mod_0_)["loaded-specs"])[mod_name_0_] = module_0_
  _1_ = module_0_
end
(_1_).templates["function"] = {"description", "param", "returns"}
(_1_).templates["variable"] = {"description"}
local function _2_()
  return "--- Description"
end
(_1_).processors["description"] = {build = _2_, implicit = true}
local function _3_(_241)
  local result = {}
  for param in _241.iter(_241.parameters) do
    local name = _241["get-text"](param.entry.name)
    table.insert(result, ("-- @param " .. name .. " The " .. name))
  end
  return result
end
local function _4_(_241)
  return (_241.parameters and not _241["empty?"](_241.parameters))
end
(_1_).processors["param"] = {build = _3_, when = _4_}
return nil

================================================
FILE: lua/nvim-tree-docs/specs/typescript/tsdoc.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/specs/typescript/tsdoc.fnl"
local _1_
do
  local mod_name_0_ = ("typescript" .. "." .. "tsdoc")
  local template_mod_0_ = require("nvim-tree-docs.template")
  local module_0_ = {["doc-lang"] = "nil", __build = template_mod_0_["build-line"], config = vim.tbl_deep_extend("force", {processors = {}, slots = {}}, {empty_line_after_description = true, include_types = false, slots = {["function"] = {["function"] = false, export = false, generator = false}, class = {class = false, export = false, extends = false}, member = {memberof = false, type = false}, method = {memberof = false}, variable = {export = false, type = false}}}), inherits = nil, lang = "typescript", module = mod_name_0_, processors = {}, spec = "tsdoc", templates = {}, utils = {}}
  template_mod_0_["extend-spec"](module_0_, "base.base")
  template_mod_0_["extend-spec"](module_0_, "javascript.jsdoc")
  do end ((template_mod_0_)["loaded-specs"])[mod_name_0_] = module_0_
  _1_ = module_0_
end
return nil

================================================
FILE: lua/nvim-tree-docs/template.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/template.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.template"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _2_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _2_
local function _3_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _3_()
    return {autoload("nvim-tree-docs.collector"), autoload("nvim-tree-docs.aniseed.core"), autoload("nvim-treesitter.ts_utils"), autoload("nvim-tree-docs.utils")}
  end
  ok_3f_0_, val_0_ = pcall(_3_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {["ts-utils"] = "nvim-treesitter.ts_utils", collectors = "nvim-tree-docs.collector", core = "nvim-tree-docs.aniseed.core", utils = "nvim-tree-docs.utils"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _3_(...)
local collectors = _local_0_[1]
local core = _local_0_[2]
local ts_utils = _local_0_[3]
local utils = _local_0_[4]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.template"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local loaded_specs
do
  local v_0_
  do
    local v_0_0 = {}
    _0_["loaded-specs"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["loaded-specs"] = v_0_
  loaded_specs = v_0_
end
local get_text
do
  local v_0_
  do
    local v_0_0
    local function get_text0(context, node, default, multi)
      local default_value = (default or "")
      if (node and (type(node) == "table")) then
        local tsnode
        if node.node then
          tsnode = node.node
        else
          tsnode = node
        end
        local lines = ts_utils.get_node_text(tsnode)
        if multi then
          return lines
        else
          local line = lines[1]
          if (line ~= "") then
            return line
          else
            return default_value
          end
        end
      else
        return default_value
      end
    end
    v_0_0 = get_text0
    _0_["get-text"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-text"] = v_0_
  get_text = v_0_
end
local iter
do
  local v_0_
  do
    local v_0_0
    local function iter0(collector)
      if collector then
        return collectors["iterate-collector"](collector)
      else
        local function _4_()
          return nil
        end
        return _4_
      end
    end
    v_0_0 = iter0
    _0_["iter"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["iter"] = v_0_
  iter = v_0_
end
local conf
do
  local v_0_
  do
    local v_0_0
    local function conf0(context, path, default_3f)
      return utils.get(path, context.config, default_3f)
    end
    v_0_0 = conf0
    _0_["conf"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["conf"] = v_0_
  conf = v_0_
end
local empty_3f
do
  local v_0_
  do
    local v_0_0
    local function empty_3f0(collector)
      return collectors["is-collector-empty"](collector)
    end
    v_0_0 = empty_3f0
    _0_["empty?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["empty?"] = v_0_
  empty_3f = v_0_
end
local build_line
do
  local v_0_
  do
    local v_0_0
    local function build_line0(...)
      local result = {content = "", marks = {}}
      local add_content
      local function _4_(_241)
        result.content = (result.content .. _241)
        return nil
      end
      add_content = _4_
      for _, value in ipairs({...}) do
        if core["string?"](value) then
          add_content(value)
        elseif (core["table?"](value) and core["string?"](value.content)) then
          if value.mark then
            local start = #result.content
            add_content(value.content)
            table.insert(result.marks, {kind = value.mark, start = start, stop = (#value.content + start)})
          else
            add_content(value.content)
          end
        end
      end
      return result
    end
    v_0_0 = build_line0
    _0_["build-line"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["build-line"] = v_0_
  build_line = v_0_
end
local new_template_context
do
  local v_0_
  do
    local v_0_0
    local function new_template_context0(collector, options_3f)
      local options = (options_3f or {})
      local context = vim.tbl_extend("keep", {["empty?"] = empty_3f, ["start-col"] = (options["start-col"] or 0), ["start-line"] = (options["start-line"] or 0), bufnr = utils["get-bufnr"](options.bufnr), build = build_line, config = options.config, content = (options.content or {}), iter = iter, kind = options.kind}, collector)
      local function _4_(...)
        return get_text(context, ...)
      end
      context["get-text"] = _4_
      local function _5_(...)
        return conf(context, ...)
      end
      context.conf = _5_
      return context
    end
    v_0_0 = new_template_context0
    _0_["new-template-context"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["new-template-context"] = v_0_
  new_template_context = v_0_
end
local get_spec
do
  local v_0_
  do
    local v_0_0
    local function get_spec0(lang, spec)
      local key = (lang .. "." .. spec)
      if not loaded_specs[key] then
        require(string.format("nvim-tree-docs.specs.%s.%s", lang, spec))
      end
      return loaded_specs[key]
    end
    v_0_0 = get_spec0
    _0_["get-spec"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-spec"] = v_0_
  get_spec = v_0_
end
local normalize_processor
do
  local v_0_
  local function normalize_processor0(processor)
    if utils["func?"](processor) then
      return {build = processor}
    else
      return processor
    end
  end
  v_0_ = normalize_processor0
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["normalize-processor"] = v_0_
  normalize_processor = v_0_
end
local get_processor
do
  local v_0_
  local function get_processor0(processors, name, aliased_from_3f)
    local processor_config = processors[name]
    if core["string?"](processor_config) then
      return get_processor0(processors, processor_config, (aliased_from_3f or name))
    else
      local result = normalize_processor((processor_config or processors.__default))
      return {["aliased-from"] = aliased_from_3f, name = name, processor = result}
    end
  end
  v_0_ = get_processor0
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-processor"] = v_0_
  get_processor = v_0_
end
local get_expanded_slots
do
  local v_0_
  do
    local v_0_0
    local function get_expanded_slots0(ps_list, slot_config, processors)
      local result = {unpack(ps_list)}
      local i = 1
      while (i <= #result) do
        local ps_name = result[i]
        local _let_0_ = get_processor(processors, ps_name)
        local processor = _let_0_["processor"]
        if (processor and processor.expand) then
          local expanded = processor.expand(utils["make-inverse-list"](result), slot_config)
          table.remove(result, i)
          for j, expanded_ps in ipairs(expanded) do
            table.insert(result, ((i + j) - 1), expanded_ps)
          end
        end
        i = (i + 1)
      end
      return result
    end
    v_0_0 = get_expanded_slots0
    _0_["get-expanded-slots"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-expanded-slots"] = v_0_
  get_expanded_slots = v_0_
end
local get_filtered_slots
do
  local v_0_
  do
    local v_0_0
    local function get_filtered_slots0(ps_list, processors, slot_config, context)
      local function _4_(_241)
        return (_241 ~= nil)
      end
      local function _5_(_241)
        local include_ps
        if utils["method?"](_241.processor, "when") then
          include_ps = _241.processor.when(context)
        else
          include_ps = core["table?"](_241.processor)
        end
        if include_ps then
          return _241.name
        else
          return nil
        end
      end
      local function _6_(_241)
        return (_241.processor and (_241.processor.implicit or slot_config[(_241["aliased-from"] or _241.name)]))
      end
      local function _7_(_241)
        return get_processor(processors, _241)
      end
      return core.filter(_4_, core.map(_5_, core.filter(_6_, core.map(_7_, ps_list))))
    end
    v_0_0 = get_filtered_slots0
    _0_["get-filtered-slots"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-filtered-slots"] = v_0_
  get_filtered_slots = v_0_
end
local normalize_build_output
do
  local v_0_
  do
    local v_0_0
    local function normalize_build_output0(output)
      if core["string?"](output) then
        return {{content = output, marks = {}}}
      elseif core["table?"](output) then
        if core["string?"](output.content) then
          return {output}
        else
          local function _4_(_241)
            if core["string?"](_241) then
              return {content = _241, marks = {}}
            else
              return _241
            end
          end
          return core.map(_4_, output)
        end
      end
    end
    v_0_0 = normalize_build_output0
    _0_["normalize-build-output"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["normalize-build-output"] = v_0_
  normalize_build_output = v_0_
end
local indent_lines
do
  local v_0_
  do
    local v_0_0
    local function indent_lines0(lines, indenter, context)
      local indentation_amount
      if utils["func?"](indenter) then
        indentation_amount = indenter(lines, context)
      else
        indentation_amount = context["start-col"]
      end
      local function _5_(line)
        local function _6_(_241)
          return vim.tbl_extend("force", _241, {start = (_241.start + indentation_amount), stop = (_241.stop + indentation_amount)})
        end
        return vim.tbl_extend("force", {}, {content = (string.rep(" ", indentation_amount) .. line.content), marks = core.map(_6_, line.marks)})
      end
      return core.map(_5_, lines)
    end
    v_0_0 = indent_lines0
    _0_["indent-lines"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["indent-lines"] = v_0_
  indent_lines = v_0_
end
local build_slots
do
  local v_0_
  do
    local v_0_0
    local function build_slots0(ps_list, processors, context)
      local result = {}
      for i, ps_name in ipairs(ps_list) do
        local _let_0_ = get_processor(processors, ps_name)
        local processor = _let_0_["processor"]
        local default_processor = processors.__default
        local build_fn
        local _5_
        do
          local _4_ = processor
          if _4_ then
            _5_ = (_4_).build
          else
            _5_ = _4_
          end
        end
        local function _7_()
          local _6_ = default_processor
          if _6_ then
            return (_6_).build
          else
            return _6_
          end
        end
        build_fn = (_5_ or _7_())
        local indent_fn
        local _9_
        do
          local _8_ = processor
          if _8_ then
            _9_ = (_8_).indent
          else
            _9_ = _8_
          end
        end
        local function _11_()
          local _10_ = default_processor
          if _10_ then
            return (_10_).indent
          else
            return _10_
          end
        end
        indent_fn = (_9_ or _11_())
        local function _12_()
          if utils["func?"](build_fn) then
            return indent_lines(normalize_build_output(build_fn(context, {index = i, name = ps_name, processors = ps_list})), indent_fn, context)
          else
            return {}
          end
        end
        table.insert(result, _12_())
      end
      return result
    end
    v_0_0 = build_slots0
    _0_["build-slots"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["build-slots"] = v_0_
  build_slots = v_0_
end
local output_to_lines
do
  local v_0_
  do
    local v_0_0
    local function output_to_lines0(output)
      local function _4_(_241, _242)
        return vim.list_extend(_241, _242)
      end
      return core.reduce(_4_, {}, output)
    end
    v_0_0 = output_to_lines0
    _0_["output-to-lines"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["output-to-lines"] = v_0_
  output_to_lines = v_0_
end
local package_build_output
do
  local v_0_
  do
    local v_0_0
    local function package_build_output0(output, context)
      local result = {content = {}, marks = {}}
      for i, entry in ipairs(output) do
        for j, line in ipairs(entry) do
          local lnum = (#result.content + 1)
          table.insert(result.content, line.content)
          local function _4_(_241)
            return vim.tbl_extend("force", {}, _241, {line = (lnum + (context["start-line"] or 0))})
          end
          vim.list_extend(result.marks, core.map(_4_, line.marks))
        end
      end
      return result
    end
    v_0_0 = package_build_output0
    _0_["package-build-output"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["package-build-output"] = v_0_
  package_build_output = v_0_
end
local process_template
do
  local v_0_
  do
    local v_0_0
    local function process_template0(collector, config)
      local _let_0_ = config
      local spec_conf = _let_0_["config"]
      local kind = _let_0_["kind"]
      local spec = _let_0_["spec"]
      local ps_list
      local _5_
      do
        local _4_ = spec_conf
        if _4_ then
          local _6_ = (_4_).templates
          if _6_ then
            _5_ = (_6_)[kind]
          else
            _5_ = _6_
          end
        else
          _5_ = _4_
        end
      end
      ps_list = (_5_ or spec.templates[kind])
      local processors = vim.tbl_extend("force", spec.processors, (spec_conf.processors or {}))
      local slot_config
      local _7_
      do
        local _6_ = spec_conf.slots
        if _6_ then
          _7_ = (_6_)[kind]
        else
          _7_ = _6_
        end
      end
      slot_config = (_7_ or {})
      local context = new_template_context(collector, config)
      return package_build_output(build_slots(get_filtered_slots(get_expanded_slots(ps_list, slot_config, processors), processors, slot_config, context), processors, context), context)
    end
    v_0_0 = process_template0
    _0_["process-template"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["process-template"] = v_0_
  process_template = v_0_
end
local extend_spec
do
  local v_0_
  do
    local v_0_0
    local function extend_spec0(mod, spec)
      if (spec and (mod.module ~= spec)) then
        require(("nvim-tree-docs.specs." .. spec))
        local inherited_spec = loaded_specs[spec]
        mod["templates"] = vim.tbl_extend("force", mod.templates, loaded_specs[spec].templates)
        do end (mod)["utils"] = vim.tbl_extend("force", mod.utils, loaded_specs[spec].utils)
        do end (mod)["inherits"] = inherited_spec
        mod["processors"] = vim.tbl_extend("force", mod.processors, inherited_spec.processors)
        do end (mod)["config"] = vim.tbl_deep_extend("force", inherited_spec.config, mod.config)
        return nil
      end
    end
    v_0_0 = extend_spec0
    _0_["extend-spec"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["extend-spec"] = v_0_
  extend_spec = v_0_
end
return nil

================================================
FILE: lua/nvim-tree-docs/utils.lua
================================================
local _2afile_2a = "fnl/nvim-tree-docs/utils.fnl"
local _0_
do
  local name_0_ = "nvim-tree-docs.utils"
  local module_0_
  do
    local x_0_ = package.loaded[name_0_]
    if ("table" == type(x_0_)) then
      module_0_ = x_0_
    else
      module_0_ = {}
    end
  end
  module_0_["aniseed/module"] = name_0_
  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
  do end (package.loaded)[name_0_] = module_0_
  _0_ = module_0_
end
local autoload
local function _2_(...)
  return (require("nvim-tree-docs.aniseed.autoload")).autoload(...)
end
autoload = _2_
local function _3_(...)
  local ok_3f_0_, val_0_ = nil, nil
  local function _3_()
    return {autoload("nvim-tree-docs.aniseed.core")}
  end
  ok_3f_0_, val_0_ = pcall(_3_)
  if ok_3f_0_ then
    _0_["aniseed/local-fns"] = {autoload = {core = "nvim-tree-docs.aniseed.core"}}
    return val_0_
  else
    return print(val_0_)
  end
end
local _local_0_ = _3_(...)
local core = _local_0_[1]
local _2amodule_2a = _0_
local _2amodule_name_2a = "nvim-tree-docs.utils"
do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
local ns
do
  local v_0_
  do
    local v_0_0 = vim.api.nvim_create_namespace("blorg")
    do end (_0_)["ns"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["ns"] = v_0_
  ns = v_0_
end
local get_start_node
do
  local v_0_
  do
    local v_0_0
    local function get_start_node0(entry)
      local _5_
      do
        local _4_ = entry
        if _4_ then
          local _6_ = (_4_).start_point
          if _6_ then
            _5_ = (_6_).node
          else
            _5_ = _6_
          end
        else
          _5_ = _4_
        end
      end
      local function _7_()
        local _6_ = entry
        if _6_ then
          local _8_ = (_6_).definition
          if _8_ then
            return (_8_).node
          else
            return _8_
          end
        else
          return _6_
        end
      end
      return (_5_ or _7_())
    end
    v_0_0 = get_start_node0
    _0_["get-start-node"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-start-node"] = v_0_
  get_start_node = v_0_
end
local get_end_node
do
  local v_0_
  do
    local v_0_0
    local function get_end_node0(entry)
      local _5_
      do
        local _4_ = entry
        if _4_ then
          local _6_ = (_4_).end_point
          if _6_ then
            _5_ = (_6_).node
          else
            _5_ = _6_
          end
        else
          _5_ = _4_
        end
      end
      local function _7_()
        local _6_ = entry
        if _6_ then
          local _8_ = (_6_).definition
          if _8_ then
            return (_8_).node
          else
            return _8_
          end
        else
          return _6_
        end
      end
      return (_5_ or _7_())
    end
    v_0_0 = get_end_node0
    _0_["get-end-node"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-end-node"] = v_0_
  get_end_node = v_0_
end
local get_position
do
  local v_0_
  do
    local v_0_0
    local function get_position0(keys, default_position, entry)
      local i = 1
      local result = nil
      while (not result and (i <= #keys)) do
        do
          local key = keys[i]
          local match_3f = entry[key]
          local has_match_3f = (core["table?"](match_3f) and match_3f.node)
          local position_3f
          if has_match_3f then
            position_3f = (match_3f.position or default_position)
          else
            position_3f = nil
          end
          if has_match_3f then
            if (position_3f == "start") then
              result = {(match_3f.node):start()}
            else
              result = {(match_3f.node):end_()}
            end
          end
        end
        i = core.inc(i)
      end
      return unpack(result)
    end
    v_0_0 = get_position0
    _0_["get-position"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-position"] = v_0_
  get_position = v_0_
end
local get_start_position
do
  local v_0_
  do
    local v_0_0
    local function _4_(...)
      return get_position({"start_point", "definition"}, "start", ...)
    end
    v_0_0 = _4_
    _0_["get-start-position"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-start-position"] = v_0_
  get_start_position = v_0_
end
local get_end_position
do
  local v_0_
  do
    local v_0_0
    local function _4_(...)
      return get_position({"end_point", "definition"}, "end", ...)
    end
    v_0_0 = _4_
    _0_["get-end-position"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-end-position"] = v_0_
  get_end_position = v_0_
end
local get_edit_start_position
do
  local v_0_
  do
    local v_0_0
    local function _4_(...)
      return get_position({"edit_start_point", "start_point", "definition"}, "start", ...)
    end
    v_0_0 = _4_
    _0_["get-edit-start-position"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-edit-start-position"] = v_0_
  get_edit_start_position = v_0_
end
local get_edit_end_position
do
  local v_0_
  do
    local v_0_0
    local function _4_(...)
      return get_position({"edit_end_point", "end_point", "definition"}, "end", ...)
    end
    v_0_0 = _4_
    _0_["get-edit-end-position"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-edit-end-position"] = v_0_
  get_edit_end_position = v_0_
end
local get_bufnr
do
  local v_0_
  do
    local v_0_0
    local function get_bufnr0(bufnr)
      return (bufnr or vim.api.nvim_get_current_buf())
    end
    v_0_0 = get_bufnr0
    _0_["get-bufnr"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-bufnr"] = v_0_
  get_bufnr = v_0_
end
local get_buf_content
do
  local v_0_
  do
    local v_0_0
    local function get_buf_content0(start_row, start_col, end_row, end_col, bufnr)
      return vim.api.nvim_buf_get_lines(bufnr, start_row, (end_row + 1), false)
    end
    v_0_0 = get_buf_content0
    _0_["get-buf-content"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-buf-content"] = v_0_
  get_buf_content = v_0_
end
local get
do
  local v_0_
  do
    local v_0_0
    local function get0(path, tbl, default_3f)
      local segments
      if (type(path) == "string") then
        segments = vim.split(path, "%.")
      else
        segments = path
      end
      local result = tbl
      for _, segment in ipairs(segments) do
        if (type(result) == "table") then
          result = result[segment]
        else
          result = nil
        end
      end
      if (result == nil) then
        return default_3f
      else
        return result
      end
    end
    v_0_0 = get0
    _0_["get"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get"] = v_0_
  get = v_0_
end
local make_inverse_list
do
  local v_0_
  do
    local v_0_0
    local function make_inverse_list0(tbl)
      local result = {}
      for i, v in ipairs(tbl) do
        result[v] = i
      end
      return result
    end
    v_0_0 = make_inverse_list0
    _0_["make-inverse-list"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["make-inverse-list"] = v_0_
  make_inverse_list = v_0_
end
local get_all_truthy_keys
do
  local v_0_
  do
    local v_0_0
    local function get_all_truthy_keys0(tbl)
      local result = {}
      for k, v in pairs(tbl) do
        if v then
          table.insert(result, k)
        end
      end
      return result
    end
    v_0_0 = get_all_truthy_keys0
    _0_["get-all-truthy-keys"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["get-all-truthy-keys"] = v_0_
  get_all_truthy_keys = v_0_
end
local func_3f
do
  local v_0_
  do
    local v_0_0
    local function func_3f0(v)
      return (type(v) == "function")
    end
    v_0_0 = func_3f0
    _0_["func?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["func?"] = v_0_
  func_3f = v_0_
end
local method_3f
do
  local v_0_
  do
    local v_0_0
    local function method_3f0(v, key)
      return ((type(v) == "table") and (type(v[key]) == "function"))
    end
    v_0_0 = method_3f0
    _0_["method?"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["method?"] = v_0_
  method_3f = v_0_
end
local highlight_marks
do
  local v_0_
  do
    local v_0_0
    local function highlight_marks0(marks, bufnr)
      for _, mark in ipairs(marks) do
        local line = (mark.line - 1)
        vim.highlight.range(bufnr, ns, "Visual", {line, mark.start}, {line, mark.stop})
      end
      return nil
    end
    v_0_0 = highlight_marks0
    _0_["highlight-marks"] = v_0_0
    v_0_ = v_0_0
  end
  local t_0_ = (_0_)["aniseed/locals"]
  t_0_["highlight-marks"] = v_0_
  highlight_marks = v_0_
end
return nil

================================================
FILE: plugin/nvim-tree-docs.vim
================================================
if has("nvim")
  lua require("nvim-tree-docs.main").init()
endif


================================================
FILE: queries/ecma/docs.scm
================================================
; ECMAScript base

; ---- Functions

[
  (function_declaration name: (identifier) @function.name)
  (generator_function_declaration name: (identifier) @function.name)
] @function.definition

(generator_function_declaration) @function.definition @function.generator

; Generator yields
(generator_function_declaration
  body: (statement_block
    (expression_statement
      (yield_expression
        (identifier) @function.yields)))) @function.definition

; Function doc
((comment) @function.doc @function.edit_start_point
 .
 (function_declaration) @function.definition)

[
  (function_declaration
    body: ((statement_block) @function.end_point)
           (#set! function.end_point.position "start"))
  (generator_function_declaration
    body: ((statement_block) @function.end_point)
           (#set! function.end_point.position "start"))
] @function.definition

; Return statement
[
  (function_declaration
    body: (statement_block
      (return_statement) @function.return_statement))
  (generator_function_declaration
    body: (statement_block
      (return_statement) @function.return_statement))
] @function.definition

; Exported function

[
  (export_statement (function_declaration) @function.definition)
  (export_statement (generator_function_declaration) @function.definition)
] @function.export @function.start_point

; Function export doc
((comment) @function.doc @function.edit_start_point
 .
 (export_statement
   (function_declaration) @function.definition))

; ----- Variables

; Variable name
(lexical_declaration
  (variable_declarator
    name: (identifier) @variable.name) @variable.definition) @variable.start_point

; Variable initializer
(lexical_declaration
  (variable_declarator
    value: (_) @variable.initial_value) @variable.definition)

; Variable doc
((comment) @variable.doc
 .
 (lexical_declaration
   (variable_declarator) @variable.definition))

; Exported variable
(export_statement
  (lexical_declaration
    (variable_declarator) @variable.definition)) @variable.start_point @variable.export

; Exported variable doc
((comment) @variable.doc
 .
 (export_statement
   (lexical_declaration
     (variable_declarator) @variable.definition)))

; ----- Methods

(method_definition
  name: (property_identifier) @method.name) @method.definition

; Method class name
(class_declaration
  name: (_) @method.class
  body: (class_body
    (method_definition) @method.definition))

(method_definition
  body: ((statement_block) @method.end_point)
         (#set! method.end_point.position "start")) @method.definition

; Method return statement
(method_definition
  body: (statement_block
    (return_statement) @method.return_statement)) @method.definition

; ----- Classes

; Classes
(class_declaration
  name: (_) @class.name) @class.definition

(class_declaration
  body: ((class_body) @class.end_point)
         (#set! class.end_point.position "start")) @class.definition

; Class doc
((comment) @class.doc
 .
 (class_declaration) @class.definition)

; Exported class doc
((comment) @class.doc
 .
 (export_statement
   declaration: (class_declaration) @class.definition))

; Exported class
(export_statement
  declaration: (class_declaration) @class.definition) @class.export @class.start_point


================================================
FILE: queries/javascript/docs.scm
================================================
; inherits: ecma
; Javascript

; ---- Functions

; Function param name
[
  (function_declaration
    parameters: (formal_parameters
      (identifier) @function.parameters.name @function.parameters.definition))
  (generator_function_declaration
    parameters: (formal_parameters
      (identifier) @function.parameters.name @function.parameters.definition))
] @function.definition

; Function param default value
[
  (function_declaration
    parameters: (formal_parameters
      (assignment_pattern
        left: (identifier) @function.parameters.definition @function.parameters.name
        right: (_) @function.parameters.default_value @function.parameters.optional)))
  (generator_function_declaration
    parameters: (formal_parameters
      (assignment_pattern
        left: (identifier) @function.parameters.definition @function.parameters.name
        right: (_) @function.parameters.default_value @function.parameters.optional)))
] @function.definition


(method_definition
  parameters: (formal_parameters) @method.end_point) @method.definition

; Method params
(method_definition
  parameters: (formal_parameters
    (identifier) @method.parameters.name @method.parameters.definition)) @method.definition

; Method param default value
(method_definition
  parameters: (formal_parameters
    (identifier) @method.parameters.definition
    (assignment_pattern
      left: (_) @method.parameters.name
      right: (_) @method.parameters.default_value @method.parameters.optional))) @method.definition

(class_declaration
  (class_heritage
    (identifier) @class.extends)) @class.definition

; Member name
(field_definition
  property: (property_identifier) @member.name @member.end_point) @member.definition

; Member class
(class_declaration
  name: (_) @member.class
  body: (class_body
    (field_definition) @member.definition))

; Member doc
((comment) @member.doc
 .
 (field_definition) @member.definition)


================================================
FILE: queries/javascriptreact/docs.scm
================================================
; inherits: javascript


================================================
FILE: queries/jsdoc/edits.scm
================================================
(tag (type) @edit)
(description) @edit


================================================
FILE: queries/jsx/docs.scm
================================================
; inherits: javascript


================================================
FILE: queries/lua/docs.scm
================================================
; Nonlocal functions `function M.test() end`
; Local functions `local function test() end`
(function_declaration
  name: (_) @function.name
  parameters: (parameters
    (identifier)? @function.parameters.name @function.parameters.definition) @function.end_point
  (return_statement)? @function.return) @function.definition

; Non local variables `M.test = {}`
(assignment_statement
  (variable_list
    name: (dot_index_expression
      field: (identifier) @variable.name)) @variable.end_point) @variable.definition @variable.local

; Local variables `local test = {}`
(variable_declaration
  (assignment_statement
    (variable_list
      name: (identifier) @variable.name)) @variable.end_point) @variable.definition


================================================
FILE: queries/python/docs.scm
================================================
(function_definition
  name: (identifier) @function.name) @function.definition

(function_definition
  parameters: (parameters
    (identifier) @function.parameters.name @function.parameters.definition) @function.end_point) @function.definition


================================================
FILE: queries/tsx/docs.scm
================================================
; inherits: typescript


================================================
FILE: queries/typescript/docs.scm
================================================
; inherits: ecma

; ---- Functions

; Function generics
(function_declaration
  type_parameters: (type_parameters
    (type_parameter
      (type_identifier) @function.generics.name @function.generics.definition))) @function.definition

; Function return type
(function_declaration
  return_type: (type_annotation
    (_) @function.return_type @function.end_point)) @function.definition

; Function param name
(function_declaration
  parameters: (formal_parameters
    (_
      (identifier) @function.parameters.name @function.parameters.definition))) @function.definition


; Function param types
(function_declaration
  parameters: (formal_parameters
    (_
      (identifier) @function.parameters.definition
      (type_annotation
        (_) @function.parameters.type)))) @function.definition

; Function param default value
(function_declaration
  parameters: (formal_parameters
    (_
      (identifier) @function.parameters.definition
      value: (_) @function.parameters.default_value @function.parameters.optional))) @function.definition

; ----- Variables

; Variable initializer
(lexical_declaration
  (variable_declarator
    type: (type_annotation
      (_) @variable.type)) @variable.definition)

; ----- Methods

; Method type parameters
(method_definition
  type_parameters: (type_parameters
    (type_parameter
      (type_identifier) @method.generics.name @method.generics.definition))) @method.definition

; Method return type
(method_definition
  return_type: (type_annotation
    (_) @method.return_type)) @method.definition

; Method params
(method_definition
  parameters: (formal_parameters
    (_
      (identifier) @method.parameters.name @method.parameters.definition))) @method.definition

; Method param type
(method_definition
  parameters: (formal_parameters
    (_
      (identifier) @method.parameters.definition
      (type_annotation (_) @method.parameters.type)))) @method.definition

; Method param default value
(method_definition
  parameters: (formal_parameters
    (_
      (identifier) @method.parameters.definition
      value: (_) @method.parameters.default_value @method.parameters.optional))) @method.definition

; Method signature name
(method_signature
  name: (property_identifier) @method.name) @method.definition

; Method signatures params
(method_signature
  parameters: (formal_parameters
    (required_parameter
      (identifier) @method.parameters.name @method.parameters.definition) @method.end_point)) @method.definition

; Method signatures params type
(method_signature
  parameters: (formal_parameters
    (_
      (identifier) @method.parameters.definition
      (type_annotation
        (_) @method.parameters.type)) @method.end_point)) @method.definition

; Method signatures return type
(method_signature
  return_type: (type_annotation
    (_) @method.return_type) @method.end_point) @method.definition

; Classes

(class_declaration
  type_parameters: (type_parameters
    (type_parameter
      name: (type_identifier) @class.generics.name @class.generics.definition)) @class.end_point) @class.definition

(class_declaration
  (class_heritage
    (extends_clause
      value: (identifier) @class.extentions.name @class.extentions.definition))) @class.definition

(class_declaration
  (class_heritage
    (implements_clause
      (type_identifier) @class.implementations.name @class.implementations.definition))) @class.definition

(class_declaration
  (class_heritage
    (implements_clause
      (generic_type
        name: (type_identifier) @class.implementations.name @class.implementations.definition)))) @class.definition

; ---- Interfaces

; Interface doc
(
  (comment) @interface.doc
  (interface_declaration) @interface.definition
)

; Interface name
(interface_declaration
  name: (_) @interface.name @interface.end_point) @interface.definition

; Interface type parameters
(interface_declaration
  type_parameters: (type_parameters
    (type_parameter
      name: (type_identifier) @interface.generics.name @interface.generics.definition)) @interface.end_point) @interface.definition

; Interface extend clause
(interface_declaration
  (extends_type_clause
    (_) @interface.extentions.name @interface.extentions.definition) @interface.end_point) @interface.definition

; Exported interface doc
((comment) @interface.doc
 .
 (export_statement
   (interface_declaration) @interface.definition))

; Exported interface
(export_statement
  (interface_declaration) @interface.definition) @interface.start_point

; Property signature name
(property_signature
  name: (_) @property_signature.name @property_signature.end_point) @property_signature.definition

; Property signature type
(property_signature
  type: (type_annotation
    (_) @property_signature.type) @property_signature.end_point) @property_signature.definition

; Property signature doc
((comment) @property_signature.doc
 .
 (property_signature) @property_signature.definition)

; ---- Type aliases

; Type alias doc
((comment) @type_alias.doc
 .
 (type_alias_declaration) @type_alias.definition)

; Type alias name
(type_alias_declaration
  name: (_) @type_alias.name @type_alias.end_point) @type_alias.definition

; Type alias type params
(type_alias_declaration
  type_parameters: (type_parameters
    (type_parameter
      name: (type_identifier) @type_alias.generics.name @type_alias.generics.definition)) @type_alias.end_point) @type_alias.definition

; Type alias export doc
((comment) @type_alias.doc
 .
 (export_statement
   (type_alias_declaration) @type_alias.definition))

; Type alias export
(export_statement
  (type_alias_declaration) @type_alias.definition) @type_alias.start_point

; Member name
(public_field_definition
  name: (property_identifier) @member.name @member.end_point) @member.definition

; Member class
(class_declaration
  name: (_) @member.class
  body: (class_body
    (public_field_definition) @member.definition))

; Member doc
((comment) @member.doc
 .
 (public_field_definition) @member.definition)


================================================
FILE: queries/typescriptreact/docs.scm
================================================
; inherits: typescript


================================================
FILE: scripts/dep.sh
================================================
#!/usr/bin/env bash

# Clones a GitHub repo into deps/{name} if it's not there already.
# Will update the repository each time and ensure the right commit is checked out.
# Args: GitHub user, repository name, checkout target.
# Usage (after copying to your scripts directory): scripts/dep.sh Olical aniseed vX.Y.Z

mkdir -p deps

if [ ! -d "deps/$2" ]; then
    git clone "https://github.com/$1/$2.git" "deps/$2"
fi

cd "deps/$2" && git fetch && git checkout "$3"



================================================
FILE: test/fnl/example/main-test.fnl
================================================
(module example.main-test)

(deftest something-simple
  (t.= 1 1 "1 should equal 1, I hope!"))