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

package/dist/node_modules/chevrotain/lib/src/scan/lexer_public.js

@@ -0,0 +1,275 @@
+import isArray_default from "../../../../lodash-es/isArray.js";
+import identity_default from "../../../../lodash-es/identity.js";
+import isEmpty_default from "../../../../lodash-es/isEmpty.js";
+import noop_default from "../../../../lodash-es/noop.js";
+import keys_default from "../../../../lodash-es/keys.js";
+import assign_default from "../../../../lodash-es/assign.js";
+import clone_default from "../../../../lodash-es/clone.js";
+import last_default from "../../../../lodash-es/last.js";
+import forEach_default from "../../../../lodash-es/forEach.js";
+import map_default from "../../../../lodash-es/map.js";
+import isUndefined_default from "../../../../lodash-es/isUndefined.js";
+import reduce_default from "../../../../lodash-es/reduce.js";
+import reject_default from "../../../../lodash-es/reject.js";
+import { PRINT_WARNING } from "../../../../@chevrotain/utils/lib/src/print.js";
+import { timer } from "../../../../@chevrotain/utils/lib/src/timer.js";
+import { toFastProperties } from "../../../../@chevrotain/utils/lib/src/to-fast-properties.js";
+import { clearRegExpParserCache } from "./reg_exp_parser.js";
+import { DEFAULT_MODE, LineTerminatorOptimizedTester, SUPPORT_STICKY, analyzeTokenTypes, charCodeToOptimizedIndex, cloneEmptyGroups, performRuntimeChecks, performWarningRuntimeChecks, validatePatterns } from "./lexer.js";
+import { augmentTokenTypes } from "./tokens.js";
+import { defaultLexerErrorProvider } from "./lexer_errors_public.js";
+var LexerDefinitionErrorType;
+(function(e) {
+	e[e.MISSING_PATTERN = 0] = "MISSING_PATTERN", e[e.INVALID_PATTERN = 1] = "INVALID_PATTERN", e[e.EOI_ANCHOR_FOUND = 2] = "EOI_ANCHOR_FOUND", e[e.UNSUPPORTED_FLAGS_FOUND = 3] = "UNSUPPORTED_FLAGS_FOUND", e[e.DUPLICATE_PATTERNS_FOUND = 4] = "DUPLICATE_PATTERNS_FOUND", e[e.INVALID_GROUP_TYPE_FOUND = 5] = "INVALID_GROUP_TYPE_FOUND", e[e.PUSH_MODE_DOES_NOT_EXIST = 6] = "PUSH_MODE_DOES_NOT_EXIST", e[e.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE = 7] = "MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE", e[e.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY = 8] = "MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY", e[e.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST = 9] = "MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST", e[e.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED = 10] = "LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED", e[e.SOI_ANCHOR_FOUND = 11] = "SOI_ANCHOR_FOUND", e[e.EMPTY_MATCH_PATTERN = 12] = "EMPTY_MATCH_PATTERN", e[e.NO_LINE_BREAKS_FLAGS = 13] = "NO_LINE_BREAKS_FLAGS", e[e.UNREACHABLE_PATTERN = 14] = "UNREACHABLE_PATTERN", e[e.IDENTIFY_TERMINATOR = 15] = "IDENTIFY_TERMINATOR", e[e.CUSTOM_LINE_BREAK = 16] = "CUSTOM_LINE_BREAK", e[e.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE = 17] = "MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE";
+})(LexerDefinitionErrorType ||= {});
+var DEFAULT_LEXER_CONFIG = {
+	deferDefinitionErrorsHandling: !1,
+	positionTracking: "full",
+	lineTerminatorsPattern: /\n|\r\n?/g,
+	lineTerminatorCharacters: ["\n", "\r"],
+	ensureOptimizations: !1,
+	safeMode: !1,
+	errorMessageProvider: defaultLexerErrorProvider,
+	traceInitPerf: !1,
+	skipValidations: !1,
+	recoveryEnabled: !0
+};
+Object.freeze(DEFAULT_LEXER_CONFIG);
+var Lexer = class {
+	constructor(s, x = DEFAULT_LEXER_CONFIG) {
+		if (this.lexerDefinition = s, this.lexerDefinitionErrors = [], this.lexerDefinitionWarning = [], this.patternIdxToConfig = {}, this.charCodeToPatternIdxToConfig = {}, this.modes = [], this.emptyGroups = {}, this.trackStartLines = !0, this.trackEndLines = !0, this.hasCustom = !1, this.canModeBeOptimized = {}, this.TRACE_INIT = (e, t) => {
+			if (this.traceInitPerf === !0) {
+				this.traceInitIndent++;
+				let n = Array(this.traceInitIndent + 1).join("	");
+				this.traceInitIndent < this.traceInitMaxIdent && console.log(`${n}--> <${e}>`);
+				let { time: r, value: i } = timer(t), a = r > 10 ? console.warn : console.log;
+				return this.traceInitIndent < this.traceInitMaxIdent && a(`${n}<-- <${e}> time: ${r}ms`), this.traceInitIndent--, i;
+			} else return t();
+		}, typeof x == "boolean") throw Error("The second argument to the Lexer constructor is now an ILexerConfig Object.\na boolean 2nd argument is no longer supported");
+		this.config = assign_default({}, DEFAULT_LEXER_CONFIG, x);
+		let S = this.config.traceInitPerf;
+		S === !0 ? (this.traceInitMaxIdent = Infinity, this.traceInitPerf = !0) : typeof S == "number" && (this.traceInitMaxIdent = S, this.traceInitPerf = !0), this.traceInitIndent = -1, this.TRACE_INIT("Lexer Constructor", () => {
+			let m, S = !0;
+			this.TRACE_INIT("Lexer Config handling", () => {
+				if (this.config.lineTerminatorsPattern === DEFAULT_LEXER_CONFIG.lineTerminatorsPattern) this.config.lineTerminatorsPattern = LineTerminatorOptimizedTester;
+				else if (this.config.lineTerminatorCharacters === DEFAULT_LEXER_CONFIG.lineTerminatorCharacters) throw Error("Error: Missing <lineTerminatorCharacters> property on the Lexer config.\n	For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#MISSING_LINE_TERM_CHARS");
+				if (x.safeMode && x.ensureOptimizations) throw Error("\"safeMode\" and \"ensureOptimizations\" flags are mutually exclusive.");
+				this.trackStartLines = /full|onlyStart/i.test(this.config.positionTracking), this.trackEndLines = /full/i.test(this.config.positionTracking), isArray_default(s) ? m = {
+					modes: { defaultMode: clone_default(s) },
+					defaultMode: DEFAULT_MODE
+				} : (S = !1, m = clone_default(s));
+			}), this.config.skipValidations === !1 && (this.TRACE_INIT("performRuntimeChecks", () => {
+				this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(performRuntimeChecks(m, this.trackStartLines, this.config.lineTerminatorCharacters));
+			}), this.TRACE_INIT("performWarningRuntimeChecks", () => {
+				this.lexerDefinitionWarning = this.lexerDefinitionWarning.concat(performWarningRuntimeChecks(m, this.trackStartLines, this.config.lineTerminatorCharacters));
+			})), m.modes = m.modes ? m.modes : {}, forEach_default(m.modes, (e, t) => {
+				m.modes[t] = reject_default(e, (e) => isUndefined_default(e));
+			});
+			let D = keys_default(m.modes);
+			if (forEach_default(m.modes, (e, t) => {
+				this.TRACE_INIT(`Mode: <${t}> processing`, () => {
+					if (this.modes.push(t), this.config.skipValidations === !1 && this.TRACE_INIT("validatePatterns", () => {
+						this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(validatePatterns(e, D));
+					}), isEmpty_default(this.lexerDefinitionErrors)) {
+						augmentTokenTypes(e);
+						let n;
+						this.TRACE_INIT("analyzeTokenTypes", () => {
+							n = analyzeTokenTypes(e, {
+								lineTerminatorCharacters: this.config.lineTerminatorCharacters,
+								positionTracking: x.positionTracking,
+								ensureOptimizations: x.ensureOptimizations,
+								safeMode: x.safeMode,
+								tracer: this.TRACE_INIT
+							});
+						}), this.patternIdxToConfig[t] = n.patternIdxToConfig, this.charCodeToPatternIdxToConfig[t] = n.charCodeToPatternIdxToConfig, this.emptyGroups = assign_default({}, this.emptyGroups, n.emptyGroups), this.hasCustom = n.hasCustom || this.hasCustom, this.canModeBeOptimized[t] = n.canBeOptimized;
+					}
+				});
+			}), this.defaultMode = m.defaultMode, !isEmpty_default(this.lexerDefinitionErrors) && !this.config.deferDefinitionErrorsHandling) {
+				let e = map_default(this.lexerDefinitionErrors, (e) => e.message).join("-----------------------\n");
+				throw Error("Errors detected in definition of Lexer:\n" + e);
+			}
+			forEach_default(this.lexerDefinitionWarning, (e) => {
+				PRINT_WARNING(e.message);
+			}), this.TRACE_INIT("Choosing sub-methods implementations", () => {
+				if (SUPPORT_STICKY ? (this.chopInput = identity_default, this.match = this.matchWithTest) : (this.updateLastIndex = noop_default, this.match = this.matchWithExec), S && (this.handleModes = noop_default), this.trackStartLines === !1 && (this.computeNewColumn = identity_default), this.trackEndLines === !1 && (this.updateTokenEndLineColumnLocation = noop_default), /full/i.test(this.config.positionTracking)) this.createTokenInstance = this.createFullToken;
+				else if (/onlyStart/i.test(this.config.positionTracking)) this.createTokenInstance = this.createStartOnlyToken;
+				else if (/onlyOffset/i.test(this.config.positionTracking)) this.createTokenInstance = this.createOffsetOnlyToken;
+				else throw Error(`Invalid <positionTracking> config option: "${this.config.positionTracking}"`);
+				this.hasCustom ? (this.addToken = this.addTokenUsingPush, this.handlePayload = this.handlePayloadWithCustom) : (this.addToken = this.addTokenUsingMemberAccess, this.handlePayload = this.handlePayloadNoCustom);
+			}), this.TRACE_INIT("Failed Optimization Warnings", () => {
+				let e = reduce_default(this.canModeBeOptimized, (e, t, n) => (t === !1 && e.push(n), e), []);
+				if (x.ensureOptimizations && !isEmpty_default(e)) throw Error(`Lexer Modes: < ${e.join(", ")} > cannot be optimized.\n	 Disable the "ensureOptimizations" lexer config flag to silently ignore this and run the lexer in an un-optimized mode.
+	 Or inspect the console log for details on how to resolve these issues.`);
+			}), this.TRACE_INIT("clearRegExpParserCache", () => {
+				clearRegExpParserCache();
+			}), this.TRACE_INIT("toFastProperties", () => {
+				toFastProperties(this);
+			});
+		});
+	}
+	tokenize(e, t = this.defaultMode) {
+		if (!isEmpty_default(this.lexerDefinitionErrors)) {
+			let e = map_default(this.lexerDefinitionErrors, (e) => e.message).join("-----------------------\n");
+			throw Error("Unable to Tokenize because Errors detected in definition of Lexer:\n" + e);
+		}
+		return this.tokenizeInternal(e, t);
+	}
+	tokenizeInternal(e, t) {
+		let n, r, i, a, o, c, l, u, d, f, p, m, h, g, _, v = e, y = v.length, b = 0, C = 0, w = this.hasCustom ? 0 : Math.floor(e.length / 10), T = Array(w), E = [], D = this.trackStartLines ? 1 : void 0, O = this.trackStartLines ? 1 : void 0, k = cloneEmptyGroups(this.emptyGroups), A = this.trackStartLines, j = this.config.lineTerminatorsPattern, M = 0, N = [], P = [], F = [], I = [];
+		Object.freeze(I);
+		let L;
+		function R() {
+			return N;
+		}
+		function z(e) {
+			let t = charCodeToOptimizedIndex(e), n = P[t];
+			return n === void 0 ? I : n;
+		}
+		let B = (e) => {
+			if (F.length === 1 && e.tokenType.PUSH_MODE === void 0) {
+				let t = this.config.errorMessageProvider.buildUnableToPopLexerModeMessage(e);
+				E.push({
+					offset: e.startOffset,
+					line: e.startLine,
+					column: e.startColumn,
+					length: e.image.length,
+					message: t
+				});
+			} else {
+				F.pop();
+				let e = last_default(F);
+				N = this.patternIdxToConfig[e], P = this.charCodeToPatternIdxToConfig[e], M = N.length;
+				let t = this.canModeBeOptimized[e] && this.config.safeMode === !1;
+				L = P && t ? z : R;
+			}
+		};
+		function V(e) {
+			F.push(e), P = this.charCodeToPatternIdxToConfig[e], N = this.patternIdxToConfig[e], M = N.length, M = N.length;
+			let t = this.canModeBeOptimized[e] && this.config.safeMode === !1;
+			L = P && t ? z : R;
+		}
+		V.call(this, t);
+		let H, U = this.config.recoveryEnabled;
+		for (; b < y;) {
+			c = null;
+			let t = v.charCodeAt(b), x = L(t), S = x.length;
+			for (n = 0; n < S; n++) {
+				H = x[n];
+				let r = H.pattern;
+				l = null;
+				let s = H.short;
+				if (s === !1 ? H.isCustom === !0 ? (_ = r.exec(v, b, T, k), _ === null ? c = null : (c = _[0], _.payload !== void 0 && (l = _.payload))) : (this.updateLastIndex(r, b), c = this.match(r, e, b)) : t === s && (c = r), c !== null) {
+					if (o = H.longerAlt, o !== void 0) {
+						let t = o.length;
+						for (i = 0; i < t; i++) {
+							let t = N[o[i]], n = t.pattern;
+							if (u = null, t.isCustom === !0 ? (_ = n.exec(v, b, T, k), _ === null ? a = null : (a = _[0], _.payload !== void 0 && (u = _.payload))) : (this.updateLastIndex(n, b), a = this.match(n, e, b)), a && a.length > c.length) {
+								c = a, l = u, H = t;
+								break;
+							}
+						}
+					}
+					break;
+				}
+			}
+			if (c !== null) {
+				if (d = c.length, f = H.group, f !== void 0 && (p = H.tokenTypeIdx, m = this.createTokenInstance(c, b, p, H.tokenType, D, O, d), this.handlePayload(m, l), f === !1 ? C = this.addToken(T, C, m) : k[f].push(m)), e = this.chopInput(e, d), b += d, O = this.computeNewColumn(O, d), A === !0 && H.canLineTerminator === !0) {
+					let e = 0, t, n;
+					j.lastIndex = 0;
+					do
+						t = j.test(c), t === !0 && (n = j.lastIndex - 1, e++);
+					while (t === !0);
+					e !== 0 && (D += e, O = d - n, this.updateTokenEndLineColumnLocation(m, f, n, e, D, O, d));
+				}
+				this.handleModes(H, B, V, m);
+			} else {
+				let t = b, n = D, i = O, a = U === !1;
+				for (; a === !1 && b < y;) for (e = this.chopInput(e, 1), b++, r = 0; r < M; r++) {
+					let t = N[r], n = t.pattern, i = t.short;
+					if (i === !1 ? t.isCustom === !0 ? a = n.exec(v, b, T, k) !== null : (this.updateLastIndex(n, b), a = n.exec(e) !== null) : v.charCodeAt(b) === i && (a = !0), a === !0) break;
+				}
+				if (h = b - t, O = this.computeNewColumn(O, h), g = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(v, t, h, n, i, last_default(F)), E.push({
+					offset: t,
+					line: n,
+					column: i,
+					length: h,
+					message: g
+				}), U === !1) break;
+			}
+		}
+		return this.hasCustom || (T.length = C), {
+			tokens: T,
+			groups: k,
+			errors: E
+		};
+	}
+	handleModes(e, t, n, r) {
+		if (e.pop === !0) {
+			let i = e.push;
+			t(r), i !== void 0 && n.call(this, i);
+		} else e.push !== void 0 && n.call(this, e.push);
+	}
+	chopInput(e, t) {
+		return e.substring(t);
+	}
+	updateLastIndex(e, t) {
+		e.lastIndex = t;
+	}
+	updateTokenEndLineColumnLocation(e, t, n, r, i, a, o) {
+		let s, c;
+		t !== void 0 && (s = n === o - 1, c = s ? -1 : 0, r === 1 && s === !0 || (e.endLine = i + c, e.endColumn = a - 1 + -c));
+	}
+	computeNewColumn(e, t) {
+		return e + t;
+	}
+	createOffsetOnlyToken(e, t, n, r) {
+		return {
+			image: e,
+			startOffset: t,
+			tokenTypeIdx: n,
+			tokenType: r
+		};
+	}
+	createStartOnlyToken(e, t, n, r, i, a) {
+		return {
+			image: e,
+			startOffset: t,
+			startLine: i,
+			startColumn: a,
+			tokenTypeIdx: n,
+			tokenType: r
+		};
+	}
+	createFullToken(e, t, n, r, i, a, o) {
+		return {
+			image: e,
+			startOffset: t,
+			endOffset: t + o - 1,
+			startLine: i,
+			endLine: i,
+			startColumn: a,
+			endColumn: a + o - 1,
+			tokenTypeIdx: n,
+			tokenType: r
+		};
+	}
+	addTokenUsingPush(e, t, n) {
+		return e.push(n), t;
+	}
+	addTokenUsingMemberAccess(e, t, n) {
+		return e[t] = n, t++, t;
+	}
+	handlePayloadNoCustom(e, t) {}
+	handlePayloadWithCustom(e, t) {
+		t !== null && (e.payload = t);
+	}
+	matchWithTest(e, t, n) {
+		return e.test(t) === !0 ? t.substring(n, e.lastIndex) : null;
+	}
+	matchWithExec(e, t) {
+		let n = e.exec(t);
+		return n === null ? null : n[0];
+	}
+};
+Lexer.SKIPPED = "This marks a skipped Token pattern, this means each token identified by it will be consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace.", Lexer.NA = /NOT_APPLICABLE/;
+export { Lexer, LexerDefinitionErrorType };

package/dist/node_modules/chevrotain/lib/src/scan/reg_exp.js

@@ -0,0 +1,152 @@
+import isArray_default from "../../../../lodash-es/isArray.js";
+import { BaseRegExpVisitor } from "../../../../@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js";
+import "../../../../@chevrotain/regexp-to-ast/lib/src/api.js";
+import forEach_default from "../../../../lodash-es/forEach.js";
+import every_default from "../../../../lodash-es/every.js";
+import find_default from "../../../../lodash-es/find.js";
+import values_default from "../../../../lodash-es/values.js";
+import includes_default from "../../../../lodash-es/includes.js";
+import { PRINT_ERROR, PRINT_WARNING } from "../../../../@chevrotain/utils/lib/src/print.js";
+import { getRegExpAst } from "./reg_exp_parser.js";
+import { charCodeToOptimizedIndex, minOptimizationVal } from "./lexer.js";
+var complementErrorMessage = "Complement Sets are not supported for first char optimization";
+const failedOptimizationPrefixMsg = "Unable to use \"first char\" lexer optimizations:\n";
+function getOptimizedStartCodesIndices(e, h = !1) {
+	try {
+		let h = getRegExpAst(e);
+		return firstCharOptimizedIndices(h.value, {}, h.flags.ignoreCase);
+	} catch (g) {
+		/* istanbul ignore next */
+		if (g.message === complementErrorMessage) h && PRINT_WARNING(`${failedOptimizationPrefixMsg}\tUnable to optimize: < ${e.toString()} >\n	Complement Sets cannot be automatically optimized.
+	This will disable the lexer's first char optimizations.
+	See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.`);
+		else {
+			let g = "";
+			h && (g = "\n	This will disable the lexer's first char optimizations.\n	See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details."), PRINT_ERROR(`${failedOptimizationPrefixMsg}\n\tFailed parsing: < ${e.toString()} >\n\tUsing the @chevrotain/regexp-to-ast library\n	Please open an issue at: https://github.com/chevrotain/chevrotain/issues` + g);
+		}
+	}
+	return [];
+}
+function firstCharOptimizedIndices(e, h, _) {
+	switch (e.type) {
+		case "Disjunction":
+			for (let g = 0; g < e.value.length; g++) firstCharOptimizedIndices(e.value[g], h, _);
+			break;
+		case "Alternative":
+			let v = e.value;
+			for (let e = 0; e < v.length; e++) {
+				let y = v[e];
+				switch (y.type) {
+					case "EndAnchor":
+					case "GroupBackReference":
+					case "Lookahead":
+					case "NegativeLookahead":
+					case "Lookbehind":
+					case "NegativeLookbehind":
+					case "StartAnchor":
+					case "WordBoundary":
+					case "NonWordBoundary": continue;
+				}
+				let b = y;
+				switch (b.type) {
+					case "Character":
+						addOptimizedIdxToResult(b.value, h, _);
+						break;
+					case "Set":
+						if (b.complement === !0) throw Error(complementErrorMessage);
+						forEach_default(b.value, (e) => {
+							if (typeof e == "number") addOptimizedIdxToResult(e, h, _);
+							else {
+								let g = e;
+								if (_ === !0) for (let e = g.from; e <= g.to; e++) addOptimizedIdxToResult(e, h, _);
+								else {
+									for (let e = g.from; e <= g.to && e < 256; e++) addOptimizedIdxToResult(e, h, _);
+									if (g.to >= 256) {
+										let e = g.from >= 256 ? g.from : 256, _ = g.to, v = charCodeToOptimizedIndex(e), y = charCodeToOptimizedIndex(_);
+										for (let e = v; e <= y; e++) h[e] = e;
+									}
+								}
+							}
+						});
+						break;
+					case "Group":
+						firstCharOptimizedIndices(b.value, h, _);
+						break;
+					default: throw Error("Non Exhaustive Match");
+				}
+				let x = b.quantifier !== void 0 && b.quantifier.atLeast === 0;
+				if (b.type === "Group" && isWholeOptional(b) === !1 || b.type !== "Group" && x === !1) break;
+			}
+			break;
+		default: throw Error("non exhaustive match!");
+	}
+	return values_default(h);
+}
+function addOptimizedIdxToResult(e, h, g) {
+	let _ = charCodeToOptimizedIndex(e);
+	h[_] = _, g === !0 && handleIgnoreCase(e, h);
+}
+function handleIgnoreCase(e, h) {
+	let g = String.fromCharCode(e), _ = g.toUpperCase();
+	/* istanbul ignore else */
+	if (_ !== g) {
+		let e = charCodeToOptimizedIndex(_.charCodeAt(0));
+		h[e] = e;
+	} else {
+		let e = g.toLowerCase();
+		if (e !== g) {
+			let g = charCodeToOptimizedIndex(e.charCodeAt(0));
+			h[g] = g;
+		}
+	}
+}
+function findCode(e, h) {
+	return find_default(e.value, (e) => {
+		if (typeof e == "number") return includes_default(h, e);
+		{
+			let g = e;
+			return find_default(h, (e) => g.from <= e && e <= g.to) !== void 0;
+		}
+	});
+}
+function isWholeOptional(h) {
+	let g = h.quantifier;
+	return g && g.atLeast === 0 ? !0 : h.value ? isArray_default(h.value) ? every_default(h.value, isWholeOptional) : isWholeOptional(h.value) : !1;
+}
+var CharCodeFinder = class extends BaseRegExpVisitor {
+	constructor(e) {
+		super(), this.targetCharCodes = e, this.found = !1;
+	}
+	visitChildren(e) {
+		if (this.found !== !0) {
+			switch (e.type) {
+				case "Lookahead":
+					this.visitLookahead(e);
+					return;
+				case "NegativeLookahead":
+					this.visitNegativeLookahead(e);
+					return;
+				case "Lookbehind":
+					this.visitLookbehind(e);
+					return;
+				case "NegativeLookbehind":
+					this.visitNegativeLookbehind(e);
+					return;
+			}
+			super.visitChildren(e);
+		}
+	}
+	visitCharacter(e) {
+		includes_default(this.targetCharCodes, e.value) && (this.found = !0);
+	}
+	visitSet(e) {
+		e.complement ? findCode(e, this.targetCharCodes) === void 0 && (this.found = !0) : findCode(e, this.targetCharCodes) !== void 0 && (this.found = !0);
+	}
+};
+function canMatchCharCode(e, h) {
+	if (h instanceof RegExp) {
+		let g = getRegExpAst(h), _ = new CharCodeFinder(e);
+		return _.visit(g), _.found;
+	} else return find_default(h, (h) => includes_default(e, h.charCodeAt(0))) !== void 0;
+}
+export { canMatchCharCode, failedOptimizationPrefixMsg, getOptimizedStartCodesIndices };

package/dist/node_modules/chevrotain/lib/src/scan/reg_exp_parser.js

@@ -0,0 +1,15 @@
+import { RegExpParser } from "../../../../@chevrotain/regexp-to-ast/lib/src/regexp-parser.js";
+import "../../../../@chevrotain/regexp-to-ast/lib/src/api.js";
+var regExpAstCache = {}, regExpParser = new RegExpParser();
+function getRegExpAst(e) {
+	let i = e.toString();
+	if (regExpAstCache.hasOwnProperty(i)) return regExpAstCache[i];
+	{
+		let e = regExpParser.pattern(i);
+		return regExpAstCache[i] = e, e;
+	}
+}
+function clearRegExpParserCache() {
+	regExpAstCache = {};
+}
+export { clearRegExpParserCache, getRegExpAst };

package/dist/node_modules/chevrotain/lib/src/scan/tokens.js

@@ -0,0 +1,75 @@
+import isArray_default from "../../../../lodash-es/isArray.js";
+import isEmpty_default from "../../../../lodash-es/isEmpty.js";
+import flatten_default from "../../../../lodash-es/flatten.js";
+import clone_default from "../../../../lodash-es/clone.js";
+import compact_default from "../../../../lodash-es/compact.js";
+import difference_default from "../../../../lodash-es/difference.js";
+import forEach_default from "../../../../lodash-es/forEach.js";
+import map_default from "../../../../lodash-es/map.js";
+import has_default from "../../../../lodash-es/has.js";
+import includes_default from "../../../../lodash-es/includes.js";
+function tokenStructuredMatcher(e, y) {
+	let b = e.tokenTypeIdx;
+	return b === y.tokenTypeIdx ? !0 : y.isParent === !0 && y.categoryMatchesMap[b] === !0;
+}
+function tokenStructuredMatcherNoCategories(e, y) {
+	return e.tokenTypeIdx === y.tokenTypeIdx;
+}
+let tokenShortNameIdx = 1;
+const tokenIdxToClass = {};
+function augmentTokenTypes(e) {
+	let y = expandCategories(e);
+	assignTokenDefaultProps(y), assignCategoriesMapProp(y), assignCategoriesTokensProp(y), forEach_default(y, (e) => {
+		e.isParent = e.categoryMatches.length > 0;
+	});
+}
+function expandCategories(e) {
+	let S = clone_default(e), C = e, w = !0;
+	for (; w;) {
+		C = compact_default(flatten_default(map_default(C, (e) => e.CATEGORIES)));
+		let e = difference_default(C, S);
+		S = S.concat(e), isEmpty_default(e) ? w = !1 : C = e;
+	}
+	return S;
+}
+function assignTokenDefaultProps(y) {
+	forEach_default(y, (y) => {
+		hasShortKeyProperty(y) || (tokenIdxToClass[tokenShortNameIdx] = y, y.tokenTypeIdx = tokenShortNameIdx++), hasCategoriesProperty(y) && !isArray_default(y.CATEGORIES) && (y.CATEGORIES = [y.CATEGORIES]), hasCategoriesProperty(y) || (y.CATEGORIES = []), hasExtendingTokensTypesProperty(y) || (y.categoryMatches = []), hasExtendingTokensTypesMapProperty(y) || (y.categoryMatchesMap = {});
+	});
+}
+function assignCategoriesTokensProp(e) {
+	forEach_default(e, (e) => {
+		e.categoryMatches = [], forEach_default(e.categoryMatchesMap, (y, b) => {
+			e.categoryMatches.push(tokenIdxToClass[b].tokenTypeIdx);
+		});
+	});
+}
+function assignCategoriesMapProp(e) {
+	forEach_default(e, (e) => {
+		singleAssignCategoriesToksMap([], e);
+	});
+}
+function singleAssignCategoriesToksMap(e, y) {
+	forEach_default(e, (e) => {
+		y.categoryMatchesMap[e.tokenTypeIdx] = !0;
+	}), forEach_default(y.CATEGORIES, (b) => {
+		let x = e.concat(y);
+		includes_default(x, b) || singleAssignCategoriesToksMap(x, b);
+	});
+}
+function hasShortKeyProperty(e) {
+	return has_default(e, "tokenTypeIdx");
+}
+function hasCategoriesProperty(e) {
+	return has_default(e, "CATEGORIES");
+}
+function hasExtendingTokensTypesProperty(e) {
+	return has_default(e, "categoryMatches");
+}
+function hasExtendingTokensTypesMapProperty(e) {
+	return has_default(e, "categoryMatchesMap");
+}
+function isTokenType(e) {
+	return has_default(e, "tokenTypeIdx");
+}
+export { augmentTokenTypes, hasShortKeyProperty, isTokenType, tokenStructuredMatcher, tokenStructuredMatcherNoCategories };

package/dist/node_modules/chevrotain/lib/src/scan/tokens_public.js

@@ -0,0 +1,42 @@
+import has_default from "../../../../lodash-es/has.js";
+import isString_default from "../../../../lodash-es/isString.js";
+import isUndefined_default from "../../../../lodash-es/isUndefined.js";
+import { augmentTokenTypes, tokenStructuredMatcher } from "./tokens.js";
+import { Lexer } from "./lexer_public.js";
+function tokenLabel(e) {
+	return hasTokenLabel(e) ? e.LABEL : e.name;
+}
+function hasTokenLabel(e) {
+	return isString_default(e.LABEL) && e.LABEL !== "";
+}
+var PARENT = "parent", CATEGORIES = "categories", LABEL = "label", GROUP = "group", PUSH_MODE = "push_mode", POP_MODE = "pop_mode", LONGER_ALT = "longer_alt", LINE_BREAKS = "line_breaks", START_CHARS_HINT = "start_chars_hint";
+function createToken(e) {
+	return createTokenInternal(e);
+}
+function createTokenInternal(h) {
+	let v = h.pattern, y = {};
+	if (y.name = h.name, isUndefined_default(v) || (y.PATTERN = v), has_default(h, PARENT)) throw "The parent property is no longer supported.\nSee: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.";
+	return has_default(h, CATEGORIES) && (y.CATEGORIES = h[CATEGORIES]), augmentTokenTypes([y]), has_default(h, LABEL) && (y.LABEL = h[LABEL]), has_default(h, GROUP) && (y.GROUP = h[GROUP]), has_default(h, POP_MODE) && (y.POP_MODE = h[POP_MODE]), has_default(h, PUSH_MODE) && (y.PUSH_MODE = h[PUSH_MODE]), has_default(h, LONGER_ALT) && (y.LONGER_ALT = h[LONGER_ALT]), has_default(h, LINE_BREAKS) && (y.LINE_BREAKS = h[LINE_BREAKS]), has_default(h, START_CHARS_HINT) && (y.START_CHARS_HINT = h[START_CHARS_HINT]), y;
+}
+const EOF = createToken({
+	name: "EOF",
+	pattern: Lexer.NA
+});
+augmentTokenTypes([EOF]);
+function createTokenInstance(e, h, g, _, v, y, b, x) {
+	return {
+		image: h,
+		startOffset: g,
+		endOffset: _,
+		startLine: v,
+		endLine: y,
+		startColumn: b,
+		endColumn: x,
+		tokenTypeIdx: e.tokenTypeIdx,
+		tokenType: e
+	};
+}
+function tokenMatcher(e, h) {
+	return tokenStructuredMatcher(e, h);
+}
+export { EOF, createToken, createTokenInstance, hasTokenLabel, tokenLabel, tokenMatcher };