@loopstack/loopstack-studio 0.27.0 → 0.29.0

package/dist/node_modules/langium/lib/utils/grammar-utils.js

@@ -1,296 +0,0 @@
-import { __export } from "../../../../_virtual/rolldown_runtime.js";
-import { isCompositeCstNode } from "../syntax-tree.js";
-import { getContainerOfType, streamAllContents } from "./ast-utils.js";
-import { isAbstractElement, isAbstractParserRule, isAction, isArrayType, isAssignment, isCharacterRange, isCrossReference, isGroup, isInferredType, isInfixRule, isInterface, isKeyword, isNegatedToken, isParserRule, isReferenceType, isRegexToken, isReturnType, isRuleCall, isSimpleType, isTerminalAlternatives, isTerminalGroup, isTerminalRule, isTerminalRuleCall, isType, isUnionType, isUntilToken, isWildcard } from "../languages/generated/ast.js";
-import { streamCst } from "./cst-utils.js";
-import { assertUnreachable } from "./errors.js";
-import { escapeRegExp, isWhitespace } from "./regexp-utils.js";
-var grammar_utils_exports = /* @__PURE__ */ __export({
-	findAssignment: () => findAssignment,
-	findNameAssignment: () => findNameAssignment,
-	findNodeForKeyword: () => findNodeForKeyword,
-	findNodeForProperty: () => findNodeForProperty,
-	findNodesForKeyword: () => findNodesForKeyword,
-	findNodesForKeywordInternal: () => findNodesForKeywordInternal,
-	findNodesForProperty: () => findNodesForProperty,
-	getActionAtElement: () => getActionAtElement,
-	getActionType: () => getActionType,
-	getAllReachableRules: () => getAllReachableRules,
-	getAllRulesUsedForCrossReferences: () => getAllRulesUsedForCrossReferences,
-	getCrossReferenceTerminal: () => getCrossReferenceTerminal,
-	getEntryRule: () => getEntryRule,
-	getExplicitRuleType: () => getExplicitRuleType,
-	getHiddenRules: () => getHiddenRules,
-	getRuleType: () => getRuleType,
-	getRuleTypeName: () => getRuleTypeName,
-	getTypeName: () => getTypeName,
-	isArrayCardinality: () => isArrayCardinality,
-	isArrayOperator: () => isArrayOperator,
-	isCommentTerminal: () => isCommentTerminal,
-	isDataType: () => isDataType,
-	isDataTypeRule: () => isDataTypeRule,
-	isOptionalCardinality: () => isOptionalCardinality,
-	terminalRegex: () => terminalRegex
-}, 1);
-function getEntryRule(b) {
-	return b.rules.find((b) => isParserRule(b) && b.entry);
-}
-function getHiddenRules(b) {
-	return b.rules.filter((b) => isTerminalRule(b) && b.hidden);
-}
-function getAllReachableRules(b, Y) {
-	let X = /* @__PURE__ */ new Set(), Z = getEntryRule(b);
-	if (!Z) return new Set(b.rules);
-	let Q = [Z].concat(getHiddenRules(b));
-	for (let b of Q) ruleDfs(b, X, Y);
-	let $ = /* @__PURE__ */ new Set();
-	for (let Y of b.rules) (X.has(Y.name) || isTerminalRule(Y) && Y.hidden) && $.add(Y);
-	return $;
-}
-function ruleDfs(b, Y, X) {
-	Y.add(b.name), streamAllContents(b).forEach((b) => {
-		if (isRuleCall(b) || X && isTerminalRuleCall(b)) {
-			let Z = b.rule.ref;
-			Z && !Y.has(Z.name) && ruleDfs(Z, Y, X);
-		}
-	});
-}
-function getAllRulesUsedForCrossReferences(b) {
-	let Y = /* @__PURE__ */ new Set();
-	return streamAllContents(b).forEach((b) => {
-		isCrossReference(b) && (isParserRule(b.type.ref) && Y.add(b.type.ref), isInferredType(b.type.ref) && isParserRule(b.type.ref.$container) && Y.add(b.type.ref.$container));
-	}), Y;
-}
-function getCrossReferenceTerminal(b) {
-	if (b.terminal) return b.terminal;
-	if (b.type.ref) return findNameAssignment(b.type.ref)?.terminal;
-}
-function isCommentTerminal(b) {
-	return b.hidden && !isWhitespace(terminalRegex(b));
-}
-function findNodesForProperty(b, Y) {
-	return !b || !Y ? [] : findNodesForPropertyInternal(b, Y, b.astNode, !0);
-}
-function findNodeForProperty(b, Y, X) {
-	if (!b || !Y) return;
-	let Z = findNodesForPropertyInternal(b, Y, b.astNode, !0);
-	if (Z.length !== 0) return X = X === void 0 ? 0 : Math.max(0, Math.min(X, Z.length - 1)), Z[X];
-}
-function findNodesForPropertyInternal(b, Z, Q, $) {
-	if (!$) {
-		let Y = getContainerOfType(b.grammarSource, isAssignment);
-		if (Y && Y.feature === Z) return [b];
-	}
-	return isCompositeCstNode(b) && b.astNode === Q ? b.content.flatMap((b) => findNodesForPropertyInternal(b, Z, Q, !1)) : [];
-}
-function findNodesForKeyword(b, Y) {
-	return b ? findNodesForKeywordInternal(b, Y, b?.astNode) : [];
-}
-function findNodeForKeyword(b, Y, X) {
-	if (!b) return;
-	let Z = findNodesForKeywordInternal(b, Y, b?.astNode);
-	if (Z.length !== 0) return X = X === void 0 ? 0 : Math.max(0, Math.min(X, Z.length - 1)), Z[X];
-}
-function findNodesForKeywordInternal(b, Y, X) {
-	if (b.astNode !== X) return [];
-	if (isKeyword(b.grammarSource) && b.grammarSource.value === Y) return [b];
-	let Z = streamCst(b).iterator(), Q, $ = [];
-	do
-		if (Q = Z.next(), !Q.done) {
-			let b = Q.value;
-			b.astNode === X ? isKeyword(b.grammarSource) && b.grammarSource.value === Y && $.push(b) : Z.prune();
-		}
-	while (!Q.done);
-	return $;
-}
-function findAssignment(b) {
-	let Y = b.astNode;
-	for (; Y === b.container?.astNode;) {
-		let Y = getContainerOfType(b.grammarSource, isAssignment);
-		if (Y) return Y;
-		b = b.container;
-	}
-}
-function findNameAssignment(b) {
-	let Y = b;
-	return isInferredType(Y) && (isAction(Y.$container) ? Y = Y.$container.$container : isAbstractParserRule(Y.$container) ? Y = Y.$container : assertUnreachable(Y.$container)), findNameAssignmentInternal(b, Y, /* @__PURE__ */ new Map());
-}
-function findNameAssignmentInternal(b, Y, Q) {
-	function $(Y, Z) {
-		let $;
-		return getContainerOfType(Y, isAssignment) || ($ = findNameAssignmentInternal(Z, Z, Q)), Q.set(b, $), $;
-	}
-	if (Q.has(b)) return Q.get(b);
-	Q.set(b, void 0);
-	for (let X of streamAllContents(Y)) if (isAssignment(X) && X.feature.toLowerCase() === "name") return Q.set(b, X), X;
-	else if (isRuleCall(X) && isParserRule(X.rule.ref)) return $(X, X.rule.ref);
-	else if (isSimpleType(X) && X.typeRef?.ref) return $(X, X.typeRef.ref);
-}
-function getActionAtElement(b) {
-	let Y = b.$container;
-	if (isGroup(Y)) {
-		let X = Y.elements, Q = X.indexOf(b);
-		for (let b = Q - 1; b >= 0; b--) {
-			let Y = X[b];
-			if (isAction(Y)) return Y;
-			{
-				let Y = streamAllContents(X[b]).find(isAction);
-				if (Y) return Y;
-			}
-		}
-	}
-	if (isAbstractElement(Y)) return getActionAtElement(Y);
-}
-function isOptionalCardinality(b, Y) {
-	return b === "?" || b === "*" || isGroup(Y) && !!Y.guardCondition;
-}
-function isArrayCardinality(b) {
-	return b === "*" || b === "+";
-}
-function isArrayOperator(b) {
-	return b === "+=";
-}
-function isDataTypeRule(b) {
-	return isDataTypeRuleInternal(b, /* @__PURE__ */ new Set());
-}
-function isDataTypeRuleInternal(b, Y) {
-	if (Y.has(b)) return !0;
-	Y.add(b);
-	for (let X of streamAllContents(b)) if (isRuleCall(X)) {
-		if (!X.rule.ref || isParserRule(X.rule.ref) && !isDataTypeRuleInternal(X.rule.ref, Y) || isInfixRule(X.rule.ref)) return !1;
-	} else if (isAssignment(X)) return !1;
-	else if (isAction(X)) return !1;
-	return !!b.definition;
-}
-function isDataType(b) {
-	return isDataTypeInternal(b.type, /* @__PURE__ */ new Set());
-}
-function isDataTypeInternal(b, Y) {
-	if (Y.has(b)) return !0;
-	if (Y.add(b), isArrayType(b) || isReferenceType(b)) return !1;
-	if (isUnionType(b)) return b.types.every((b) => isDataTypeInternal(b, Y));
-	if (isSimpleType(b)) {
-		if (b.primitiveType !== void 0 || b.stringType !== void 0) return !0;
-		if (b.typeRef !== void 0) {
-			let X = b.typeRef.ref;
-			return isType(X) ? isDataTypeInternal(X.type, Y) : !1;
-		} else return !1;
-	} else return !1;
-}
-function getExplicitRuleType(b) {
-	if (!isTerminalRule(b)) {
-		if (b.inferredType) return b.inferredType.name;
-		if (b.dataType) return b.dataType;
-		if (b.returnType) {
-			let Y = b.returnType.ref;
-			if (Y) return Y.name;
-		}
-	}
-}
-function getTypeName(b) {
-	if (isAbstractParserRule(b)) return isParserRule(b) && isDataTypeRule(b) ? b.name : getExplicitRuleType(b) ?? b.name;
-	if (isInterface(b) || isType(b) || isReturnType(b)) return b.name;
-	if (isAction(b)) {
-		let Y = getActionType(b);
-		if (Y) return Y;
-	} else if (isInferredType(b)) return b.name;
-	throw Error("Cannot get name of Unknown Type");
-}
-function getActionType(b) {
-	if (b.inferredType) return b.inferredType.name;
-	if (b.type?.ref) return getTypeName(b.type.ref);
-}
-function getRuleTypeName(b) {
-	return isTerminalRule(b) ? b.type?.name ?? "string" : isParserRule(b) && isDataTypeRule(b) ? b.name : getExplicitRuleType(b) ?? b.name;
-}
-function getRuleType(b) {
-	return isTerminalRule(b) ? b.type?.name ?? "string" : getExplicitRuleType(b) ?? b.name;
-}
-function terminalRegex(b) {
-	let Y = {
-		s: !1,
-		i: !1,
-		u: !1
-	}, X = abstractElementToRegex(b.definition, Y), Z = Object.entries(Y).filter(([, b]) => b).map(([b]) => b).join("");
-	return new RegExp(X, Z);
-}
-var WILDCARD = "[\\s\\S]";
-function abstractElementToRegex(b, Y) {
-	if (isTerminalAlternatives(b)) return terminalAlternativesToRegex(b);
-	if (isTerminalGroup(b)) return terminalGroupToRegex(b);
-	if (isCharacterRange(b)) return characterRangeToRegex(b);
-	if (isTerminalRuleCall(b)) {
-		let Y = b.rule.ref;
-		if (!Y) throw Error("Missing rule reference.");
-		return withCardinality(abstractElementToRegex(Y.definition), {
-			cardinality: b.cardinality,
-			lookahead: b.lookahead,
-			parenthesized: b.parenthesized
-		});
-	} else if (isNegatedToken(b)) return negateTokenToRegex(b);
-	else if (isUntilToken(b)) return untilTokenToRegex(b);
-	else if (isRegexToken(b)) {
-		let X = b.regex.lastIndexOf("/"), Z = b.regex.substring(1, X), Q = b.regex.substring(X + 1);
-		return Y && (Y.i = Q.includes("i"), Y.s = Q.includes("s"), Y.u = Q.includes("u")), withCardinality(Z, {
-			cardinality: b.cardinality,
-			lookahead: b.lookahead,
-			parenthesized: b.parenthesized,
-			wrap: !1
-		});
-	} else if (isWildcard(b)) return withCardinality(WILDCARD, {
-		cardinality: b.cardinality,
-		lookahead: b.lookahead,
-		parenthesized: b.parenthesized
-	});
-	else throw Error(`Invalid terminal element: ${b?.$type}, ${b?.$cstNode?.text}`);
-}
-function terminalAlternativesToRegex(b) {
-	return withCardinality(b.elements.map((b) => abstractElementToRegex(b)).join("|"), {
-		cardinality: b.cardinality,
-		lookahead: b.lookahead,
-		parenthesized: b.parenthesized,
-		wrap: !1
-	});
-}
-function terminalGroupToRegex(b) {
-	return withCardinality(b.elements.map((b) => abstractElementToRegex(b)).join(""), {
-		cardinality: b.cardinality,
-		lookahead: b.lookahead,
-		parenthesized: b.parenthesized,
-		wrap: !1
-	});
-}
-function untilTokenToRegex(b) {
-	return withCardinality(`${WILDCARD}*?${abstractElementToRegex(b.terminal)}`, {
-		cardinality: b.cardinality,
-		lookahead: b.lookahead,
-		parenthesized: b.parenthesized
-	});
-}
-function negateTokenToRegex(b) {
-	return withCardinality(`(?!${abstractElementToRegex(b.terminal)})${WILDCARD}*?`, {
-		cardinality: b.cardinality,
-		lookahead: b.lookahead,
-		parenthesized: b.parenthesized
-	});
-}
-function characterRangeToRegex(b) {
-	return b.right ? withCardinality(`[${keywordToRegex(b.left)}-${keywordToRegex(b.right)}]`, {
-		cardinality: b.cardinality,
-		lookahead: b.lookahead,
-		parenthesized: b.parenthesized,
-		wrap: !1
-	}) : withCardinality(keywordToRegex(b.left), {
-		cardinality: b.cardinality,
-		lookahead: b.lookahead,
-		parenthesized: b.parenthesized,
-		wrap: !1
-	});
-}
-function keywordToRegex(b) {
-	return escapeRegExp(b.value);
-}
-function withCardinality(b, Y) {
-	return (Y.parenthesized || Y.lookahead || Y.wrap !== !1) && (b = `(${Y.lookahead ?? (Y.parenthesized ? "" : "?:")}${b})`), Y.cardinality ? `${b}${Y.cardinality}` : b;
-}
-export { findAssignment, findNameAssignment, findNodeForKeyword, findNodeForProperty, findNodesForProperty, getAllReachableRules, getCrossReferenceTerminal, getRuleType, getTypeName, grammar_utils_exports, isCommentTerminal, isDataTypeRule, terminalRegex };

package/dist/node_modules/langium/lib/utils/index.js

@@ -1,53 +0,0 @@
-import { __export, __reExport } from "../../../../_virtual/rolldown_runtime.js";
-import { DONE_RESULT, EMPTY_STREAM, Reduction, StreamImpl, TreeStreamImpl, stream } from "./stream.js";
-import { ast_utils_exports } from "./ast-utils.js";
-import { cst_utils_exports } from "./cst-utils.js";
-import { ErrorWithLocation, assertCondition, assertUnreachable } from "./errors.js";
-import { regexp_utils_exports } from "./regexp-utils.js";
-import { grammar_utils_exports } from "./grammar-utils.js";
-import { cancellation_exports } from "./cancellation.js";
-import { Deferred, OperationCancelled, delayNextTick, interruptAndCheck, isOperationCancelled, setInterruptionPeriod, startCancelableOperation } from "./promise-utils.js";
-import { URI } from "../../../vscode-uri/lib/esm/index.js";
-import { UriTrie, UriUtils } from "./uri-utils.js";
-import { BiMap, MultiMap } from "./collections.js";
-import { ContextCache, DisposableCache, DocumentCache, SimpleCache, WorkspaceCache } from "./caching.js";
-import { event_exports } from "./event.js";
-import { Disposable } from "./disposable.js";
-import { loadGrammarFromJson } from "./grammar-loader.js";
-var utils_exports = /* @__PURE__ */ __export({
-	AstUtils: () => ast_utils_exports,
-	BiMap: () => BiMap,
-	Cancellation: () => cancellation_exports,
-	ContextCache: () => ContextCache,
-	CstUtils: () => cst_utils_exports,
-	DONE_RESULT: () => DONE_RESULT,
-	Deferred: () => Deferred,
-	Disposable: () => Disposable,
-	DisposableCache: () => DisposableCache,
-	DocumentCache: () => DocumentCache,
-	EMPTY_STREAM: () => EMPTY_STREAM,
-	ErrorWithLocation: () => ErrorWithLocation,
-	GrammarUtils: () => grammar_utils_exports,
-	MultiMap: () => MultiMap,
-	OperationCancelled: () => OperationCancelled,
-	Reduction: () => Reduction,
-	RegExpUtils: () => regexp_utils_exports,
-	SimpleCache: () => SimpleCache,
-	StreamImpl: () => StreamImpl,
-	TreeStreamImpl: () => TreeStreamImpl,
-	URI: () => URI,
-	UriTrie: () => UriTrie,
-	UriUtils: () => UriUtils,
-	WorkspaceCache: () => WorkspaceCache,
-	assertCondition: () => assertCondition,
-	assertUnreachable: () => assertUnreachable,
-	delayNextTick: () => delayNextTick,
-	interruptAndCheck: () => interruptAndCheck,
-	isOperationCancelled: () => isOperationCancelled,
-	loadGrammarFromJson: () => loadGrammarFromJson,
-	setInterruptionPeriod: () => setInterruptionPeriod,
-	startCancelableOperation: () => startCancelableOperation,
-	stream: () => stream
-}, 1);
-__reExport(utils_exports, event_exports, void 0, 1);
-export { utils_exports };

package/dist/node_modules/langium/lib/utils/promise-utils.js

@@ -1,30 +0,0 @@
-import { cancellation_exports } from "./cancellation.js";
-function delayNextTick() {
-	return new Promise((e) => {
-		typeof setImmediate > "u" ? setTimeout(e, 0) : setImmediate(e);
-	});
-}
-var lastTick = 0, globalInterruptionPeriod = 10;
-function startCancelableOperation() {
-	return lastTick = performance.now(), new cancellation_exports.CancellationTokenSource();
-}
-function setInterruptionPeriod(e) {
-	globalInterruptionPeriod = e;
-}
-const OperationCancelled = Symbol("OperationCancelled");
-function isOperationCancelled(e) {
-	return e === OperationCancelled;
-}
-async function interruptAndCheck(c) {
-	if (c === cancellation_exports.CancellationToken.None) return;
-	let l = performance.now();
-	if (l - lastTick >= globalInterruptionPeriod && (lastTick = l, await delayNextTick(), lastTick = performance.now()), c.isCancellationRequested) throw OperationCancelled;
-}
-var Deferred = class {
-	constructor() {
-		this.promise = new Promise((e, s) => {
-			this.resolve = (s) => (e(s), this), this.reject = (e) => (s(e), this);
-		});
-	}
-};
-export { Deferred, OperationCancelled, delayNextTick, interruptAndCheck, isOperationCancelled, setInterruptionPeriod, startCancelableOperation };

package/dist/node_modules/langium/lib/utils/regexp-utils.js

@@ -1,167 +0,0 @@
-import { __export } from "../../../../_virtual/rolldown_runtime.js";
-import { RegExpParser } from "../../../@chevrotain/regexp-to-ast/lib/src/regexp-parser.js";
-import { BaseRegExpVisitor } from "../../../@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js";
-import "../../../@chevrotain/regexp-to-ast/lib/src/api.js";
-var regexp_utils_exports = /* @__PURE__ */ __export({
-	NEWLINE_REGEXP: () => NEWLINE_REGEXP,
-	escapeRegExp: () => escapeRegExp,
-	getTerminalParts: () => getTerminalParts,
-	isMultilineComment: () => isMultilineComment,
-	isWhitespace: () => isWhitespace,
-	partialMatches: () => partialMatches,
-	partialRegExp: () => partialRegExp,
-	whitespaceCharacters: () => whitespaceCharacters
-}, 1);
-const NEWLINE_REGEXP = /\r?\n/gm;
-var regexpParser = new RegExpParser(), visitor = new class extends BaseRegExpVisitor {
-	constructor() {
-		super(...arguments), this.isStarting = !0, this.endRegexpStack = [], this.multiline = !1;
-	}
-	get endRegex() {
-		return this.endRegexpStack.join("");
-	}
-	reset(e) {
-		this.multiline = !1, this.regex = e, this.startRegexp = "", this.isStarting = !0, this.endRegexpStack = [];
-	}
-	visitGroup(e) {
-		e.quantifier && (this.isStarting = !1, this.endRegexpStack = []);
-	}
-	visitCharacter(e) {
-		let s = String.fromCharCode(e.value);
-		if (!this.multiline && s === "\n" && (this.multiline = !0), e.quantifier) this.isStarting = !1, this.endRegexpStack = [];
-		else {
-			let e = escapeRegExp(s);
-			this.endRegexpStack.push(e), this.isStarting && (this.startRegexp += e);
-		}
-	}
-	visitSet(e) {
-		if (!this.multiline) {
-			let s = this.regex.substring(e.loc.begin, e.loc.end), c = new RegExp(s);
-			this.multiline = !!"\n".match(c);
-		}
-		if (e.quantifier) this.isStarting = !1, this.endRegexpStack = [];
-		else {
-			let s = this.regex.substring(e.loc.begin, e.loc.end);
-			this.endRegexpStack.push(s), this.isStarting && (this.startRegexp += s);
-		}
-	}
-	visitChildren(e) {
-		e.type === "Group" && e.quantifier || super.visitChildren(e);
-	}
-}();
-function getTerminalParts(e) {
-	try {
-		typeof e != "string" && (e = e.source), e = `/${e}/`;
-		let s = regexpParser.pattern(e), c = [];
-		for (let l of s.value.value) visitor.reset(e), visitor.visit(l), c.push({
-			start: visitor.startRegexp,
-			end: visitor.endRegex
-		});
-		return c;
-	} catch {
-		return [];
-	}
-}
-function isMultilineComment(e) {
-	try {
-		return typeof e == "string" && (e = new RegExp(e)), e = e.toString(), visitor.reset(e), visitor.visit(regexpParser.pattern(e)), visitor.multiline;
-	} catch {
-		return !1;
-	}
-}
-const whitespaceCharacters = "\f\n\r	\v \xA0            \u2028\u2029  　".split("");
-function isWhitespace(e) {
-	let s = typeof e == "string" ? new RegExp(e) : e;
-	return whitespaceCharacters.some((e) => s.test(e));
-}
-function escapeRegExp(e) {
-	return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function partialMatches(e, s) {
-	let c = partialRegExp(e), l = s.match(c);
-	return !!l && l[0].length > 0;
-}
-function partialRegExp(e) {
-	typeof e == "string" && (e = new RegExp(e));
-	let s = e, c = e.source, l = 0;
-	function u() {
-		let e = "", d;
-		function f(s) {
-			e += c.substr(l, s), l += s;
-		}
-		function p(s) {
-			e += "(?:" + c.substr(l, s) + "|$)", l += s;
-		}
-		for (; l < c.length;) switch (c[l]) {
-			case "\\":
-				switch (c[l + 1]) {
-					case "c":
-						p(3);
-						break;
-					case "x":
-						p(4);
-						break;
-					case "u":
-						s.unicode ? c[l + 2] === "{" ? p(c.indexOf("}", l) - l + 1) : p(6) : p(2);
-						break;
-					case "p":
-					case "P":
-						s.unicode ? p(c.indexOf("}", l) - l + 1) : p(2);
-						break;
-					case "k":
-						p(c.indexOf(">", l) - l + 1);
-						break;
-					default:
-						p(2);
-						break;
-				}
-				break;
-			case "[":
-				d = /\[(?:\\.|.)*?\]/g, d.lastIndex = l, d = d.exec(c) || [], p(d[0].length);
-				break;
-			case "|":
-			case "^":
-			case "$":
-			case "*":
-			case "+":
-			case "?":
-				f(1);
-				break;
-			case "{":
-				d = /\{\d+,?\d*\}/g, d.lastIndex = l, d = d.exec(c), d ? f(d[0].length) : p(1);
-				break;
-			case "(":
-				if (c[l + 1] === "?") switch (c[l + 2]) {
-					case ":":
-						e += "(?:", l += 3, e += u() + "|$)";
-						break;
-					case "=":
-						e += "(?=", l += 3, e += u() + ")";
-						break;
-					case "!":
-						d = l, l += 3, u(), e += c.substr(d, l - d);
-						break;
-					case "<":
-						switch (c[l + 3]) {
-							case "=":
-							case "!":
-								d = l, l += 4, u(), e += c.substr(d, l - d);
-								break;
-							default:
-								f(c.indexOf(">", l) - l + 1), e += u() + "|$)";
-								break;
-						}
-						break;
-				}
-				else f(1), e += u() + "|$)";
-				break;
-			case ")": return ++l, e;
-			default:
-				p(1);
-				break;
-		}
-		return e;
-	}
-	return new RegExp(u(), e.flags);
-}
-export { NEWLINE_REGEXP, escapeRegExp, isMultilineComment, isWhitespace, partialMatches, regexp_utils_exports };