@lobehub/ui 3.4.2 → 3.4.3

package/es/node_modules/unist-util-visit/lib/index.mjs

@@ -0,0 +1,291 @@
+import { CONTINUE, EXIT, SKIP, visitParents } from "../node_modules/unist-util-visit-parents/lib/index.mjs";
+
+//#region node_modules/unist-util-visit/lib/index.js
+/**
+* @typedef {import('unist').Node} UnistNode
+* @typedef {import('unist').Parent} UnistParent
+* @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
+*/
+/**
+* @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test
+*   Test from `unist-util-is`.
+*
+*   Note: we have remove and add `undefined`, because otherwise when generating
+*   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,
+*   which doesn’t work when publishing on npm.
+*/
+/**
+* @typedef {(
+*   Fn extends (value: any) => value is infer Thing
+*   ? Thing
+*   : Fallback
+* )} Predicate
+*   Get the value of a type guard `Fn`.
+* @template Fn
+*   Value; typically function that is a type guard (such as `(x): x is Y`).
+* @template Fallback
+*   Value to yield if `Fn` is not a type guard.
+*/
+/**
+* @typedef {(
+*   Check extends null | undefined // No test.
+*   ? Value
+*   : Value extends {type: Check} // String (type) test.
+*   ? Value
+*   : Value extends Check // Partial test.
+*   ? Value
+*   : Check extends Function // Function test.
+*   ? Predicate<Check, Value> extends Value
+*     ? Predicate<Check, Value>
+*     : never
+*   : never // Some other test?
+* )} MatchesOne
+*   Check whether a node matches a primitive check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test, but not arrays.
+*/
+/**
+* @typedef {(
+*   Check extends Array<any>
+*   ? MatchesOne<Value, Check[keyof Check]>
+*   : MatchesOne<Value, Check>
+* )} Matches
+*   Check whether a node matches a check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test.
+*/
+/**
+* @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
+*   Number; capped reasonably.
+*/
+/**
+* @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
+*   Increment a number in the type system.
+* @template {Uint} [I=0]
+*   Index.
+*/
+/**
+* @typedef {(
+*   Node extends UnistParent
+*   ? Node extends {children: Array<infer Children>}
+*     ? Child extends Children ? Node : never
+*     : never
+*   : never
+* )} InternalParent
+*   Collect nodes that can be parents of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent
+*   Collect nodes in `Tree` that can be parents of `Child`.
+* @template {UnistNode} Tree
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {(
+*   Depth extends Max
+*   ? never
+*   :
+*     | InternalParent<Node, Child>
+*     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
+* )} InternalAncestor
+*   Collect nodes in `Tree` that can be ancestors of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @typedef {(
+*   Tree extends UnistParent
+*     ? Depth extends Max
+*       ? Tree
+*       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
+*     : Tree
+* )} InclusiveDescendant
+*   Collect all (inclusive) descendants of `Tree`.
+*
+*   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
+*   > recurse without actually running into an infinite loop, which the
+*   > previous version did.
+*   >
+*   > Practically, a max of `2` is typically enough assuming a `Root` is
+*   > passed, but it doesn’t improve performance.
+*   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
+*   > Using up to `10` doesn’t hurt or help either.
+* @template {UnistNode} Tree
+*   Tree type.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @callback Visitor
+*   Handle a node (matching `test`, if given).
+*
+*   Visitors are free to transform `node`.
+*   They can also transform `parent`.
+*
+*   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` (or next siblings, in
+*   case of reverse), the `Visitor` should return a new `Index` to specify the
+*   sibling to traverse after `node` is traversed.
+*   Adding or removing next siblings of `node` (or previous siblings, in case
+*   of reverse) is handled as expected without needing to return a new `Index`.
+*
+*   Removing the children property of `parent` still results in them being
+*   traversed.
+* @param {Visited} node
+*   Found node.
+* @param {Visited extends UnistNode ? number | undefined : never} index
+*   Index of `node` in `parent`.
+* @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
+*   Parent of `node`.
+* @returns {VisitorResult}
+*   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.
+* @template {UnistNode} [Visited=UnistNode]
+*   Visited node type.
+* @template {UnistParent} [Ancestor=UnistParent]
+*   Ancestor type.
+*/
+/**
+* @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch
+*   Build a typed `Visitor` function from a node and all possible parents.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} Visited
+*   Node type.
+* @template {UnistParent} Ancestor
+*   Parent type.
+*/
+/**
+* @typedef {(
+*   BuildVisitorFromMatch<
+*     Matches<Descendant, Check>,
+*     Extract<Descendant, UnistParent>
+*   >
+* )} BuildVisitorFromDescendants
+*   Build a typed `Visitor` function from a list of descendants and a test.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} Descendant
+*   Node type.
+* @template {Test} Check
+*   Test type.
+*/
+/**
+* @typedef {(
+*   BuildVisitorFromDescendants<
+*     InclusiveDescendant<Tree>,
+*     Check
+*   >
+* )} BuildVisitor
+*   Build a typed `Visitor` function from a tree and a test.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} [Tree=UnistNode]
+*   Node type.
+* @template {Test} [Check=Test]
+*   Test type.
+*/
+/**
+* Visit nodes.
+*
+* This algorithm performs *depth-first* *tree traversal* in *preorder*
+* (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+*
+* You can choose for which nodes `visitor` is called by passing a `test`.
+* For complex tests, you should test yourself in `visitor`, as it will be
+* faster and will have improved type information.
+*
+* Walking the tree is an intensive task.
+* Make use of the return values of the visitor 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.
+*
+* You can change the tree.
+* See `Visitor` for more info.
+*
+* @overload
+* @param {Tree} tree
+* @param {Check} check
+* @param {BuildVisitor<Tree, Check>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @overload
+* @param {Tree} tree
+* @param {BuildVisitor<Tree>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @param {UnistNode} tree
+*   Tree to traverse.
+* @param {Visitor | Test} testOrVisitor
+*   `unist-util-is`-compatible test (optional, omit to pass a visitor).
+* @param {Visitor | boolean | null | undefined} [visitorOrReverse]
+*   Handle each node (when test is omitted, pass `reverse`).
+* @param {boolean | null | undefined} [maybeReverse=false]
+*   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+* @returns {undefined}
+*   Nothing.
+*
+* @template {UnistNode} Tree
+*   Node type.
+* @template {Test} Check
+*   `unist-util-is`-compatible test.
+*/
+function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+	/** @type {boolean | null | undefined} */
+	let reverse;
+	/** @type {Test} */
+	let test;
+	/** @type {Visitor} */
+	let visitor;
+	if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
+		test = void 0;
+		visitor = testOrVisitor;
+		reverse = visitorOrReverse;
+	} else {
+		test = testOrVisitor;
+		visitor = visitorOrReverse;
+		reverse = maybeReverse;
+	}
+	visitParents(tree, test, overload, reverse);
+	/**
+	* @param {UnistNode} node
+	* @param {Array<UnistParent>} parents
+	*/
+	function overload(node, parents) {
+		const parent = parents[parents.length - 1];
+		const index = parent ? parent.children.indexOf(node) : void 0;
+		return visitor(node, index, parent);
+	}
+}
+
+//#endregion
+export { visit };
+//# sourceMappingURL=index.mjs.map

package/es/node_modules/unist-util-visit/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../node_modules/unist-util-visit/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsRA,SAAgB,MAAM,MAAM,eAAe,kBAAkB,cAAc;;CAEzE,IAAI;;CAEJ,IAAI;;CAEJ,IAAI;AAEJ,KACE,OAAO,kBAAkB,cACzB,OAAO,qBAAqB,YAC5B;AACA,SAAO;AACP,YAAU;AACV,YAAU;QACL;AAEL,SAAO;AAEP,YAAU;AACV,YAAU;;AAGZ,cAAa,MAAM,MAAM,UAAU,QAAQ;;;;;CAM3C,SAAS,SAAS,MAAM,SAAS;EAC/B,MAAM,SAAS,QAAQ,QAAQ,SAAS;EACxC,MAAM,QAAQ,SAAS,OAAO,SAAS,QAAQ,KAAK,GAAG;AACvD,SAAO,QAAQ,MAAM,OAAO,OAAO"}

package/es/node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.node.mjs

@@ -0,0 +1,12 @@
+//#region node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.node.js
+/**
+* @param {string} d
+* @returns {string}
+*/
+function color(d) {
+	return "\x1B[33m" + d + "\x1B[39m";
+}
+
+//#endregion
+export { color };
+//# sourceMappingURL=color.node.mjs.map

package/es/node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.node.mjs","names":[],"sources":["../../../../../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.node.js"],"sourcesContent":["/**\n * @param {string} d\n * @returns {string}\n */\nexport function color(d) {\n  return '\\u001B[33m' + d + '\\u001B[39m'\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;AAIA,SAAgB,MAAM,GAAG;AACvB,QAAO,aAAe,IAAI"}

package/es/node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/index.mjs

@@ -0,0 +1,339 @@
+import { convert } from "../../../../unist-util-is/lib/index.mjs";
+import { color } from "./color.node.mjs";
+
+//#region node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/index.js
+/**
+* @import {Node as UnistNode, Parent as UnistParent} from 'unist'
+*/
+/**
+* @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test
+*   Test from `unist-util-is`.
+*
+*   Note: we have remove and add `undefined`, because otherwise when generating
+*   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,
+*   which doesn’t work when publishing on npm.
+*/
+/**
+* @typedef {(
+*   Fn extends (value: any) => value is infer Thing
+*   ? Thing
+*   : Fallback
+* )} Predicate
+*   Get the value of a type guard `Fn`.
+* @template Fn
+*   Value; typically function that is a type guard (such as `(x): x is Y`).
+* @template Fallback
+*   Value to yield if `Fn` is not a type guard.
+*/
+/**
+* @typedef {(
+*   Check extends null | undefined // No test.
+*   ? Value
+*   : Value extends {type: Check} // String (type) test.
+*   ? Value
+*   : Value extends Check // Partial test.
+*   ? Value
+*   : Check extends Function // Function test.
+*   ? Predicate<Check, Value> extends Value
+*     ? Predicate<Check, Value>
+*     : never
+*   : never // Some other test?
+* )} MatchesOne
+*   Check whether a node matches a primitive check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test, but not arrays.
+*/
+/**
+* @typedef {(
+*   Check extends ReadonlyArray<infer T>
+*   ? MatchesOne<Value, T>
+*   : Check extends Array<infer T>
+*   ? MatchesOne<Value, T>
+*   : MatchesOne<Value, Check>
+* )} Matches
+*   Check whether a node matches a check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test.
+*/
+/**
+* @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
+*   Number; capped reasonably.
+*/
+/**
+* @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
+*   Increment a number in the type system.
+* @template {Uint} [I=0]
+*   Index.
+*/
+/**
+* @typedef {(
+*   Node extends UnistParent
+*   ? Node extends {children: Array<infer Children>}
+*     ? Child extends Children ? Node : never
+*     : never
+*   : never
+* )} InternalParent
+*   Collect nodes that can be parents of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent
+*   Collect nodes in `Tree` that can be parents of `Child`.
+* @template {UnistNode} Tree
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {(
+*   Depth extends Max
+*   ? never
+*   :
+*     | InternalParent<Node, Child>
+*     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
+* )} InternalAncestor
+*   Collect nodes in `Tree` that can be ancestors of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor
+*   Collect nodes in `Tree` that can be ancestors of `Child`.
+* @template {UnistNode} Tree
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {(
+*   Tree extends UnistParent
+*     ? Depth extends Max
+*       ? Tree
+*       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
+*     : Tree
+* )} InclusiveDescendant
+*   Collect all (inclusive) descendants of `Tree`.
+*
+*   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
+*   > recurse without actually running into an infinite loop, which the
+*   > previous version did.
+*   >
+*   > Practically, a max of `2` is typically enough assuming a `Root` is
+*   > passed, but it doesn’t improve performance.
+*   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
+*   > Using up to `10` doesn’t hurt or help either.
+* @template {UnistNode} Tree
+*   Tree type.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @typedef {'skip' | boolean} Action
+*   Union of the action types.
+*
+* @typedef {number} Index
+*   Move to the sibling at `index` next (after node itself is completely
+*   traversed).
+*
+*   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.
+*
+* @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult
+*   Any value that can be returned from a visitor.
+*/
+/**
+* @callback Visitor
+*   Handle a node (matching `test`, if given).
+*
+*   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` (or next siblings, in
+*   case of reverse), the `Visitor` should return a new `Index` to specify the
+*   sibling to traverse after `node` is traversed.
+*   Adding or removing next siblings of `node` (or previous siblings, in case
+*   of reverse) is handled as expected without needing to return a new `Index`.
+*
+*   Removing the children property of an ancestor still results in them being
+*   traversed.
+* @param {Visited} node
+*   Found node.
+* @param {Array<VisitedParents>} ancestors
+*   Ancestors of `node`.
+* @returns {VisitorResult}
+*   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.
+* @template {UnistNode} [Visited=UnistNode]
+*   Visited node type.
+* @template {UnistParent} [VisitedParents=UnistParent]
+*   Ancestor type.
+*/
+/**
+* @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor
+*   Build a typed `Visitor` function from a tree and a test.
+*
+*   It will infer which values are passed as `node` and which as `parents`.
+* @template {UnistNode} [Tree=UnistNode]
+*   Tree type.
+* @template {Test} [Check=Test]
+*   Test type.
+*/
+/** @type {Readonly<ActionTuple>} */
+const empty = [];
+/**
+* Continue traversing as normal.
+*/
+const CONTINUE = true;
+/**
+* Stop traversing immediately.
+*/
+const EXIT = false;
+/**
+* Do not traverse this node’s children.
+*/
+const SKIP = "skip";
+/**
+* Visit nodes, with ancestral information.
+*
+* This algorithm performs *depth-first* *tree traversal* in *preorder*
+* (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+*
+* You can choose for which nodes `visitor` is called by passing a `test`.
+* For complex tests, you should test yourself in `visitor`, as it will be
+* faster and will have improved type information.
+*
+* Walking the tree is an intensive task.
+* Make use of the return values of the visitor 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.
+*
+* You can change the tree.
+* See `Visitor` for more info.
+*
+* @overload
+* @param {Tree} tree
+* @param {Check} check
+* @param {BuildVisitor<Tree, Check>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @overload
+* @param {Tree} tree
+* @param {BuildVisitor<Tree>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @param {UnistNode} tree
+*   Tree to traverse.
+* @param {Visitor | Test} test
+*   `unist-util-is`-compatible test
+* @param {Visitor | boolean | null | undefined} [visitor]
+*   Handle each node.
+* @param {boolean | null | undefined} [reverse]
+*   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+* @returns {undefined}
+*   Nothing.
+*
+* @template {UnistNode} Tree
+*   Node type.
+* @template {Test} Check
+*   `unist-util-is`-compatible test.
+*/
+function visitParents(tree, test, visitor, reverse) {
+	/** @type {Test} */
+	let check;
+	if (typeof test === "function" && typeof visitor !== "function") {
+		reverse = visitor;
+		visitor = test;
+	} else check = test;
+	const is = convert(check);
+	const step = reverse ? -1 : 1;
+	factory(tree, void 0, [])();
+	/**
+	* @param {UnistNode} node
+	* @param {number | undefined} index
+	* @param {Array<UnistParent>} parents
+	*/
+	function factory(node, index, parents) {
+		const value = node && typeof node === "object" ? node : {};
+		if (typeof value.type === "string") {
+			const name = typeof value.tagName === "string" ? value.tagName : typeof value.name === "string" ? value.name : void 0;
+			Object.defineProperty(visit, "name", { value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")" });
+		}
+		return visit;
+		function visit() {
+			/** @type {Readonly<ActionTuple>} */
+			let result = empty;
+			/** @type {Readonly<ActionTuple>} */
+			let subresult;
+			/** @type {number} */
+			let offset;
+			/** @type {Array<UnistParent>} */
+			let grandparents;
+			if (!test || is(node, index, parents[parents.length - 1] || void 0)) {
+				result = toResult(visitor(node, parents));
+				if (result[0] === EXIT) return result;
+			}
+			if ("children" in node && node.children) {
+				const nodeAsParent = node;
+				if (nodeAsParent.children && result[0] !== SKIP) {
+					offset = (reverse ? nodeAsParent.children.length : -1) + step;
+					grandparents = parents.concat(nodeAsParent);
+					while (offset > -1 && offset < nodeAsParent.children.length) {
+						const child = nodeAsParent.children[offset];
+						subresult = factory(child, offset, grandparents)();
+						if (subresult[0] === EXIT) return subresult;
+						offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
+					}
+				}
+			}
+			return result;
+		}
+	}
+}
+/**
+* Turn a return value into a clean result.
+*
+* @param {VisitorResult} value
+*   Valid return values from visitors.
+* @returns {Readonly<ActionTuple>}
+*   Clean result.
+*/
+function toResult(value) {
+	if (Array.isArray(value)) return value;
+	if (typeof value === "number") return [CONTINUE, value];
+	return value === null || value === void 0 ? empty : [value];
+}
+
+//#endregion
+export { CONTINUE, EXIT, SKIP, visitParents };
+//# sourceMappingURL=index.mjs.map