@lobehub/ui 5.34.2 → 5.35.0

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

@@ -1,330 +0,0 @@
-import { convert } from "../../../../unist-util-is@6.0.1/node_modules/unist-util-is/lib/index.mjs";
-import { color } from "./color.node.mjs";
-//#region node_modules/.pnpm/unist-util-visit-parents@6.0.2/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 = [];
-/**
-* 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] === false) 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] === false) 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 [true, value];
-	return value === null || value === void 0 ? empty : [value];
-}
-//#endregion
-export { SKIP, visitParents };
-
-//# sourceMappingURL=index.mjs.map

package/es/node_modules/.pnpm/unist-util-visit-parents@6.0.2/node_modules/unist-util-visit-parents/lib/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../../../node_modules/.pnpm/unist-util-visit-parents@6.0.2/node_modules/unist-util-visit-parents/lib/index.js"],"sourcesContent":["/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\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/**\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 ReadonlyArray<infer T>\n *   ? MatchesOne<Value, T>\n *   : Check extends Array<infer T>\n *   ? MatchesOne<Value, T>\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 {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors 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 *   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 * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\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 the parent of node (the last of `ancestors`).\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 an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors 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} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} 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 `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from 'unist-util-visit-parents/do-not-use-color'\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\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} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\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 visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = convert(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n            typeof value.name === 'string'\n            ? value.name\n            : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgOA,MAAM,QAAQ,CAAC;;;;AAef,MAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDpB,SAAgB,aAAa,MAAM,MAAM,SAAS,SAAS;;CAEzD,IAAI;CAEJ,IAAI,OAAO,SAAS,cAAc,OAAO,YAAY,YAAY;EAC/D,UAAU;EAEV,UAAU;CACZ,OAEE,QAAQ;CAGV,MAAM,KAAK,QAAQ,KAAK;CACxB,MAAM,OAAO,UAAU,KAAK;CAE5B,QAAQ,MAAM,KAAA,GAAW,CAAC,CAAC,CAAC,CAAC;;;;;;CAO7B,SAAS,QAAQ,MAAM,OAAO,SAAS;EACrC,MAAM,QACJ,QAAQ,OAAO,SAAS,WAAW,OAAO,CAAC;EAG7C,IAAI,OAAO,MAAM,SAAS,UAAU;GAClC,MAAM,OAEJ,OAAO,MAAM,YAAY,WACrB,MAAM,UAEN,OAAO,MAAM,SAAS,WACpB,MAAM,OACN,KAAA;GAER,OAAO,eAAe,OAAO,QAAQ,EACnC,OACE,WAAW,MAAM,KAAK,QAAQ,OAAO,MAAM,OAAO,MAAM,GAAG,IAAI,IACnE,CAAC;EACH;EAEA,OAAO;EAEP,SAAS,QAAQ;;GAEf,IAAI,SAAS;;GAEb,IAAI;;GAEJ,IAAI;;GAEJ,IAAI;GAEJ,IAAI,CAAC,QAAQ,GAAG,MAAM,OAAO,QAAQ,QAAQ,SAAS,MAAM,KAAA,CAAS,GAAG;IAEtE,SAAS,SAAS,QAAQ,MAAM,OAAO,CAAC;IAExC,IAAI,OAAO,OAAA,OACT,OAAO;GAEX;GAEA,IAAI,cAAc,QAAQ,KAAK,UAAU;IACvC,MAAM,eAA2C;IAEjD,IAAI,aAAa,YAAY,OAAO,OAAA,QAAa;KAC/C,UAAU,UAAU,aAAa,SAAS,SAAS,MAAM;KACzD,eAAe,QAAQ,OAAO,YAAY;KAE1C,OAAO,SAAS,MAAM,SAAS,aAAa,SAAS,QAAQ;MAC3D,MAAM,QAAQ,aAAa,SAAS;MAEpC,YAAY,QAAQ,OAAO,QAAQ,YAAY,CAAC,CAAC;MAEjD,IAAI,UAAU,OAAA,OACZ,OAAO;MAGT,SACE,OAAO,UAAU,OAAO,WAAW,UAAU,KAAK,SAAS;KAC/D;IACF;GACF;GAEA,OAAO;EACT;CACF;AACF;;;;;;;;;AAUA,SAAS,SAAS,OAAO;CACvB,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO;CAGT,IAAI,OAAO,UAAU,UACnB,OAAO,CAAA,MAAW,KAAK;CAGzB,OAAO,UAAU,QAAQ,UAAU,KAAA,IAAY,QAAQ,CAAC,KAAK;AAC/D"}