@likec4/core 1.46.4 → 1.48.0

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

@@ -0,0 +1,653 @@
+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 };