🎉 initiate project *astro_rewrite*

node_modules/estree-util-visit/index.d.ts

@@ -0,0 +1,6 @@
+export type Action = import('./lib/index.js').Action
+export type ActionTuple = import('./lib/index.js').ActionTuple
+export type Index = import('./lib/index.js').Index
+export type Visitor = import('./lib/index.js').Visitor
+export type Visitors = import('./lib/index.js').Visitors
+export {CONTINUE, EXIT, SKIP, visit} from './lib/index.js'

node_modules/estree-util-visit/index.js

@@ -0,0 +1,9 @@
+/**
+ * @typedef {import('./lib/index.js').Action} Action
+ * @typedef {import('./lib/index.js').ActionTuple} ActionTuple
+ * @typedef {import('./lib/index.js').Index} Index
+ * @typedef {import('./lib/index.js').Visitor} Visitor
+ * @typedef {import('./lib/index.js').Visitors} Visitors
+ */
+
+export {CONTINUE, EXIT, SKIP, visit} from './lib/index.js'

node_modules/estree-util-visit/lib/color.browser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {string} d
+ * @returns {string}
+ */
+export function color(d: string): string

node_modules/estree-util-visit/lib/color.browser.js

@@ -0,0 +1,7 @@
+/**
+ * @param {string} d
+ * @returns {string}
+ */
+export function color(d) {
+  return d
+}

node_modules/estree-util-visit/lib/color.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {string} d
+ * @returns {string}
+ */
+export function color(d: string): string

node_modules/estree-util-visit/lib/color.js

@@ -0,0 +1,7 @@
+/**
+ * @param {string} d
+ * @returns {string}
+ */
+export function color(d) {
+  return '\u001B[33m' + d + '\u001B[39m'
+}

node_modules/estree-util-visit/lib/index.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Visit nodes, with ancestral information.
+ *
+ * This algorithm performs *depth-first* *tree traversal* in *preorder*
+ * (**NLR**) and/or *postorder* (**LRN**).
+ *
+ * Walking the tree is an intensive task.
+ * Make use of the return values of the visitor(s) when possible.
+ * Instead of walking a tree multiple times, walk it once, use `unist-util-is`
+ * to check if a node matches, and then perform different operations.
+ *
+ * @param {Node} tree
+ *   Tree to traverse
+ * @param {Visitor | Visitors | null | undefined} [visitor]
+ *   Handle each node.
+ * @returns {void}
+ *   Nothing.
+ */
+export function visit(
+  tree: Node,
+  visitor?: Visitor | Visitors | null | undefined
+): void
+/**
+ * Continue traversing as normal.
+ */
+export const CONTINUE: unique symbol
+/**
+ * Stop traversing immediately.
+ */
+export const EXIT: unique symbol
+/**
+ * Do not traverse this node’s children.
+ */
+export const SKIP: unique symbol
+export type Node = import('estree-jsx').Node
+/**
+ * Union of the action types.
+ */
+export type Action = typeof CONTINUE | typeof SKIP | typeof EXIT
+/**
+ * Move to the sibling at `index` next (after node itself is completely
+ * traversed), when moving in an array.
+ *
+ * Useful if mutating the tree, such as removing the node the visitor is
+ * currently on, or any of its previous siblings.
+ * Results less than 0 or greater than or equal to `children.length` stop
+ * traversing the parent.
+ */
+export type Index = number
+/**
+ * List with one or two values, the first an action, the second an index.
+ */
+export type ActionTuple = [
+  (Action | null | undefined | void)?,
+  (Index | null | undefined)?
+]
+/**
+ * Handle a node.
+ *
+ * Visitors are free to transform `node`.
+ * They can also transform the parent of node (the last of `ancestors`).
+ *
+ * Replacing `node` itself, if `SKIP` is not returned, still causes its
+ * descendants to be walked (which is a bug).
+ *
+ * When adding or removing previous siblings of `node`, the `Visitor` should
+ * return a new `Index` to specify the sibling to traverse after `node` is
+ * traversed.
+ * Adding or removing next siblings of `node` is handled as expected without
+ * needing to return a new `Index`.
+ */
+export type Visitor = (
+  node: Node,
+  key: string | null,
+  index: number | null,
+  ancestors: Array<Node>
+) => Action | Index | ActionTuple | null | undefined | void
+/**
+ * Handle nodes when entering (preorder) and leaving (postorder).
+ */
+export type Visitors = {
+  /**
+   * Handle nodes when entering (preorder).
+   */
+  enter?: Visitor | null | undefined
+  /**
+   * Handle nodes when leaving (postorder).
+   */
+  leave?: Visitor | null | undefined
+}

node_modules/estree-util-visit/lib/index.js

@@ -0,0 +1,229 @@
+/**
+ * @typedef {import('estree-jsx').Node} Node
+ */
+
+/**
+ * @typedef {CONTINUE | SKIP | EXIT} Action
+ *   Union of the action types.
+ *
+ * @typedef {number} Index
+ *   Move to the sibling at `index` next (after node itself is completely
+ *   traversed), when moving in an array.
+ *
+ *   Useful if mutating the tree, such as removing the node the visitor is
+ *   currently on, or any of its previous siblings.
+ *   Results less than 0 or greater than or equal to `children.length` stop
+ *   traversing the parent.
+ *
+ * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple
+ *   List with one or two values, the first an action, the second an index.
+ */
+
+/**
+ * @callback Visitor
+ *   Handle a node.
+ *
+ *   Visitors are free to transform `node`.
+ *   They can also transform the parent of node (the last of `ancestors`).
+ *
+ *   Replacing `node` itself, if `SKIP` is not returned, still causes its
+ *   descendants to be walked (which is a bug).
+ *
+ *   When adding or removing previous siblings of `node`, the `Visitor` should
+ *   return a new `Index` to specify the sibling to traverse after `node` is
+ *   traversed.
+ *   Adding or removing next siblings of `node` is handled as expected without
+ *   needing to return a new `Index`.
+ * @param {Node} node
+ *   Found node.
+ * @param {string | null} key
+ *   Field at which `node` lives in its parent (or where a list of nodes lives).
+ * @param {number | null} index
+ *   Index where `node` lives if `parent[key]` is an array.
+ * @param {Array<Node>} ancestors
+ *   Ancestors of `node`.
+ * @returns {Action | Index | ActionTuple | null | undefined | void}
+ *   What to do next.
+ *
+ *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
+ *   An `Action` is treated as a tuple of `[Action]`.
+ *
+ *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
+ *   When the `Action` is `EXIT`, that action can be returned.
+ *   When the `Action` is `CONTINUE`, `Index` can be returned.
+ */
+
+/**
+ * @typedef Visitors
+ *   Handle nodes when entering (preorder) and leaving (postorder).
+ * @property {Visitor | null | undefined} [enter]
+ *   Handle nodes when entering (preorder).
+ * @property {Visitor | null | undefined} [leave]
+ *   Handle nodes when leaving (postorder).
+ */
+
+import {color} from './color.js'
+
+const own = {}.hasOwnProperty
+
+/**
+ * Continue traversing as normal.
+ */
+export const CONTINUE = Symbol('continue')
+
+/**
+ * Stop traversing immediately.
+ */
+export const EXIT = Symbol('exit')
+
+/**
+ * Do not traverse this node’s children.
+ */
+export const SKIP = Symbol('skip')
+
+/**
+ * Visit nodes, with ancestral information.
+ *
+ * This algorithm performs *depth-first* *tree traversal* in *preorder*
+ * (**NLR**) and/or *postorder* (**LRN**).
+ *
+ * Walking the tree is an intensive task.
+ * Make use of the return values of the visitor(s) when possible.
+ * Instead of walking a tree multiple times, walk it once, use `unist-util-is`
+ * to check if a node matches, and then perform different operations.
+ *
+ * @param {Node} tree
+ *   Tree to traverse
+ * @param {Visitor | Visitors | null | undefined} [visitor]
+ *   Handle each node.
+ * @returns {void}
+ *   Nothing.
+ */
+export function visit(tree, visitor) {
+  /** @type {Visitor | undefined} */
+  let enter
+  /** @type {Visitor | undefined} */
+  let leave
+
+  if (typeof visitor === 'function') {
+    enter = visitor
+  } else if (visitor && typeof visitor === 'object') {
+    if (visitor.enter) enter = visitor.enter
+    if (visitor.leave) leave = visitor.leave
+  }
+
+  build(tree, null, null, [])()
+
+  /**
+   * @param {Node} node
+   * @param {string | null} key
+   * @param {number | null} index
+   * @param {Array<Node>} parents
+   */
+  function build(node, key, index, parents) {
+    if (nodelike(node)) {
+      visit.displayName = 'node (' + color(node.type) + ')'
+    }
+
+    return visit
+
+    /**
+     * @returns {ActionTuple}
+     */
+    function visit() {
+      /** @type {ActionTuple} */
+      const result = enter ? toResult(enter(node, key, index, parents)) : []
+
+      if (result[0] === EXIT) {
+        return result
+      }
+
+      if (result[0] !== SKIP) {
+        /** @type {keyof node} */
+        let cKey
+
+        for (cKey in node) {
+          if (
+            own.call(node, cKey) &&
+            node[cKey] &&
+            typeof node[cKey] === 'object' &&
+            // @ts-expect-error: custom esast extension.
+            cKey !== 'data' &&
+            // @ts-expect-error: custom esast extension.
+            cKey !== 'position'
+          ) {
+            const grandparents = parents.concat(node)
+            /** @type {unknown} */
+            const value = node[cKey]
+
+            if (Array.isArray(value)) {
+              const nodes = /** @type {Array<unknown>} */ (value)
+              let cIndex = 0
+
+              while (cIndex > -1 && cIndex < nodes.length) {
+                const subvalue = nodes[cIndex]
+
+                if (nodelike(subvalue)) {
+                  const subresult = build(
+                    subvalue,
+                    cKey,
+                    cIndex,
+                    grandparents
+                  )()
+                  if (subresult[0] === EXIT) return subresult
+                  cIndex =
+                    typeof subresult[1] === 'number' ? subresult[1] : cIndex + 1
+                } else {
+                  cIndex++
+                }
+              }
+            } else if (nodelike(value)) {
+              const subresult = build(value, cKey, null, grandparents)()
+              if (subresult[0] === EXIT) return subresult
+            }
+          }
+        }
+      }
+
+      return leave ? toResult(leave(node, key, index, parents)) : result
+    }
+  }
+}
+
+/**
+ * Turn a return value into a clean result.
+ *
+ * @param {Action | Index | ActionTuple | null | undefined | void} value
+ *   Valid return values from visitors.
+ * @returns {ActionTuple}
+ *   Clean result.
+ */
+function toResult(value) {
+  if (Array.isArray(value)) {
+    return value
+  }
+
+  if (typeof value === 'number') {
+    return [CONTINUE, value]
+  }
+
+  return [value]
+}
+
+/**
+ * Check if something looks like a node.
+ *
+ * @param {unknown} value
+ *   Anything.
+ * @returns {value is Node}
+ *   Whether `value` looks like a node.
+ */
+function nodelike(value) {
+  return Boolean(
+    value &&
+      typeof value === 'object' &&
+      'type' in value &&
+      typeof value.type === 'string' &&
+      value.type.length > 0
+  )
+}

node_modules/estree-util-visit/license

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2021 Titus Wormer <tituswormer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/estree-util-visit/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "estree-util-visit",
+  "version": "1.2.1",
+  "description": "esast (and estree) utility to visit nodes",
+  "license": "MIT",
+  "keywords": [
+    "esast",
+    "esast-util",
+    "util",
+    "utility",
+    "recma",
+    "esast",
+    "estree",
+    "javascript",
+    "ecmascript",
+    "tree",
+    "ast",
+    "node",
+    "visit",
+    "walk"
+  ],
+  "repository": "syntax-tree/estree-util-visit",
+  "bugs": "https://github.com/syntax-tree/estree-util-visit/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "browser": {
+    "./lib/color.js": "./lib/color.browser.js"
+  },
+  "react-native": {
+    "./lib/color.js": "./lib/color.browser.js"
+  },
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/estree-jsx": "^1.0.0",
+    "@types/unist": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "acorn": "^8.0.0",
+    "c8": "^7.0.0",
+    "prettier": "^2.0.0",
+    "remark-cli": "^11.0.0",
+    "remark-preset-wooorm": "^9.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^4.0.0",
+    "xo": "^0.53.0"
+  },
+  "scripts": {
+    "prepack": "npm run build && npm run format",
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix",
+    "test-api": "node --conditions development test.js",
+    "test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api",
+    "test": "npm run build && npm run format && npm run test-coverage"
+  },
+  "prettier": {
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "bracketSpacing": false,
+    "semi": false,
+    "trailingComma": "none"
+  },
+  "xo": {
+    "prettier": true,
+    "rules": {
+      "max-depth": "off"
+    }
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "strict": true
+  }
+}

node_modules/estree-util-visit/readme.md

@@ -0,0 +1,352 @@
+# estree-util-visit
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+[estree][] (and [esast][]) utility to visit nodes.
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`visit(tree, visitor|visitors)`](#visittree-visitorvisitors)
+    *   [`CONTINUE`](#continue)
+    *   [`EXIT`](#exit)
+    *   [`SKIP`](#skip)
+    *   [`Action`](#action)
+    *   [`ActionTuple`](#actiontuple)
+    *   [`Index`](#index)
+    *   [`Visitor`](#visitor)
+    *   [`Visitors`](#visitors)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Related](#related)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This package is a utility that helps you walk the tree.
+
+## When should I use this?
+
+This package helps when dealing with JavaScript ASTs.
+Use [`unist-util-visit`][unist-util-visit] for other unist ASTs.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 14.14+ and 16.0+), install with [npm][]:
+
+```sh
+npm install estree-util-visit
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import {visit} from 'https://esm.sh/estree-util-visit@1'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+<script type="module">
+  import {visit} from 'https://esm.sh/estree-util-visit@1?bundle'
+</script>
+```
+
+## Use
+
+```js
+import {parse} from 'acorn'
+import {visit} from 'estree-util-visit'
+
+const tree = parse(
+  'export function x() { console.log(1 + "2"); process.exit(3) }',
+  {sourceType: 'module', ecmaVersion: 2020}
+)
+
+visit(tree, (node) => {
+  if (node.type === 'Literal' && 'value' in node) console.log(node.value)
+})
+
+// Both enter and leave:
+walk(tree, {
+  enter(node, field, index, parents) { /* … */ },
+  leave(node, field, index, parents) { /* … */ }
+})
+```
+
+Yields:
+
+```txt
+1
+"2"
+3
+```
+
+## API
+
+This package exports the identifiers [`CONTINUE`][continue], [`EXIT`][exit],
+[`SKIP`][skip], and [`visit`][visit].
+There is no default export.
+
+### `visit(tree, visitor|visitors)`
+
+Visit nodes, with ancestral information.
+
+This algorithm performs [*depth-first*][depth-first]
+[*tree traversal*][tree-traversal] in [*preorder*][preorder] (**NLR**) and/or
+[*postorder*][postorder] (**LRN**).
+
+Compared to other estree walkers, this does not need a dictionary of which
+fields are nodes, because it ducktypes instead.
+
+Walking the tree is an intensive task.
+Make use of the return values of the visitor(s) when possible.
+Instead of walking a tree multiple times, walk it once, use
+[`unist-util-is`][is] to check if a node matches, and then perform different
+operations.
+
+###### Parameters
+
+*   `tree` ([`Node`][node])
+    — tree to traverse
+*   `visitor` ([`Visitor`][visitor])
+    — same as passing `{enter: visitor}`
+*   `visitors` ([`Visitors`][visitors])
+    — handle each node
+
+###### Returns
+
+Nothing (`void`).
+
+### `CONTINUE`
+
+Continue traversing as normal (`symbol`).
+
+### `EXIT`
+
+Stop traversing immediately (`symbol`).
+
+### `SKIP`
+
+Do not traverse this node’s children (`symbol`).
+
+### `Action`
+
+Union of the action types (TypeScript type).
+
+###### Type
+
+```ts
+type Action = typeof CONTINUE | typeof SKIP | typeof EXIT
+```
+
+### `ActionTuple`
+
+List with one or two values, the first an action, the second an index
+(TypeScript type).
+
+###### Type
+
+```ts
+type ActionTuple = [
+  (Action | null | undefined | void)?,
+  (Index | null | undefined)?
+]
+```
+
+### `Index`
+
+Move to the sibling at `index` next (after node itself is completely
+traversed), when moving in an array (TypeScript type).
+
+Useful if mutating the tree, such as removing the node the visitor is currently
+on, or any of its previous siblings.
+Results less than 0 or greater than or equal to `children.length` stop
+traversing the parent.
+
+###### Type
+
+```ts
+type Index = number
+```
+
+### `Visitor`
+
+Handle a node (TypeScript type).
+
+Visitors are free to transform `node`.
+They can also transform the parent of node (the last of `ancestors`).
+
+Replacing `node` itself, if `SKIP` is not returned, still causes its
+descendants to be walked (which is a bug).
+
+When adding or removing previous siblings of `node`, the `Visitor` should
+return a new `Index` to specify the sibling to traverse after `node` is
+traversed.
+Adding or removing next siblings of `node` is handled as expected without
+needing to return a new `Index`.
+
+###### Parameters
+
+*   `node` ([`Node`][node])
+    — found node
+*   `key` (`string` or `null`)
+    — field at which `node` lives in its parent (or where a list of nodes
+    lives)
+*   `index` (`number` or `null`)
+    — index where `node` lives if `parent[key]` is an array
+*   `ancestors` ([`Array<Node>`][node])
+    — ancestors of `node`
+
+###### Returns
+
+What to do next ([`Action`][action], [`Index`][index], or
+[`ActionTuple`][actiontuple], optional).
+
+An `Index` is treated as a tuple of `[CONTINUE, Index]`.
+An `Action` is treated as a tuple of `[Action]`.
+
+Passing a tuple back only makes sense if the `Action` is `SKIP`.
+When the `Action` is `EXIT`, that action can be returned.
+When the `Action` is `CONTINUE`, `Index` can be returned.
+
+### `Visitors`
+
+Handle nodes when entering (preorder) and leaving (postorder) (TypeScript
+type).
+
+###### Fields
+
+*   `enter` ([`Visitor`][visitor], optional)
+    — handle nodes when entering (preorder)
+*   `leave` ([`Visitor`][visitor], optional)
+    — handle nodes when leaving (postorder)
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional types [`Action`][action],
+[`ActionTuple`][actiontuple], [`Index`][index],
+[`Visitor`][visitor], and [`Visitors`][visitors].
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with all maintained
+versions of Node.js.
+As of now, that is Node.js 12.20+, 14.14+, 16.0+, and 18.0+.
+Our projects sometimes work with older versions, but this is not guaranteed.
+
+## Related
+
+*   [`unist-util-visit`](https://github.com/syntax-tree/unist-util-visit)
+    — walk any unist tree
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`syntax-tree/.github`][health] for
+ways to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+<!-- Definition -->
+
+[build-badge]: https://github.com/syntax-tree/estree-util-visit/workflows/main/badge.svg
+
+[build]: https://github.com/syntax-tree/estree-util-visit/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/syntax-tree/estree-util-visit.svg
+
+[coverage]: https://codecov.io/github/syntax-tree/estree-util-visit
+
+[downloads-badge]: https://img.shields.io/npm/dm/estree-util-visit.svg
+
+[downloads]: https://www.npmjs.com/package/estree-util-visit
+
+[size-badge]: https://img.shields.io/bundlephobia/minzip/estree-util-visit.svg
+
+[size]: https://bundlephobia.com/result?p=estree-util-visit
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/syntax-tree/unist/discussions
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[typescript]: https://www.typescriptlang.org
+
+[license]: license
+
+[author]: https://wooorm.com
+
+[health]: https://github.com/syntax-tree/.github
+
+[contributing]: https://github.com/syntax-tree/.github/blob/main/contributing.md
+
+[support]: https://github.com/syntax-tree/.github/blob/main/support.md
+
+[coc]: https://github.com/syntax-tree/.github/blob/main/code-of-conduct.md
+
+[esast]: https://github.com/syntax-tree/esast
+
+[estree]: https://github.com/estree/estree
+
+[depth-first]: https://github.com/syntax-tree/unist#depth-first-traversal
+
+[tree-traversal]: https://github.com/syntax-tree/unist#tree-traversal
+
+[preorder]: https://github.com/syntax-tree/unist#preorder
+
+[postorder]: https://github.com/syntax-tree/unist#postorder
+
+[is]: https://github.com/syntax-tree/unist-util-is
+
+[node]: https://github.com/syntax-tree/esast#node
+
+[unist-util-visit]: https://github.com/syntax-tree/unist-util-visit
+
+[continue]: #continue
+
+[exit]: #exit
+
+[skip]: #skip
+
+[visit]: #visittree-visitorvisitors
+
+[visitor]: #visitor
+
+[visitors]: #visitors
+
+[action]: #action
+
+[index]: #index
+
+[actiontuple]: #actiontuple