vinext 1.2.0 → 1.3.0

package/dist/utils/regex-safety.js

@@ -1,789 +0,0 @@
-//#region src/utils/regex-safety.ts
-const MAX_NODES = 16384;
-const MAX_NESTING_DEPTH = 256;
-const MAX_PATTERN_LENGTH = 65536;
-const MAX_WORDS = 4096;
-const MAX_WORD_SYMBOLS = 32768;
-const MAX_OPAQUE_COMPARISONS = 4096;
-const MAX_SEQUENCE_EXPANSIONS = 256;
-const MAX_SAFE_OVERLAPPING_VARIABLE_BOUNDARIES = 1;
-function canonicalizeIgnoreCase(character) {
-	const upper = character.toUpperCase();
-	if (upper.length !== 1) return character;
-	if (character.charCodeAt(0) >= 128 && upper.charCodeAt(0) < 128) return character;
-	return upper;
-}
-function literalSymbol(character, ignoreCase) {
-	return {
-		kind: "literal",
-		key: ignoreCase ? canonicalizeIgnoreCase(character) : character,
-		value: character
-	};
-}
-function createClassSymbol(values, nonAscii) {
-	return {
-		kind: "class",
-		key: `class:${nonAscii}:${[...values].sort().join("")}`,
-		values,
-		nonAscii
-	};
-}
-function shorthandClassSymbol(shorthand, ignoreCase) {
-	if (!"dDwWsS".includes(shorthand)) return null;
-	const regexp = new RegExp(`\\${shorthand}`);
-	const values = /* @__PURE__ */ new Set();
-	for (let code = 0; code <= 127; code++) {
-		const character = String.fromCharCode(code);
-		if (regexp.test(character)) values.add(ignoreCase ? canonicalizeIgnoreCase(character) : character);
-	}
-	return createClassSymbol(values, shorthand === "d" || shorthand === "w" ? "none" : shorthand === "s" ? "whitespace" : shorthand === "S" ? "non-whitespace" : "all");
-}
-function unionNonAscii(left, right) {
-	if (left === "none") return right;
-	if (right === "none" || left === right) return left;
-	return "all";
-}
-function simpleClassSymbol(raw, ignoreCase) {
-	const end = raw.length - 1;
-	if (raw[0] !== "[" || raw[end] !== "]" || raw[1] === "^") return null;
-	const values = /* @__PURE__ */ new Set();
-	let nonAscii = "none";
-	const add = (character) => {
-		if (character.charCodeAt(0) > 127) return false;
-		values.add(ignoreCase ? canonicalizeIgnoreCase(character) : character);
-		return true;
-	};
-	const addClass = (symbol) => {
-		if (symbol.kind !== "class") return false;
-		for (const value of symbol.values) values.add(value);
-		nonAscii = unionNonAscii(nonAscii, symbol.nonAscii);
-		return true;
-	};
-	for (let index = 1; index < end; index++) {
-		const start = raw[index];
-		if (start === "\\") {
-			const escaped = raw[++index];
-			if (escaped === void 0) return null;
-			const shorthand = shorthandClassSymbol(escaped, ignoreCase);
-			if (shorthand) {
-				if (!addClass(shorthand)) return null;
-			} else if ("\\-]".includes(escaped)) {
-				if (!add(escaped)) return null;
-			} else return null;
-			continue;
-		}
-		if (index + 2 < end && raw[index + 1] === "-") {
-			const rangeEnd = raw[index + 2];
-			if (rangeEnd === "\\") return null;
-			const startCode = start.charCodeAt(0);
-			const endCode = rangeEnd.charCodeAt(0);
-			if (startCode > endCode || endCode > 127) return null;
-			for (let code = startCode; code <= endCode; code++) if (!add(String.fromCharCode(code))) return null;
-			index += 2;
-		} else if (!add(start)) return null;
-	}
-	if (values.size === 0 && nonAscii === "none") return null;
-	return createClassSymbol(values, nonAscii);
-}
-var RegexParser = class {
-	pattern;
-	ignoreCase;
-	namedGroups;
-	index = 0;
-	nodes = 0;
-	depth = 0;
-	exceededBudget = false;
-	constructor(pattern, ignoreCase, namedGroups) {
-		this.pattern = pattern;
-		this.ignoreCase = ignoreCase;
-		this.namedGroups = namedGroups;
-	}
-	parse() {
-		return this.parseAlternation();
-	}
-	node(node) {
-		this.nodes++;
-		if (this.nodes > MAX_NODES) this.exceededBudget = true;
-		return node;
-	}
-	parseAlternation() {
-		const branches = [this.parseSequence()];
-		while (this.pattern[this.index] === "|") {
-			this.index++;
-			branches.push(this.parseSequence());
-		}
-		return branches.length === 1 ? branches[0] : this.node({
-			kind: "alternation",
-			branches
-		});
-	}
-	parseSequence() {
-		const children = [];
-		while (this.index < this.pattern.length) {
-			const character = this.pattern[this.index];
-			if (character === "|" || character === ")") break;
-			const term = this.parseTerm();
-			if (term.kind === "sequence") children.push(...term.children);
-			else children.push(term);
-		}
-		return children.length === 1 ? children[0] : this.node({
-			kind: "sequence",
-			children
-		});
-	}
-	parseTerm() {
-		const atom = this.parseAtom();
-		const quantifier = this.parseQuantifier();
-		if (!quantifier) return atom;
-		if (this.pattern[this.index] === "?") this.index++;
-		if (quantifier.min === 1 && quantifier.max === 1) return atom;
-		return this.node({
-			kind: "repeat",
-			child: atom,
-			...quantifier
-		});
-	}
-	parseAtom() {
-		const character = this.pattern[this.index++];
-		if (character === "(") return this.parseGroup();
-		if (character === "[") return this.parseClass();
-		if (character === "\\") return this.parseEscape();
-		if (character === "^" || character === "$") return this.node({
-			kind: "assertion",
-			child: this.node({
-				kind: "sequence",
-				children: []
-			})
-		});
-		if (character === ".") return this.node({
-			kind: "atom",
-			symbol: {
-				kind: "opaque",
-				key: "opaque:.",
-				pattern: ".",
-				ignoreCase: this.ignoreCase
-			},
-			fixedWidth: true
-		});
-		return this.node({
-			kind: "atom",
-			symbol: literalSymbol(character, this.ignoreCase),
-			fixedWidth: true
-		});
-	}
-	parseGroup() {
-		this.depth++;
-		if (this.depth > MAX_NESTING_DEPTH) {
-			this.exceededBudget = true;
-			this.skipGroup();
-			this.depth--;
-			return this.node({
-				kind: "atom",
-				symbol: null,
-				fixedWidth: false
-			});
-		}
-		let assertion = false;
-		if (this.pattern[this.index] === "?") {
-			const marker = this.pattern[this.index + 1];
-			if (marker === ":") this.index += 2;
-			else if (marker === "=" || marker === "!") {
-				assertion = true;
-				this.index += 2;
-			} else if (marker === "<" && (this.pattern[this.index + 2] === "=" || this.pattern[this.index + 2] === "!")) {
-				assertion = true;
-				this.index += 3;
-			} else if (marker === "<") {
-				const nameEnd = this.pattern.indexOf(">", this.index + 2);
-				this.index = nameEnd === -1 ? this.pattern.length : nameEnd + 1;
-			} else {
-				while (this.index < this.pattern.length && this.pattern[this.index] !== ")") this.index++;
-				if (this.pattern[this.index] === ")") this.index++;
-				this.depth--;
-				return this.node({
-					kind: "atom",
-					symbol: null,
-					fixedWidth: false
-				});
-			}
-		}
-		const child = this.parseAlternation();
-		if (this.pattern[this.index] === ")") this.index++;
-		this.depth--;
-		return assertion ? this.node({
-			kind: "assertion",
-			child
-		}) : child;
-	}
-	skipGroup() {
-		let depth = 1;
-		let inClass = false;
-		while (this.index < this.pattern.length && depth > 0) {
-			const character = this.pattern[this.index++];
-			if (character === "\\") {
-				this.index++;
-				continue;
-			}
-			if (character === "[") inClass = true;
-			else if (character === "]") inClass = false;
-			else if (!inClass && character === "(") depth++;
-			else if (!inClass && character === ")") depth--;
-		}
-	}
-	parseClass() {
-		const start = this.index - 1;
-		while (this.index < this.pattern.length) {
-			const character = this.pattern[this.index++];
-			if (character === "\\") this.index++;
-			else if (character === "]") break;
-		}
-		const raw = this.pattern.slice(start, this.index);
-		return this.node({
-			kind: "atom",
-			symbol: simpleClassSymbol(raw, this.ignoreCase) ?? {
-				kind: "opaque",
-				key: `opaque:${raw}`,
-				pattern: raw,
-				ignoreCase: this.ignoreCase
-			},
-			fixedWidth: true
-		});
-	}
-	parseEscape() {
-		const escaped = this.pattern[this.index++];
-		if (escaped === void 0) return this.node({
-			kind: "atom",
-			symbol: null,
-			fixedWidth: false
-		});
-		if (escaped === "b" || escaped === "B") return this.node({
-			kind: "assertion",
-			child: this.node({
-				kind: "sequence",
-				children: []
-			})
-		});
-		const shorthand = shorthandClassSymbol(escaped, this.ignoreCase);
-		if (shorthand) return this.node({
-			kind: "atom",
-			symbol: shorthand,
-			fixedWidth: true
-		});
-		if (escaped === "k" && this.namedGroups && this.pattern[this.index] === "<") {
-			const nameEnd = this.pattern.indexOf(">", this.index);
-			this.index = nameEnd === -1 ? this.pattern.length : nameEnd + 1;
-			return this.node({
-				kind: "atom",
-				symbol: null,
-				fixedWidth: false
-			});
-		}
-		if (/\d/.test(escaped)) return this.node({
-			kind: "atom",
-			symbol: null,
-			fixedWidth: false
-		});
-		let literal = null;
-		if (escaped === "x" && /^[\da-fA-F]{2}/.test(this.pattern.slice(this.index, this.index + 2))) {
-			literal = String.fromCharCode(Number.parseInt(this.pattern.slice(this.index, this.index + 2), 16));
-			this.index += 2;
-		} else if (escaped === "u" && /^[\da-fA-F]{4}/.test(this.pattern.slice(this.index, this.index + 4))) {
-			literal = String.fromCharCode(Number.parseInt(this.pattern.slice(this.index, this.index + 4), 16));
-			this.index += 4;
-		} else if (escaped === "c") {
-			const letter = this.pattern[this.index];
-			if (letter !== void 0 && /[A-Za-z]/.test(letter)) {
-				literal = String.fromCharCode(letter.charCodeAt(0) % 32);
-				this.index++;
-			} else {
-				literal = "\\";
-				this.index--;
-			}
-		} else if ("nrtvf0".includes(escaped)) literal = {
-			n: "\n",
-			r: "\r",
-			t: "	",
-			v: "\v",
-			f: "\f",
-			0: "\0"
-		}[escaped];
-		else if (!/[A-Za-z]/.test(escaped)) literal = escaped;
-		if (literal !== null) return this.node({
-			kind: "atom",
-			symbol: literalSymbol(literal, this.ignoreCase),
-			fixedWidth: true
-		});
-		const raw = `\\${escaped}`;
-		return this.node({
-			kind: "atom",
-			symbol: {
-				kind: "opaque",
-				key: `opaque:${raw}`,
-				pattern: raw,
-				ignoreCase: this.ignoreCase
-			},
-			fixedWidth: true
-		});
-	}
-	parseQuantifier() {
-		const character = this.pattern[this.index];
-		if (character === "*") {
-			this.index++;
-			return {
-				min: 0,
-				max: Infinity
-			};
-		}
-		if (character === "+") {
-			this.index++;
-			return {
-				min: 1,
-				max: Infinity
-			};
-		}
-		if (character === "?") {
-			this.index++;
-			return {
-				min: 0,
-				max: 1
-			};
-		}
-		if (character !== "{") return null;
-		const start = this.index;
-		let cursor = start + 1;
-		while (/\d/.test(this.pattern[cursor] ?? "")) cursor++;
-		if (cursor === start + 1) return null;
-		const min = Number(this.pattern.slice(start + 1, cursor));
-		if (this.pattern[cursor] === "}") {
-			this.index = cursor + 1;
-			return {
-				min,
-				max: min
-			};
-		}
-		if (this.pattern[cursor] !== ",") return null;
-		cursor++;
-		const maxStart = cursor;
-		while (/\d/.test(this.pattern[cursor] ?? "")) cursor++;
-		if (this.pattern[cursor] !== "}") return null;
-		const max = cursor === maxStart ? Infinity : Number(this.pattern.slice(maxStart, cursor));
-		this.index = cursor + 1;
-		return {
-			min,
-			max
-		};
-	}
-};
-function exactWidth(node) {
-	switch (node.kind) {
-		case "atom": return node.fixedWidth ? 1 : null;
-		case "assertion": return 0;
-		case "sequence": {
-			let width = 0;
-			for (const child of node.children) {
-				const childWidth = exactWidth(child);
-				if (childWidth === null) return null;
-				width += childWidth;
-			}
-			return width;
-		}
-		case "alternation": {
-			let width;
-			for (const branch of node.branches) {
-				const branchWidth = exactWidth(branch);
-				if (branchWidth === null) return null;
-				if (width === void 0) width = branchWidth;
-				else if (width !== branchWidth) return null;
-			}
-			return width ?? 0;
-		}
-		case "repeat": {
-			if (node.min !== node.max || !Number.isFinite(node.max)) return null;
-			const childWidth = exactWidth(node.child);
-			return childWidth === null ? null : childWidth * node.min;
-		}
-	}
-}
-function containsConsumingRepetition(node) {
-	switch (node.kind) {
-		case "atom": return false;
-		case "assertion": return false;
-		case "sequence": return node.children.some(containsConsumingRepetition);
-		case "alternation": return node.branches.some(containsConsumingRepetition);
-		case "repeat": return node.min !== 1 || node.max !== 1 || containsConsumingRepetition(node.child);
-	}
-}
-function containsConsumingAlternation(node) {
-	switch (node.kind) {
-		case "atom": return false;
-		case "assertion": return false;
-		case "sequence": return node.children.some(containsConsumingAlternation);
-		case "alternation": return true;
-		case "repeat": return containsConsumingAlternation(node.child);
-	}
-}
-function fixedWords(node, budget) {
-	if (budget.exceeded) return null;
-	switch (node.kind) {
-		case "atom": return node.symbol ? [[node.symbol]] : null;
-		case "assertion": return [[]];
-		case "sequence": {
-			let words = [[]];
-			for (const child of node.children) {
-				const childWords = fixedWords(child, budget);
-				if (!childWords) return null;
-				const next = [];
-				for (const prefix of words) for (const suffix of childWords) {
-					if (++budget.words > MAX_WORDS) {
-						budget.exceeded = true;
-						return null;
-					}
-					const word = [...prefix, ...suffix];
-					budget.symbols += word.length;
-					if (budget.symbols > MAX_WORD_SYMBOLS) {
-						budget.exceeded = true;
-						return null;
-					}
-					next.push(word);
-				}
-				words = next;
-			}
-			return words;
-		}
-		case "alternation": {
-			const words = [];
-			for (const branch of node.branches) {
-				const branchWords = fixedWords(branch, budget);
-				if (!branchWords) return null;
-				words.push(...branchWords);
-				if ((budget.words += branchWords.length) > MAX_WORDS) {
-					budget.exceeded = true;
-					return null;
-				}
-			}
-			return words;
-		}
-		case "repeat": {
-			if (!Number.isFinite(node.max) || node.min > node.max) return null;
-			let words = [[]];
-			const childWords = fixedWords(node.child, budget);
-			if (!childWords) return null;
-			const repeated = node.min === 0 ? [[]] : [];
-			for (let count = 1; count <= node.max; count++) {
-				const next = [];
-				for (const prefix of words) for (const suffix of childWords) {
-					if (++budget.words > MAX_WORDS) {
-						budget.exceeded = true;
-						return null;
-					}
-					const word = [...prefix, ...suffix];
-					budget.symbols += word.length;
-					if (budget.symbols > MAX_WORD_SYMBOLS) {
-						budget.exceeded = true;
-						return null;
-					}
-					next.push(word);
-				}
-				words = next;
-				if (count >= node.min) repeated.push(...words);
-			}
-			return repeated;
-		}
-	}
-}
-function createTrieNode() {
-	return {
-		terminal: false,
-		edges: /* @__PURE__ */ new Map(),
-		complexEdges: []
-	};
-}
-function opaqueMatchesLiteral(opaque, literal) {
-	if (opaque.kind !== "opaque" || literal.kind !== "literal") return false;
-	try {
-		return new RegExp(`^(?:${opaque.pattern})$`, opaque.ignoreCase ? "i" : "").test(literal.value);
-	} catch {
-		return true;
-	}
-}
-function classMatchesLiteral(characterClass, literal) {
-	if (characterClass.kind !== "class" || literal.kind !== "literal") return false;
-	if (literal.value.charCodeAt(0) <= 127) return characterClass.values.has(literal.key);
-	if (characterClass.nonAscii === "all") return true;
-	return /\s/.test(literal.value) ? characterClass.nonAscii === "whitespace" : characterClass.nonAscii === "non-whitespace";
-}
-function nonAsciiDomainsOverlap(left, right) {
-	if (left === "none" || right === "none") return false;
-	if (left === "all" || right === "all") return true;
-	return left === right;
-}
-function symbolsMayOverlap(left, right) {
-	if (left.kind === "literal" && right.kind === "literal") return left.key === right.key;
-	if (left.kind === "class" && right.kind === "literal") return classMatchesLiteral(left, right);
-	if (left.kind === "literal" && right.kind === "class") return classMatchesLiteral(right, left);
-	if (left.kind === "class" && right.kind === "class") {
-		const [smaller, larger] = left.values.size <= right.values.size ? [left.values, right.values] : [right.values, left.values];
-		for (const value of smaller) if (larger.has(value)) return true;
-		return nonAsciiDomainsOverlap(left.nonAscii, right.nonAscii);
-	}
-	if (left.kind === "opaque" && right.kind === "literal") return opaqueMatchesLiteral(left, right);
-	if (left.kind === "literal" && right.kind === "opaque") return opaqueMatchesLiteral(right, left);
-	return true;
-}
-function wordMayCollide(node, word, index, comparisons, branched) {
-	if (node.terminal) return true;
-	if (index === word.length) return node.edges.size > 0;
-	if (branched && ++comparisons.count > MAX_OPAQUE_COMPARISONS) return true;
-	const symbol = word[index];
-	const exact = node.edges.get(symbol.key);
-	if (exact && wordMayCollide(exact.node, word, index + 1, comparisons, branched)) return true;
-	const candidates = symbol.kind === "literal" ? node.complexEdges : node.edges.values();
-	for (const candidate of candidates) {
-		if (candidate === exact) continue;
-		if (++comparisons.count > MAX_OPAQUE_COMPARISONS) return true;
-		if (symbolsMayOverlap(candidate.symbol, symbol) && wordMayCollide(candidate.node, word, index + 1, comparisons, true)) return true;
-	}
-	return false;
-}
-function insertPrefixFreeWord(root, word, comparisons) {
-	if (wordMayCollide(root, word, 0, comparisons, false)) return false;
-	let node = root;
-	for (const symbol of word) {
-		let edge = node.edges.get(symbol.key);
-		if (!edge) {
-			edge = {
-				symbol,
-				node: createTrieNode()
-			};
-			node.edges.set(symbol.key, edge);
-			if (symbol.kind !== "literal") node.complexEdges.push(edge);
-		}
-		node = edge.node;
-	}
-	node.terminal = true;
-	return true;
-}
-function hasPrefixFreeFiniteLanguage(node) {
-	const budget = {
-		words: 0,
-		symbols: 0,
-		exceeded: false
-	};
-	const words = fixedWords(node, budget);
-	if (!words) return {
-		safe: false,
-		budgetExceeded: budget.exceeded,
-		wordCount: 0
-	};
-	const root = createTrieNode();
-	const comparisons = { count: 0 };
-	for (const word of words) if (!insertPrefixFreeWord(root, word, comparisons)) return {
-		safe: false,
-		budgetExceeded: comparisons.count > MAX_OPAQUE_COMPARISONS,
-		wordCount: words.length
-	};
-	return {
-		safe: true,
-		budgetExceeded: false,
-		wordCount: words.length
-	};
-}
-function ambiguousExpansionFactor(node) {
-	switch (node.kind) {
-		case "atom":
-		case "assertion": return 1;
-		case "alternation": {
-			const result = hasPrefixFreeFiniteLanguage(node);
-			if (result.safe) return 1;
-			if (result.budgetExceeded || result.wordCount === 0) return 257;
-			return result.wordCount;
-		}
-		case "sequence": {
-			let factor = 1;
-			for (const child of node.children) {
-				factor *= ambiguousExpansionFactor(child);
-				if (factor > MAX_SEQUENCE_EXPANSIONS) return factor;
-			}
-			return factor;
-		}
-		case "repeat": {
-			if (node.min !== node.max || !Number.isFinite(node.max)) return 1;
-			const childFactor = ambiguousExpansionFactor(node.child);
-			if (childFactor === 1) return 1;
-			let factor = 1;
-			for (let count = 0; count < node.max; count++) {
-				factor *= childFactor;
-				if (factor > MAX_SEQUENCE_EXPANSIONS) return factor;
-			}
-			return factor;
-		}
-	}
-}
-function isNullable(node) {
-	switch (node.kind) {
-		case "atom": return !node.fixedWidth;
-		case "assertion": return true;
-		case "sequence": return node.children.every(isNullable);
-		case "alternation": return node.branches.some(isNullable);
-		case "repeat": return node.min === 0 || isNullable(node.child);
-	}
-}
-function firstSymbols(node) {
-	switch (node.kind) {
-		case "atom": return node.symbol ? [node.symbol] : null;
-		case "assertion": return [];
-		case "repeat": return firstSymbols(node.child);
-		case "alternation": {
-			const symbols = [];
-			for (const branch of node.branches) {
-				const branchSymbols = firstSymbols(branch);
-				if (!branchSymbols) return null;
-				symbols.push(...branchSymbols);
-			}
-			return symbols;
-		}
-		case "sequence": {
-			const symbols = [];
-			for (const child of node.children) {
-				const childSymbols = firstSymbols(child);
-				if (!childSymbols) return null;
-				symbols.push(...childSymbols);
-				if (!isNullable(child)) break;
-			}
-			return symbols;
-		}
-	}
-}
-function lastSymbols(node) {
-	switch (node.kind) {
-		case "atom": return node.symbol ? [node.symbol] : null;
-		case "assertion": return [];
-		case "repeat": return lastSymbols(node.child);
-		case "alternation": {
-			const symbols = [];
-			for (const branch of node.branches) {
-				const branchSymbols = lastSymbols(branch);
-				if (!branchSymbols) return null;
-				symbols.push(...branchSymbols);
-			}
-			return symbols;
-		}
-		case "sequence": {
-			const symbols = [];
-			for (let index = node.children.length - 1; index >= 0; index--) {
-				const child = node.children[index];
-				const childSymbols = lastSymbols(child);
-				if (!childSymbols) return null;
-				symbols.push(...childSymbols);
-				if (!isNullable(child)) break;
-			}
-			return symbols;
-		}
-	}
-}
-function boundariesMayOverlap(left, right, comparisons) {
-	if (!left || !right) return true;
-	for (const leftSymbol of left) for (const rightSymbol of right) {
-		if (++comparisons.count > MAX_OPAQUE_COMPARISONS) return true;
-		if (symbolsMayOverlap(leftSymbol, rightSymbol)) return true;
-	}
-	return false;
-}
-function findSequenceIssue(node) {
-	if (ambiguousExpansionFactor(node) > MAX_SEQUENCE_EXPANSIONS) return "ambiguous sequence expansion";
-	let pendingRepetitionEnds = [];
-	const comparisons = { count: 0 };
-	let overlappingBoundaryCount = 0;
-	for (const child of node.children) if (child.kind === "repeat" && (child.min !== child.max || !Number.isFinite(child.max))) {
-		const starts = firstSymbols(child);
-		if (pendingRepetitionEnds.filter((ends) => boundariesMayOverlap(ends, starts, comparisons)).length > 0) overlappingBoundaryCount++;
-		else if (!isNullable(child)) overlappingBoundaryCount = 0;
-		if (overlappingBoundaryCount > MAX_SAFE_OVERLAPPING_VARIABLE_BOUNDARIES) return "overlapping sequential repetition";
-		const ends = lastSymbols(child);
-		pendingRepetitionEnds = isNullable(child) ? [...pendingRepetitionEnds, ends] : [ends];
-	} else if (!isNullable(child)) {
-		pendingRepetitionEnds = [];
-		overlappingBoundaryCount = 0;
-	}
-	return null;
-}
-function findSafetyIssue(node) {
-	switch (node.kind) {
-		case "atom": return null;
-		case "assertion": return findSafetyIssue(node.child);
-		case "sequence": {
-			const sequenceIssue = findSequenceIssue(node);
-			if (sequenceIssue) return sequenceIssue;
-			for (const child of node.children) {
-				const issue = findSafetyIssue(child);
-				if (issue) return issue;
-			}
-			return null;
-		}
-		case "alternation":
-			for (const branch of node.branches) {
-				const issue = findSafetyIssue(branch);
-				if (issue) return issue;
-			}
-			return null;
-		case "repeat": {
-			const nestedRepetition = containsConsumingRepetition(node.child);
-			if (node.max > 1 && nestedRepetition && exactWidth(node.child) === null) return "nested repetition";
-			if (node.max > 1 && containsConsumingAlternation(node.child)) {
-				const prefixFree = hasPrefixFreeFiniteLanguage(node.child);
-				if (!prefixFree.safe) return prefixFree.budgetExceeded ? "analysis budget exceeded" : "ambiguous alternatives under repetition";
-			}
-			return findSafetyIssue(node.child);
-		}
-	}
-}
-/**
-* Whether a RegExp source declares a named group, which turns `\k<name>` into
-* a backreference. Escaped characters and character classes cannot open one.
-*/
-function mayHaveNamedGroups(pattern) {
-	let inClass = false;
-	for (let index = 0; index < pattern.length; index++) {
-		const character = pattern[index];
-		if (character === "\\") index++;
-		else if (inClass) {
-			if (character === "]") inClass = false;
-		} else if (character === "[") inClass = true;
-		else if (character === "(" && pattern.startsWith("?<", index + 1) && pattern[index + 3] !== "=" && pattern[index + 3] !== "!") return true;
-	}
-	return false;
-}
-/**
-* `namedGroups` must describe the whole compiled RegExp when `pattern` is only
-* a fragment of it. It defaults to scanning `pattern` itself.
-*/
-function analyzeRegexSafety(pattern, options = {}) {
-	if (pattern.length > MAX_PATTERN_LENGTH) return "analysis budget exceeded";
-	const parser = new RegexParser(pattern, options.ignoreCase === true, options.namedGroups ?? mayHaveNamedGroups(pattern));
-	const node = parser.parse();
-	if (parser.exceededBudget) return "analysis budget exceeded";
-	return findSafetyIssue(node);
-}
-function regexAtomsMayOverlap(left, right, ignoreCase = false) {
-	const leftParser = new RegexParser(left, ignoreCase, true);
-	const rightParser = new RegexParser(right, ignoreCase, true);
-	const leftNode = leftParser.parse();
-	const rightNode = rightParser.parse();
-	const leftWords = fixedWords(leftNode, {
-		words: 0,
-		symbols: 0,
-		exceeded: false
-	});
-	const rightWords = fixedWords(rightNode, {
-		words: 0,
-		symbols: 0,
-		exceeded: false
-	});
-	if (!leftWords || !rightWords || leftWords.length !== 1 || rightWords.length !== 1) return true;
-	const leftSymbol = leftWords[0][0];
-	const rightSymbol = rightWords[0][0];
-	if (!leftSymbol || !rightSymbol) return true;
-	return symbolsMayOverlap(leftSymbol, rightSymbol);
-}
-//#endregion
-export { analyzeRegexSafety, mayHaveNamedGroups, regexAtomsMayOverlap };