@loopstack/loopstack-studio 0.20.2 → 0.21.0-rc.0

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

@@ -0,0 +1,296 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,30 @@
+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

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