@likec4/core 1.48.0 → 1.49.0

package/dist/_chunks/libs/mdast-util-find-and-replace.mjs

@@ -1,653 +1 @@
-import { t as escapeStringRegexp } from "./escape-string-regexp.mjs";
-
-//#region ../../node_modules/.pnpm/unist-util-is@6.0.0/node_modules/unist-util-is/lib/index.js
-/**
-* Generate an assertion from a test.
-*
-* Useful if you’re going to test many nodes, for example when creating a
-* utility where something else passes a compatible test.
-*
-* The created function is a bit faster because it expects valid input only:
-* a `node`, `index`, and `parent`.
-*
-* @param {Test} test
-*   *   when nullish, checks if `node` is a `Node`.
-*   *   when `string`, works like passing `(node) => node.type === test`.
-*   *   when `function` checks if function passed the node is true.
-*   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
-*   *   when `array`, checks if any one of the subtests pass.
-* @returns {Check}
-*   An assertion.
-*/
-const convert = (function(test) {
-	if (test === null || test === void 0) return ok;
-	if (typeof test === "function") return castFactory(test);
-	if (typeof test === "object") return Array.isArray(test) ? anyFactory(test) : propsFactory(test);
-	if (typeof test === "string") return typeFactory(test);
-	throw new Error("Expected function, string, or object as test");
-});
-/**
-* @param {Array<Props | TestFunction | string>} tests
-* @returns {Check}
-*/
-function anyFactory(tests) {
-	/** @type {Array<Check>} */
-	const checks = [];
-	let index = -1;
-	while (++index < tests.length) checks[index] = convert(tests[index]);
-	return castFactory(any);
-	/**
-	* @this {unknown}
-	* @type {TestFunction}
-	*/
-	function any(...parameters) {
-		let index = -1;
-		while (++index < checks.length) if (checks[index].apply(this, parameters)) return true;
-		return false;
-	}
-}
-/**
-* Turn an object into a test for a node with a certain fields.
-*
-* @param {Props} check
-* @returns {Check}
-*/
-function propsFactory(check) {
-	const checkAsRecord = check;
-	return castFactory(all);
-	/**
-	* @param {Node} node
-	* @returns {boolean}
-	*/
-	function all(node) {
-		const nodeAsRecord = node;
-		/** @type {string} */
-		let key;
-		for (key in check) if (nodeAsRecord[key] !== checkAsRecord[key]) return false;
-		return true;
-	}
-}
-/**
-* Turn a string into a test for a node with a certain type.
-*
-* @param {string} check
-* @returns {Check}
-*/
-function typeFactory(check) {
-	return castFactory(type);
-	/**
-	* @param {Node} node
-	*/
-	function type(node) {
-		return node && node.type === check;
-	}
-}
-/**
-* Turn a custom test into a test for a node that passes that test.
-*
-* @param {TestFunction} testFunction
-* @returns {Check}
-*/
-function castFactory(testFunction) {
-	return check;
-	/**
-	* @this {unknown}
-	* @type {Check}
-	*/
-	function check(value, index, parent) {
-		return Boolean(looksLikeANode(value) && testFunction.call(this, value, typeof index === "number" ? index : void 0, parent || void 0));
-	}
-}
-function ok() {
-	return true;
-}
-/**
-* @param {unknown} value
-* @returns {value is Node}
-*/
-function looksLikeANode(value) {
-	return value !== null && typeof value === "object" && "type" in value;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/unist-util-visit-parents@6.0.2/node_modules/unist-util-visit-parents/lib/color.js
-/**
-* @param {string} d
-* @returns {string}
-*/
-function color(d) {
-	return d;
-}
-
-//#endregion
-//#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 = [];
-/**
-* 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
-//#region ../../node_modules/.pnpm/mdast-util-find-and-replace@3.0.2/node_modules/mdast-util-find-and-replace/lib/index.js
-/**
-* @import {Nodes, Parents, PhrasingContent, Root, Text} from 'mdast'
-* @import {BuildVisitor, Test, VisitorResult} from 'unist-util-visit-parents'
-*/
-/**
-* @typedef RegExpMatchObject
-*   Info on the match.
-* @property {number} index
-*   The index of the search at which the result was found.
-* @property {string} input
-*   A copy of the search string in the text node.
-* @property {[...Array<Parents>, Text]} stack
-*   All ancestors of the text node, where the last node is the text itself.
-*
-* @typedef {RegExp | string} Find
-*   Pattern to find.
-*
-*   Strings are escaped and then turned into global expressions.
-*
-* @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList
-*   Several find and replaces, in array form.
-*
-* @typedef {[Find, Replace?]} FindAndReplaceTuple
-*   Find and replace in tuple form.
-*
-* @typedef {ReplaceFunction | string | null | undefined} Replace
-*   Thing to replace with.
-*
-* @callback ReplaceFunction
-*   Callback called when a search matches.
-* @param {...any} parameters
-*   The parameters are the result of corresponding search expression:
-*
-*   * `value` (`string`) — whole match
-*   * `...capture` (`Array<string>`) — matches from regex capture groups
-*   * `match` (`RegExpMatchObject`) — info on the match
-* @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}
-*   Thing to replace with.
-*
-*   * when `null`, `undefined`, `''`, remove the match
-*   * …or when `false`, do not replace at all
-*   * …or when `string`, replace with a text node of that value
-*   * …or when `Node` or `Array<Node>`, replace with those nodes
-*
-* @typedef {[RegExp, ReplaceFunction]} Pair
-*   Normalized find and replace.
-*
-* @typedef {Array<Pair>} Pairs
-*   All find and replaced.
-*
-* @typedef Options
-*   Configuration.
-* @property {Test | null | undefined} [ignore]
-*   Test for which nodes to ignore (optional).
-*/
-/**
-* Find patterns in a tree and replace them.
-*
-* The algorithm searches the tree in *preorder* for complete values in `Text`
-* nodes.
-* Partial matches are not supported.
-*
-* @param {Nodes} tree
-*   Tree to change.
-* @param {FindAndReplaceList | FindAndReplaceTuple} list
-*   Patterns to find.
-* @param {Options | null | undefined} [options]
-*   Configuration (when `find` is not `Find`).
-* @returns {undefined}
-*   Nothing.
-*/
-function findAndReplace(tree, list, options) {
-	const ignored = convert((options || {}).ignore || []);
-	const pairs = toPairs(list);
-	let pairIndex = -1;
-	while (++pairIndex < pairs.length) visitParents(tree, "text", visitor);
-	/** @type {BuildVisitor<Root, 'text'>} */
-	function visitor(node, parents) {
-		let index = -1;
-		/** @type {Parents | undefined} */
-		let grandparent;
-		while (++index < parents.length) {
-			const parent = parents[index];
-			/** @type {Array<Nodes> | undefined} */
-			const siblings = grandparent ? grandparent.children : void 0;
-			if (ignored(parent, siblings ? siblings.indexOf(parent) : void 0, grandparent)) return;
-			grandparent = parent;
-		}
-		if (grandparent) return handler(node, parents);
-	}
-	/**
-	* Handle a text node which is not in an ignored parent.
-	*
-	* @param {Text} node
-	*   Text node.
-	* @param {Array<Parents>} parents
-	*   Parents.
-	* @returns {VisitorResult}
-	*   Result.
-	*/
-	function handler(node, parents) {
-		const parent = parents[parents.length - 1];
-		const find = pairs[pairIndex][0];
-		const replace = pairs[pairIndex][1];
-		let start = 0;
-		const index = parent.children.indexOf(node);
-		let change = false;
-		/** @type {Array<PhrasingContent>} */
-		let nodes = [];
-		find.lastIndex = 0;
-		let match = find.exec(node.value);
-		while (match) {
-			const position = match.index;
-			/** @type {RegExpMatchObject} */
-			const matchObject = {
-				index: match.index,
-				input: match.input,
-				stack: [...parents, node]
-			};
-			let value = replace(...match, matchObject);
-			if (typeof value === "string") value = value.length > 0 ? {
-				type: "text",
-				value
-			} : void 0;
-			if (value === false) find.lastIndex = position + 1;
-			else {
-				if (start !== position) nodes.push({
-					type: "text",
-					value: node.value.slice(start, position)
-				});
-				if (Array.isArray(value)) nodes.push(...value);
-				else if (value) nodes.push(value);
-				start = position + match[0].length;
-				change = true;
-			}
-			if (!find.global) break;
-			match = find.exec(node.value);
-		}
-		if (change) {
-			if (start < node.value.length) nodes.push({
-				type: "text",
-				value: node.value.slice(start)
-			});
-			parent.children.splice(index, 1, ...nodes);
-		} else nodes = [node];
-		return index + nodes.length;
-	}
-}
-/**
-* Turn a tuple or a list of tuples into pairs.
-*
-* @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList
-*   Schema.
-* @returns {Pairs}
-*   Clean pairs.
-*/
-function toPairs(tupleOrList) {
-	/** @type {Pairs} */
-	const result = [];
-	if (!Array.isArray(tupleOrList)) throw new TypeError("Expected find and replace tuple or list of tuples");
-	/** @type {FindAndReplaceList} */
-	const list = !tupleOrList[0] || Array.isArray(tupleOrList[0]) ? tupleOrList : [tupleOrList];
-	let index = -1;
-	while (++index < list.length) {
-		const tuple = list[index];
-		result.push([toExpression(tuple[0]), toFunction(tuple[1])]);
-	}
-	return result;
-}
-/**
-* Turn a find into an expression.
-*
-* @param {Find} find
-*   Find.
-* @returns {RegExp}
-*   Expression.
-*/
-function toExpression(find) {
-	return typeof find === "string" ? new RegExp(escapeStringRegexp(find), "g") : find;
-}
-/**
-* Turn a replace into a function.
-*
-* @param {Replace} replace
-*   Replace.
-* @returns {ReplaceFunction}
-*   Function.
-*/
-function toFunction(replace) {
-	return typeof replace === "function" ? replace : function() {
-		return replace;
-	};
-}
-
-//#endregion
-export { convert as i, EXIT as n, visitParents as r, findAndReplace as t };
+import{t as escapeStringRegexp}from"./escape-string-regexp.mjs";const convert=(function(e){if(e==null)return ok;if(typeof e==`function`)return castFactory(e);if(typeof e==`object`)return Array.isArray(e)?anyFactory(e):propsFactory(e);if(typeof e==`string`)return typeFactory(e);throw Error(`Expected function, string, or object as test`)});function anyFactory(e){let n=[],r=-1;for(;++r<e.length;)n[r]=convert(e[r]);return castFactory(i);function i(...e){let t=-1;for(;++t<n.length;)if(n[t].apply(this,e))return!0;return!1}}function propsFactory(e){let t=e;return castFactory(n);function n(n){let r=n,i;for(i in e)if(r[i]!==t[i])return!1;return!0}}function typeFactory(e){return castFactory(t);function t(t){return t&&t.type===e}}function castFactory(e){return t;function t(t,n,r){return!!(looksLikeANode(t)&&e.call(this,t,typeof n==`number`?n:void 0,r||void 0))}}function ok(){return!0}function looksLikeANode(e){return typeof e==`object`&&!!e&&`type`in e}function color(e){return e}const empty=[],EXIT=!1;function visitParents(e,n,r,i){let a;typeof n==`function`&&typeof r!=`function`?(i=r,r=n):a=n;let o=convert(a),s=i?-1:1;u(e,void 0,[])();function u(e,t,a){let d=e&&typeof e==`object`?e:{};if(typeof d.type==`string`){let t=typeof d.tagName==`string`?d.tagName:typeof d.name==`string`?d.name:void 0;Object.defineProperty(f,`name`,{value:`node (`+color(e.type+(t?`<`+t+`>`:``))+`)`})}return f;function f(){let c=empty,d,f,p;if((!n||o(e,t,a[a.length-1]||void 0))&&(c=toResult(r(e,a)),c[0]===!1))return c;if(`children`in e&&e.children){let t=e;if(t.children&&c[0]!==`skip`)for(f=(i?t.children.length:-1)+s,p=a.concat(t);f>-1&&f<t.children.length;){let e=t.children[f];if(d=u(e,f,p)(),d[0]===!1)return d;f=typeof d[1]==`number`?d[1]:f+s}}return c}}}function toResult(e){return Array.isArray(e)?e:typeof e==`number`?[!0,e]:e==null?empty:[e]}function findAndReplace(e,n,r){let i=convert((r||{}).ignore||[]),a=toPairs(n),o=-1;for(;++o<a.length;)visitParents(e,`text`,s);function s(e,t){let n=-1,r;for(;++n<t.length;){let e=t[n],a=r?r.children:void 0;if(i(e,a?a.indexOf(e):void 0,r))return;r=e}if(r)return c(e,t)}function c(e,t){let n=t[t.length-1],r=a[o][0],i=a[o][1],s=0,c=n.children.indexOf(e),l=!1,u=[];r.lastIndex=0;let d=r.exec(e.value);for(;d;){let n=d.index,a={index:d.index,input:d.input,stack:[...t,e]},o=i(...d,a);if(typeof o==`string`&&(o=o.length>0?{type:`text`,value:o}:void 0),o===!1?r.lastIndex=n+1:(s!==n&&u.push({type:`text`,value:e.value.slice(s,n)}),Array.isArray(o)?u.push(...o):o&&u.push(o),s=n+d[0].length,l=!0),!r.global)break;d=r.exec(e.value)}return l?(s<e.value.length&&u.push({type:`text`,value:e.value.slice(s)}),n.children.splice(c,1,...u)):u=[e],c+u.length}}function toPairs(e){let t=[];if(!Array.isArray(e))throw TypeError(`Expected find and replace tuple or list of tuples`);let n=!e[0]||Array.isArray(e[0])?e:[e],r=-1;for(;++r<n.length;){let e=n[r];t.push([toExpression(e[0]),toFunction(e[1])])}return t}function toExpression(t){return typeof t==`string`?new RegExp(escapeStringRegexp(t),`g`):t}function toFunction(e){return typeof e==`function`?e:function(){return e}}export{convert as i,EXIT as n,visitParents as r,findAndReplace as t};