@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

package/browser/esm/DIqScru4YD2CC9q7.mjs

@@ -0,0 +1,4436 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.7.23-beta.2
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { tt as e } from "./Cnay4yeRx2XxT4Yp.mjs";
+import { FormulaError as t } from "@sheetxl/primitives";
+function n(e) {
+	console && console.error && console.error(`Error: ${e}`);
+}
+function r(e) {
+	console && console.warn && console.warn(`Warning: ${e}`);
+}
+function i(e) {
+	let t = (/* @__PURE__ */ new Date()).getTime(), n = e();
+	return {
+		time: (/* @__PURE__ */ new Date()).getTime() - t,
+		value: n
+	};
+}
+function a(e) {
+	function t() {}
+	t.prototype = e;
+	let n = new t();
+	function r() {
+		return typeof n.bar;
+	}
+	return r(), r(), e;
+}
+var o = class {
+	get definition() {
+		return this._definition;
+	}
+	set definition(e) {
+		this._definition = e;
+	}
+	constructor(e) {
+		this._definition = e;
+	}
+	accept(e) {
+		e.visit(this), this.definition.forEach((t) => {
+			t.accept(e);
+		});
+	}
+}, s = class extends o {
+	constructor(e) {
+		super([]), this.idx = 1, Object.assign(this, v(e));
+	}
+	set definition(e) {}
+	get definition() {
+		return this.referencedRule === void 0 ? [] : this.referencedRule.definition;
+	}
+	accept(e) {
+		e.visit(this);
+	}
+}, c = class extends o {
+	constructor(e) {
+		super(e.definition), this.orgText = "", Object.assign(this, v(e));
+	}
+}, l = class extends o {
+	constructor(e) {
+		super(e.definition), this.ignoreAmbiguities = !1, Object.assign(this, v(e));
+	}
+}, u = class extends o {
+	constructor(e) {
+		super(e.definition), this.idx = 1, Object.assign(this, v(e));
+	}
+}, d = class extends o {
+	constructor(e) {
+		super(e.definition), this.idx = 1, Object.assign(this, v(e));
+	}
+}, f = class extends o {
+	constructor(e) {
+		super(e.definition), this.idx = 1, Object.assign(this, v(e));
+	}
+}, p = class extends o {
+	constructor(e) {
+		super(e.definition), this.idx = 1, Object.assign(this, v(e));
+	}
+}, m = class extends o {
+	constructor(e) {
+		super(e.definition), this.idx = 1, Object.assign(this, v(e));
+	}
+}, h = class extends o {
+	get definition() {
+		return this._definition;
+	}
+	set definition(e) {
+		this._definition = e;
+	}
+	constructor(e) {
+		super(e.definition), this.idx = 1, this.ignoreAmbiguities = !1, this.hasPredicates = !1, Object.assign(this, v(e));
+	}
+}, g = class {
+	constructor(e) {
+		this.idx = 1, Object.assign(this, v(e));
+	}
+	accept(e) {
+		e.visit(this);
+	}
+};
+function _(e) {
+	function t(e) {
+		return e.map(_);
+	}
+	if (e instanceof s) {
+		let t = {
+			type: "NonTerminal",
+			name: e.nonTerminalName,
+			idx: e.idx
+		};
+		return typeof e.label == "string" && (t.label = e.label), t;
+	}
+	if (e instanceof l) return {
+		type: "Alternative",
+		definition: t(e.definition)
+	};
+	if (e instanceof u) return {
+		type: "Option",
+		idx: e.idx,
+		definition: t(e.definition)
+	};
+	if (e instanceof d) return {
+		type: "RepetitionMandatory",
+		idx: e.idx,
+		definition: t(e.definition)
+	};
+	if (e instanceof f) return {
+		type: "RepetitionMandatoryWithSeparator",
+		idx: e.idx,
+		separator: _(new g({ terminalType: e.separator })),
+		definition: t(e.definition)
+	};
+	if (e instanceof m) return {
+		type: "RepetitionWithSeparator",
+		idx: e.idx,
+		separator: _(new g({ terminalType: e.separator })),
+		definition: t(e.definition)
+	};
+	if (e instanceof p) return {
+		type: "Repetition",
+		idx: e.idx,
+		definition: t(e.definition)
+	};
+	if (e instanceof h) return {
+		type: "Alternation",
+		idx: e.idx,
+		definition: t(e.definition)
+	};
+	if (e instanceof g) {
+		let t = {
+			type: "Terminal",
+			name: e.terminalType.name,
+			label: (n = e.terminalType, typeof (r = n).LABEL == "string" && r.LABEL !== "" ? n.LABEL : n.name),
+			idx: e.idx
+		};
+		typeof e.label == "string" && (t.terminalLabel = e.label);
+		let i = e.terminalType.PATTERN;
+		return e.terminalType.PATTERN && (t.pattern = i instanceof RegExp ? i.source : i), t;
+	}
+	if (e instanceof c) return {
+		type: "Rule",
+		name: e.name,
+		orgText: e.orgText,
+		definition: t(e.definition)
+	};
+	throw Error("non exhaustive match");
+	var n, r;
+}
+function v(e) {
+	return Object.fromEntries(Object.entries(e).filter(([, e]) => e !== void 0));
+}
+var y = class {
+	visit(e) {
+		let t = e;
+		switch (t.constructor) {
+			case s: return this.visitNonTerminal(t);
+			case l: return this.visitAlternative(t);
+			case u: return this.visitOption(t);
+			case d: return this.visitRepetitionMandatory(t);
+			case f: return this.visitRepetitionMandatoryWithSeparator(t);
+			case m: return this.visitRepetitionWithSeparator(t);
+			case p: return this.visitRepetition(t);
+			case h: return this.visitAlternation(t);
+			case g: return this.visitTerminal(t);
+			case c: return this.visitRule(t);
+			default: throw Error("non exhaustive match");
+		}
+	}
+	visitNonTerminal(e) {}
+	visitAlternative(e) {}
+	visitOption(e) {}
+	visitRepetition(e) {}
+	visitRepetitionMandatory(e) {}
+	visitRepetitionMandatoryWithSeparator(e) {}
+	visitRepetitionWithSeparator(e) {}
+	visitAlternation(e) {}
+	visitTerminal(e) {}
+	visitRule(e) {}
+};
+function b(e, t = []) {
+	return e instanceof u || e instanceof p || e instanceof m || (e instanceof h ? e.definition.some((e) => b(e, t)) : !(e instanceof s && t.includes(e)) && e instanceof o && (e instanceof s && t.push(e), e.definition.every((e) => b(e, t))));
+}
+function x(e) {
+	if (e instanceof s) return "SUBRULE";
+	if (e instanceof u) return "OPTION";
+	if (e instanceof h) return "OR";
+	if (e instanceof d) return "AT_LEAST_ONE";
+	if (e instanceof f) return "AT_LEAST_ONE_SEP";
+	if (e instanceof m) return "MANY_SEP";
+	if (e instanceof p) return "MANY";
+	if (e instanceof g) return "CONSUME";
+	throw Error("non exhaustive match");
+}
+var S = class {
+	walk(e, t = []) {
+		e.definition.forEach((n, r) => {
+			let i = e.definition.slice(r + 1);
+			if (n instanceof s) this.walkProdRef(n, i, t);
+			else if (n instanceof g) this.walkTerminal(n, i, t);
+			else if (n instanceof l) this.walkFlat(n, i, t);
+			else if (n instanceof u) this.walkOption(n, i, t);
+			else if (n instanceof d) this.walkAtLeastOne(n, i, t);
+			else if (n instanceof f) this.walkAtLeastOneSep(n, i, t);
+			else if (n instanceof m) this.walkManySep(n, i, t);
+			else if (n instanceof p) this.walkMany(n, i, t);
+			else {
+				if (!(n instanceof h)) throw Error("non exhaustive match");
+				this.walkOr(n, i, t);
+			}
+		});
+	}
+	walkTerminal(e, t, n) {}
+	walkProdRef(e, t, n) {}
+	walkFlat(e, t, n) {
+		let r = t.concat(n);
+		this.walk(e, r);
+	}
+	walkOption(e, t, n) {
+		let r = t.concat(n);
+		this.walk(e, r);
+	}
+	walkAtLeastOne(e, t, n) {
+		let r = [new u({ definition: e.definition })].concat(t, n);
+		this.walk(e, r);
+	}
+	walkAtLeastOneSep(e, t, n) {
+		let r = C(e, t, n);
+		this.walk(e, r);
+	}
+	walkMany(e, t, n) {
+		let r = [new u({ definition: e.definition })].concat(t, n);
+		this.walk(e, r);
+	}
+	walkManySep(e, t, n) {
+		let r = C(e, t, n);
+		this.walk(e, r);
+	}
+	walkOr(e, t, n) {
+		let r = t.concat(n);
+		e.definition.forEach((e) => {
+			let t = new l({ definition: [e] });
+			this.walk(t, r);
+		});
+	}
+};
+function C(e, t, n) {
+	return [new u({ definition: [new g({ terminalType: e.separator })].concat(e.definition) })].concat(t, n);
+}
+function w(e) {
+	if (e instanceof s) return w(e.referencedRule);
+	if (e instanceof g) return [e.terminalType];
+	if (function(e) {
+		return e instanceof l || e instanceof u || e instanceof p || e instanceof d || e instanceof f || e instanceof m || e instanceof g || e instanceof c;
+	}(e)) return function(e) {
+		let t = [], n = e.definition, r, i = 0, a = n.length > i, o = !0;
+		for (; a && o;) r = n[i], o = b(r), t = t.concat(w(r)), i += 1, a = n.length > i;
+		return [...new Set(t)];
+	}(e);
+	if (function(e) {
+		return e instanceof h;
+	}(e)) return function(e) {
+		let t = e.definition.map((e) => w(e));
+		return [...new Set(t.flat())];
+	}(e);
+	throw Error("non exhaustive match");
+}
+var T = "_~IN~_", E = class extends S {
+	constructor(e) {
+		super(), this.topProd = e, this.follows = {};
+	}
+	startWalking() {
+		return this.walk(this.topProd), this.follows;
+	}
+	walkTerminal(e, t, n) {}
+	walkProdRef(e, t, n) {
+		let r = (i = e.referencedRule, a = e.idx, i.name + a + T + this.topProd.name);
+		var i, a;
+		let o = w(new l({ definition: t.concat(n) }));
+		this.follows[r] = o;
+	}
+};
+function D(e) {
+	return e.charCodeAt(0);
+}
+function O(e, t) {
+	Array.isArray(e) ? e.forEach(function(e) {
+		t.push(e);
+	}) : t.push(e);
+}
+function k(e, t) {
+	if (!0 === e[t]) throw "duplicate flag " + t;
+	e[t], e[t] = !0;
+}
+function A(e) {
+	if (e === void 0) throw Error("Internal Error - Should never get here!");
+	return !0;
+}
+function j() {
+	throw Error("Internal Error - Should never get here!");
+}
+function M(e) {
+	return e.type === "Character";
+}
+var N = [];
+for (let e = D("0"); e <= D("9"); e++) N.push(e);
+var P = [D("_")].concat(N);
+for (let e = D("a"); e <= D("z"); e++) P.push(e);
+for (let e = D("A"); e <= D("Z"); e++) P.push(e);
+var ee = [
+	D(" "),
+	D("\f"),
+	D("\n"),
+	D("\r"),
+	D("	"),
+	D("\v"),
+	D("	"),
+	D("\xA0"),
+	D(" "),
+	D(" "),
+	D(" "),
+	D(" "),
+	D(" "),
+	D(" "),
+	D(" "),
+	D(" "),
+	D(" "),
+	D(" "),
+	D(" "),
+	D(" "),
+	D("\u2028"),
+	D("\u2029"),
+	D(" "),
+	D(" "),
+	D("　"),
+	D("")
+], te = /[0-9a-fA-F]/, F = /[0-9]/, ne = /[1-9]/, I = class {
+	visitChildren(e) {
+		for (let t in e) {
+			let n = e[t];
+			e.hasOwnProperty(t) && (n.type === void 0 ? Array.isArray(n) && n.forEach((e) => {
+				this.visit(e);
+			}, this) : this.visit(n));
+		}
+	}
+	visit(e) {
+		switch (e.type) {
+			case "Pattern":
+				this.visitPattern(e);
+				break;
+			case "Flags":
+				this.visitFlags(e);
+				break;
+			case "Disjunction":
+				this.visitDisjunction(e);
+				break;
+			case "Alternative":
+				this.visitAlternative(e);
+				break;
+			case "StartAnchor":
+				this.visitStartAnchor(e);
+				break;
+			case "EndAnchor":
+				this.visitEndAnchor(e);
+				break;
+			case "WordBoundary":
+				this.visitWordBoundary(e);
+				break;
+			case "NonWordBoundary":
+				this.visitNonWordBoundary(e);
+				break;
+			case "Lookahead":
+				this.visitLookahead(e);
+				break;
+			case "NegativeLookahead":
+				this.visitNegativeLookahead(e);
+				break;
+			case "Lookbehind":
+				this.visitLookbehind(e);
+				break;
+			case "NegativeLookbehind":
+				this.visitNegativeLookbehind(e);
+				break;
+			case "Character":
+				this.visitCharacter(e);
+				break;
+			case "Set":
+				this.visitSet(e);
+				break;
+			case "Group":
+				this.visitGroup(e);
+				break;
+			case "GroupBackReference":
+				this.visitGroupBackReference(e);
+				break;
+			case "Quantifier": this.visitQuantifier(e);
+		}
+		this.visitChildren(e);
+	}
+	visitPattern(e) {}
+	visitFlags(e) {}
+	visitDisjunction(e) {}
+	visitAlternative(e) {}
+	visitStartAnchor(e) {}
+	visitEndAnchor(e) {}
+	visitWordBoundary(e) {}
+	visitNonWordBoundary(e) {}
+	visitLookahead(e) {}
+	visitNegativeLookahead(e) {}
+	visitLookbehind(e) {}
+	visitNegativeLookbehind(e) {}
+	visitCharacter(e) {}
+	visitSet(e) {}
+	visitGroup(e) {}
+	visitGroupBackReference(e) {}
+	visitQuantifier(e) {}
+}, L = {}, re = new class {
+	constructor() {
+		this.idx = 0, this.input = "", this.groupIdx = 0;
+	}
+	saveState() {
+		return {
+			idx: this.idx,
+			input: this.input,
+			groupIdx: this.groupIdx
+		};
+	}
+	restoreState(e) {
+		this.idx = e.idx, this.input = e.input, this.groupIdx = e.groupIdx;
+	}
+	pattern(e) {
+		this.idx = 0, this.input = e, this.groupIdx = 0, this.consumeChar("/");
+		let t = this.disjunction();
+		this.consumeChar("/");
+		let n = {
+			type: "Flags",
+			loc: {
+				begin: this.idx,
+				end: e.length
+			},
+			global: !1,
+			ignoreCase: !1,
+			multiLine: !1,
+			unicode: !1,
+			sticky: !1
+		};
+		for (; this.isRegExpFlag();) switch (this.popChar()) {
+			case "g":
+				k(n, "global");
+				break;
+			case "i":
+				k(n, "ignoreCase");
+				break;
+			case "m":
+				k(n, "multiLine");
+				break;
+			case "u":
+				k(n, "unicode");
+				break;
+			case "y": k(n, "sticky");
+		}
+		if (this.idx !== this.input.length) throw Error("Redundant input: " + this.input.substring(this.idx));
+		return {
+			type: "Pattern",
+			flags: n,
+			value: t,
+			loc: this.loc(0)
+		};
+	}
+	disjunction() {
+		let e = [], t = this.idx;
+		for (e.push(this.alternative()); this.peekChar() === "|";) this.consumeChar("|"), e.push(this.alternative());
+		return {
+			type: "Disjunction",
+			value: e,
+			loc: this.loc(t)
+		};
+	}
+	alternative() {
+		let e = [], t = this.idx;
+		for (; this.isTerm();) e.push(this.term());
+		return {
+			type: "Alternative",
+			value: e,
+			loc: this.loc(t)
+		};
+	}
+	term() {
+		return this.isAssertion() ? this.assertion() : this.atom();
+	}
+	assertion() {
+		let e = this.idx;
+		switch (this.popChar()) {
+			case "^": return {
+				type: "StartAnchor",
+				loc: this.loc(e)
+			};
+			case "$": return {
+				type: "EndAnchor",
+				loc: this.loc(e)
+			};
+			case "\\":
+				switch (this.popChar()) {
+					case "b": return {
+						type: "WordBoundary",
+						loc: this.loc(e)
+					};
+					case "B": return {
+						type: "NonWordBoundary",
+						loc: this.loc(e)
+					};
+				}
+				throw Error("Invalid Assertion Escape");
+			case "(":
+				let t;
+				switch (this.consumeChar("?"), this.popChar()) {
+					case "=":
+						t = "Lookahead";
+						break;
+					case "!":
+						t = "NegativeLookahead";
+						break;
+					case "<": switch (this.popChar()) {
+						case "=":
+							t = "Lookbehind";
+							break;
+						case "!": t = "NegativeLookbehind";
+					}
+				}
+				A(t);
+				let n = this.disjunction();
+				return this.consumeChar(")"), {
+					type: t,
+					value: n,
+					loc: this.loc(e)
+				};
+		}
+		return j();
+	}
+	quantifier(e = !1) {
+		let t, n = this.idx;
+		switch (this.popChar()) {
+			case "*":
+				t = {
+					atLeast: 0,
+					atMost: Infinity
+				};
+				break;
+			case "+":
+				t = {
+					atLeast: 1,
+					atMost: Infinity
+				};
+				break;
+			case "?":
+				t = {
+					atLeast: 0,
+					atMost: 1
+				};
+				break;
+			case "{":
+				let n = this.integerIncludingZero();
+				switch (this.popChar()) {
+					case "}":
+						t = {
+							atLeast: n,
+							atMost: n
+						};
+						break;
+					case ",":
+						let e;
+						this.isDigit() ? (e = this.integerIncludingZero(), t = {
+							atLeast: n,
+							atMost: e
+						}) : t = {
+							atLeast: n,
+							atMost: Infinity
+						}, this.consumeChar("}");
+				}
+				if (!0 === e && t === void 0) return;
+				A(t);
+		}
+		if (!0 !== e || t !== void 0) return A(t) ? (this.peekChar(0) === "?" ? (this.consumeChar("?"), t.greedy = !1) : t.greedy = !0, t.type = "Quantifier", t.loc = this.loc(n), t) : void 0;
+	}
+	atom() {
+		let e, t = this.idx;
+		switch (this.peekChar()) {
+			case ".":
+				e = this.dotAll();
+				break;
+			case "\\":
+				e = this.atomEscape();
+				break;
+			case "[":
+				e = this.characterClass();
+				break;
+			case "(": e = this.group();
+		}
+		return e === void 0 && this.isPatternCharacter() && (e = this.patternCharacter()), A(e) ? (e.loc = this.loc(t), this.isQuantifier() && (e.quantifier = this.quantifier()), e) : j();
+	}
+	dotAll() {
+		return this.consumeChar("."), {
+			type: "Set",
+			complement: !0,
+			value: [
+				D("\n"),
+				D("\r"),
+				D("\u2028"),
+				D("\u2029")
+			]
+		};
+	}
+	atomEscape() {
+		switch (this.consumeChar("\\"), this.peekChar()) {
+			case "1":
+			case "2":
+			case "3":
+			case "4":
+			case "5":
+			case "6":
+			case "7":
+			case "8":
+			case "9": return this.decimalEscapeAtom();
+			case "d":
+			case "D":
+			case "s":
+			case "S":
+			case "w":
+			case "W": return this.characterClassEscape();
+			case "f":
+			case "n":
+			case "r":
+			case "t":
+			case "v": return this.controlEscapeAtom();
+			case "c": return this.controlLetterEscapeAtom();
+			case "0": return this.nulCharacterAtom();
+			case "x": return this.hexEscapeSequenceAtom();
+			case "u": return this.regExpUnicodeEscapeSequenceAtom();
+			default: return this.identityEscapeAtom();
+		}
+	}
+	decimalEscapeAtom() {
+		return {
+			type: "GroupBackReference",
+			value: this.positiveInteger()
+		};
+	}
+	characterClassEscape() {
+		let e, t = !1;
+		switch (this.popChar()) {
+			case "d":
+				e = N;
+				break;
+			case "D":
+				e = N, t = !0;
+				break;
+			case "s":
+				e = ee;
+				break;
+			case "S":
+				e = ee, t = !0;
+				break;
+			case "w":
+				e = P;
+				break;
+			case "W": e = P, t = !0;
+		}
+		return A(e) ? {
+			type: "Set",
+			value: e,
+			complement: t
+		} : j();
+	}
+	controlEscapeAtom() {
+		let e;
+		switch (this.popChar()) {
+			case "f":
+				e = D("\f");
+				break;
+			case "n":
+				e = D("\n");
+				break;
+			case "r":
+				e = D("\r");
+				break;
+			case "t":
+				e = D("	");
+				break;
+			case "v": e = D("\v");
+		}
+		return A(e) ? {
+			type: "Character",
+			value: e
+		} : j();
+	}
+	controlLetterEscapeAtom() {
+		this.consumeChar("c");
+		let e = this.popChar();
+		if (!1 === /[a-zA-Z]/.test(e)) throw Error("Invalid ");
+		return {
+			type: "Character",
+			value: e.toUpperCase().charCodeAt(0) - 64
+		};
+	}
+	nulCharacterAtom() {
+		return this.consumeChar("0"), {
+			type: "Character",
+			value: D("\0")
+		};
+	}
+	hexEscapeSequenceAtom() {
+		return this.consumeChar("x"), this.parseHexDigits(2);
+	}
+	regExpUnicodeEscapeSequenceAtom() {
+		return this.consumeChar("u"), this.parseHexDigits(4);
+	}
+	identityEscapeAtom() {
+		return {
+			type: "Character",
+			value: D(this.popChar())
+		};
+	}
+	classPatternCharacterAtom() {
+		switch (this.peekChar()) {
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029":
+			case "\\":
+			case "]": throw Error("TBD");
+			default: return {
+				type: "Character",
+				value: D(this.popChar())
+			};
+		}
+	}
+	characterClass() {
+		let e = [], t = !1;
+		for (this.consumeChar("["), this.peekChar(0) === "^" && (this.consumeChar("^"), t = !0); this.isClassAtom();) {
+			let t = this.classAtom();
+			if (t.type, M(t) && this.isRangeDash()) {
+				this.consumeChar("-");
+				let n = this.classAtom();
+				if (n.type, M(n)) {
+					if (n.value < t.value) throw Error("Range out of order in character class");
+					e.push({
+						from: t.value,
+						to: n.value
+					});
+				} else O(t.value, e), e.push(D("-")), O(n.value, e);
+			} else O(t.value, e);
+		}
+		return this.consumeChar("]"), {
+			type: "Set",
+			complement: t,
+			value: e
+		};
+	}
+	classAtom() {
+		switch (this.peekChar()) {
+			case "]":
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029": throw Error("TBD");
+			case "\\": return this.classEscape();
+			default: return this.classPatternCharacterAtom();
+		}
+	}
+	classEscape() {
+		switch (this.consumeChar("\\"), this.peekChar()) {
+			case "b": return this.consumeChar("b"), {
+				type: "Character",
+				value: D("\b")
+			};
+			case "d":
+			case "D":
+			case "s":
+			case "S":
+			case "w":
+			case "W": return this.characterClassEscape();
+			case "f":
+			case "n":
+			case "r":
+			case "t":
+			case "v": return this.controlEscapeAtom();
+			case "c": return this.controlLetterEscapeAtom();
+			case "0": return this.nulCharacterAtom();
+			case "x": return this.hexEscapeSequenceAtom();
+			case "u": return this.regExpUnicodeEscapeSequenceAtom();
+			default: return this.identityEscapeAtom();
+		}
+	}
+	group() {
+		let e = !0;
+		this.consumeChar("("), this.peekChar(0) === "?" ? (this.consumeChar("?"), this.consumeChar(":"), e = !1) : this.groupIdx++;
+		let t = this.disjunction();
+		this.consumeChar(")");
+		let n = {
+			type: "Group",
+			capturing: e,
+			value: t
+		};
+		return e && (n.idx = this.groupIdx), n;
+	}
+	positiveInteger() {
+		let e = this.popChar();
+		if (!1 === ne.test(e)) throw Error("Expecting a positive integer");
+		for (; F.test(this.peekChar(0));) e += this.popChar();
+		return parseInt(e, 10);
+	}
+	integerIncludingZero() {
+		let e = this.popChar();
+		if (!1 === F.test(e)) throw Error("Expecting an integer");
+		for (; F.test(this.peekChar(0));) e += this.popChar();
+		return parseInt(e, 10);
+	}
+	patternCharacter() {
+		let e = this.popChar();
+		switch (e) {
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029":
+			case "^":
+			case "$":
+			case "\\":
+			case ".":
+			case "*":
+			case "+":
+			case "?":
+			case "(":
+			case ")":
+			case "[":
+			case "|": throw Error("TBD");
+			default: return {
+				type: "Character",
+				value: D(e)
+			};
+		}
+	}
+	isRegExpFlag() {
+		switch (this.peekChar(0)) {
+			case "g":
+			case "i":
+			case "m":
+			case "u":
+			case "y": return !0;
+			default: return !1;
+		}
+	}
+	isRangeDash() {
+		return this.peekChar() === "-" && this.isClassAtom(1);
+	}
+	isDigit() {
+		return F.test(this.peekChar(0));
+	}
+	isClassAtom(e = 0) {
+		switch (this.peekChar(e)) {
+			case "]":
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029": return !1;
+			default: return !0;
+		}
+	}
+	isTerm() {
+		return this.isAtom() || this.isAssertion();
+	}
+	isAtom() {
+		if (this.isPatternCharacter()) return !0;
+		switch (this.peekChar(0)) {
+			case ".":
+			case "\\":
+			case "[":
+			case "(": return !0;
+			default: return !1;
+		}
+	}
+	isAssertion() {
+		switch (this.peekChar(0)) {
+			case "^":
+			case "$": return !0;
+			case "\\": switch (this.peekChar(1)) {
+				case "b":
+				case "B": return !0;
+				default: return !1;
+			}
+			case "(": return this.peekChar(1) === "?" && (this.peekChar(2) === "=" || this.peekChar(2) === "!" || this.peekChar(2) === "<" && (this.peekChar(3) === "=" || this.peekChar(3) === "!"));
+			default: return !1;
+		}
+	}
+	isQuantifier() {
+		let e = this.saveState();
+		try {
+			return this.quantifier(!0) !== void 0;
+		} catch {
+			return !1;
+		} finally {
+			this.restoreState(e);
+		}
+	}
+	isPatternCharacter() {
+		switch (this.peekChar()) {
+			case "^":
+			case "$":
+			case "\\":
+			case ".":
+			case "*":
+			case "+":
+			case "?":
+			case "(":
+			case ")":
+			case "[":
+			case "|":
+			case "/":
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029": return !1;
+			default: return !0;
+		}
+	}
+	parseHexDigits(e) {
+		let t = "";
+		for (let n = 0; n < e; n++) {
+			let e = this.popChar();
+			if (!1 === te.test(e)) throw Error("Expecting a HexDecimal digits");
+			t += e;
+		}
+		return {
+			type: "Character",
+			value: parseInt(t, 16)
+		};
+	}
+	peekChar(e = 0) {
+		return this.input[this.idx + e];
+	}
+	popChar() {
+		let e = this.peekChar(0);
+		return this.consumeChar(void 0), e;
+	}
+	consumeChar(e) {
+		if (e !== void 0 && this.input[this.idx] !== e) throw Error("Expected: '" + e + "' but found: '" + this.input[this.idx] + "' at offset: " + this.idx);
+		if (this.idx >= this.input.length) throw Error("Unexpected end of input");
+		this.idx++;
+	}
+	loc(e) {
+		return {
+			begin: e,
+			end: this.idx
+		};
+	}
+}();
+function ie(e) {
+	let t = e.toString();
+	if (L.hasOwnProperty(t)) return L[t];
+	{
+		let e = re.pattern(t);
+		return L[t] = e, e;
+	}
+}
+var ae = "Complement Sets are not supported for first char optimization", oe = "Unable to use \"first char\" lexer optimizations:\n";
+function se(e, t = !1) {
+	try {
+		let t = ie(e);
+		return ce(t.value, {}, t.flags.ignoreCase);
+	} catch (i) {
+		if (i.message === ae) t && r(`${oe}\tUnable to optimize: < ${e.toString()} >\n\tComplement Sets cannot be automatically optimized.\n\tThis will disable the lexer's first char optimizations.\n\tSee: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.`);
+		else {
+			let r = "";
+			t && (r = "\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."), n(`${oe}\n\tFailed parsing: < ${e.toString()} >\n\tUsing the @chevrotain/regexp-to-ast library\n\tPlease open an issue at: https://github.com/chevrotain/chevrotain/issues` + r);
+		}
+	}
+	return [];
+}
+function ce(e, t, n) {
+	switch (e.type) {
+		case "Disjunction":
+			for (let r = 0; r < e.value.length; r++) ce(e.value[r], t, n);
+			break;
+		case "Alternative":
+			let r = e.value;
+			for (let e = 0; e < r.length; e++) {
+				let i = r[e];
+				switch (i.type) {
+					case "EndAnchor":
+					case "GroupBackReference":
+					case "Lookahead":
+					case "NegativeLookahead":
+					case "Lookbehind":
+					case "NegativeLookbehind":
+					case "StartAnchor":
+					case "WordBoundary":
+					case "NonWordBoundary": continue;
+				}
+				let a = i;
+				switch (a.type) {
+					case "Character":
+						le(a.value, t, n);
+						break;
+					case "Set":
+						if (!0 === a.complement) throw Error(ae);
+						a.value.forEach((e) => {
+							if (typeof e == "number") le(e, t, n);
+							else {
+								let r = e;
+								if (!0 === n) for (let e = r.from; e <= r.to; e++) le(e, t, n);
+								else {
+									for (let e = r.from; e <= r.to && e < 256; e++) le(e, t, n);
+									if (r.to >= 256) {
+										let e = r.from >= 256 ? r.from : 256, n = r.to, i = z(e), a = z(n);
+										for (let e = i; e <= a; e++) t[e] = e;
+									}
+								}
+							}
+						});
+						break;
+					case "Group":
+						ce(a.value, t, n);
+						break;
+					default: throw Error("Non Exhaustive Match");
+				}
+				let o = a.quantifier !== void 0 && a.quantifier.atLeast === 0;
+				if (a.type === "Group" && !1 === de(a) || a.type !== "Group" && !1 === o) break;
+			}
+			break;
+		default: throw Error("non exhaustive match!");
+	}
+	return Object.values(t);
+}
+function le(e, t, n) {
+	let r = z(e);
+	t[r] = r, !0 === n && function(e, t) {
+		let n = String.fromCharCode(e), r = n.toUpperCase();
+		if (r !== n) {
+			let e = z(r.charCodeAt(0));
+			t[e] = e;
+		} else {
+			let e = n.toLowerCase();
+			if (e !== n) {
+				let n = z(e.charCodeAt(0));
+				t[n] = n;
+			}
+		}
+	}(e, t);
+}
+function ue(e, t) {
+	return e.value.find((e) => {
+		if (typeof e == "number") return t.includes(e);
+		{
+			let n = e;
+			return t.find((e) => n.from <= e && e <= n.to) !== void 0;
+		}
+	});
+}
+function de(e) {
+	let t = e.quantifier;
+	return !(!t || t.atLeast !== 0) || !!e.value && (Array.isArray(e.value) ? e.value.every(de) : de(e.value));
+}
+var fe = class extends I {
+	constructor(e) {
+		super(), this.targetCharCodes = e, this.found = !1;
+	}
+	visitChildren(e) {
+		if (!0 !== this.found) {
+			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) {
+		this.targetCharCodes.includes(e.value) && (this.found = !0);
+	}
+	visitSet(e) {
+		e.complement ? ue(e, this.targetCharCodes) === void 0 && (this.found = !0) : ue(e, this.targetCharCodes) !== void 0 && (this.found = !0);
+	}
+};
+function pe(e, t) {
+	if (t instanceof RegExp) {
+		let n = ie(t), r = new fe(e);
+		return r.visit(n), r.found;
+	}
+	for (let n of t) {
+		let t = n.charCodeAt(0);
+		if (e.includes(t)) return !0;
+	}
+	return !1;
+}
+var R = "PATTERN", me = "defaultMode";
+function he(e, t) {
+	let r = (t = Object.assign({
+		safeMode: !1,
+		positionTracking: "full",
+		lineTerminatorCharacters: ["\r", "\n"],
+		tracer: (e, t) => t()
+	}, t)).tracer, i;
+	r("initCharCodeToOptimizedIndexMap", () => {
+		(function() {
+			if (De.length === 0) {
+				De = Array(65536);
+				for (let e = 0; e < 65536; e++) De[e] = e > 255 ? 255 + ~~(e / 255) : e;
+			}
+		})();
+	}), r("Reject Lexer.NA", () => {
+		i = e.filter((e) => e[R] !== W.NA);
+	});
+	let a, o, s, c, l, u, d, f, p, m, h, g = !1;
+	r("Transform Patterns", () => {
+		g = !1, a = i.map((e) => {
+			let t = e[R];
+			if (t instanceof RegExp) {
+				let e = t.source;
+				return e.length !== 1 || e === "^" || e === "$" || e === "." || t.ignoreCase ? e.length !== 2 || e[0] !== "\\" || [
+					"d",
+					"D",
+					"s",
+					"S",
+					"t",
+					"r",
+					"n",
+					"t",
+					"0",
+					"c",
+					"b",
+					"B",
+					"f",
+					"v",
+					"w",
+					"W"
+				].includes(e[1]) ? ye(t) : e[1] : e;
+			}
+			if (typeof t == "function") return g = !0, { exec: t };
+			if (typeof t == "object") return g = !0, t;
+			if (typeof t == "string") {
+				if (t.length === 1) return t;
+				{
+					let e = t.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+					return ye(new RegExp(e));
+				}
+			}
+			throw Error("non exhaustive match");
+		});
+	}), r("misc mapping", () => {
+		o = i.map((e) => e.tokenTypeIdx), s = i.map((e) => {
+			let t = e.GROUP;
+			if (t !== W.SKIPPED) {
+				if (typeof t == "string") return t;
+				if (t === void 0) return !1;
+				throw Error("non exhaustive match");
+			}
+		}), c = i.map((e) => {
+			let t = e.LONGER_ALT;
+			if (t) return Array.isArray(t) ? t.map((e) => i.indexOf(e)) : [i.indexOf(t)];
+		}), l = i.map((e) => e.PUSH_MODE), u = i.map((e) => Object.hasOwn(e, "POP_MODE"));
+	}), r("Line Terminator Handling", () => {
+		let e = Te(t.lineTerminatorCharacters);
+		d = i.map((e) => !1), t.positionTracking !== "onlyOffset" && (d = i.map((t) => Object.hasOwn(t, "LINE_BREAKS") ? !!t.LINE_BREAKS : !1 === Ce(t, e) && pe(e, t.PATTERN)));
+	}), r("Misc Mapping #2", () => {
+		f = i.map(be), p = a.map(xe), m = i.reduce((e, t) => {
+			let n = t.GROUP;
+			return typeof n == "string" && n !== W.SKIPPED && (e[n] = []), e;
+		}, {}), h = a.map((e, t) => ({
+			pattern: a[t],
+			longerAlt: c[t],
+			canLineTerminator: d[t],
+			isCustom: f[t],
+			short: p[t],
+			group: s[t],
+			push: l[t],
+			pop: u[t],
+			tokenTypeIdx: o[t],
+			tokenType: i[t]
+		}));
+	});
+	let _ = !0, v = [];
+	return t.safeMode || r("First Char Optimization", () => {
+		v = i.reduce((e, r, i) => {
+			if (typeof r.PATTERN == "string") Ee(e, z(r.PATTERN.charCodeAt(0)), h[i]);
+			else if (Array.isArray(r.START_CHARS_HINT)) {
+				let t;
+				r.START_CHARS_HINT.forEach((n) => {
+					let r = z(typeof n == "string" ? n.charCodeAt(0) : n);
+					t !== r && (t = r, Ee(e, r, h[i]));
+				});
+			} else if (r.PATTERN instanceof RegExp) if (r.PATTERN.unicode) _ = !1, t.ensureOptimizations && n(`${oe}\tUnable to analyze < ${r.PATTERN.toString()} > pattern.\n\tThe regexp unicode flag is not currently supported by the regexp-to-ast library.\n\tThis will disable the lexer's first char optimizations.\n\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNICODE_OPTIMIZE`);
+			else {
+				let n = se(r.PATTERN, t.ensureOptimizations);
+				n.length === 0 && (_ = !1), n.forEach((t) => {
+					Ee(e, t, h[i]);
+				});
+			}
+			else t.ensureOptimizations && n(`${oe}\tTokenType: <${r.name}> is using a custom token pattern without providing <start_chars_hint> parameter.\n\tThis will disable the lexer's first char optimizations.\n\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_OPTIMIZE`), _ = !1;
+			return e;
+		}, []);
+	}), {
+		emptyGroups: m,
+		patternIdxToConfig: h,
+		charCodeToPatternIdxToConfig: v,
+		hasCustom: g,
+		canBeOptimized: _
+	};
+}
+function ge(e, t) {
+	let n = [], r = function(e) {
+		let t = e.filter((e) => !Object.hasOwn(e, R));
+		return {
+			errors: t.map((e) => ({
+				message: "Token Type: ->" + e.name + "<- missing static 'PATTERN' property",
+				type: H.MISSING_PATTERN,
+				tokenTypes: [e]
+			})),
+			valid: e.filter((e) => !t.includes(e))
+		};
+	}(e);
+	n = n.concat(r.errors);
+	let i = function(e) {
+		let t = e.filter((e) => {
+			let t = e[R];
+			return !(t instanceof RegExp || typeof t == "function" || Object.hasOwn(t, "exec") || typeof t == "string");
+		});
+		return {
+			errors: t.map((e) => ({
+				message: "Token Type: ->" + e.name + "<- static 'PATTERN' can only be a RegExp, a Function matching the {CustomPatternMatcherFunc} type or an Object matching the {ICustomPattern} interface.",
+				type: H.INVALID_PATTERN,
+				tokenTypes: [e]
+			})),
+			valid: e.filter((e) => !t.includes(e))
+		};
+	}(r.valid), a = i.valid;
+	return n = n.concat(i.errors), n = n.concat(function(e) {
+		let t = [], n = e.filter((e) => e[R] instanceof RegExp);
+		return t = t.concat(function(e) {
+			class t extends I {
+				constructor() {
+					super(...arguments), this.found = !1;
+				}
+				visitEndAnchor(e) {
+					this.found = !0;
+				}
+			}
+			return e.filter((e) => {
+				let n = e.PATTERN;
+				try {
+					let e = ie(n), r = new t();
+					return r.visit(e), r.found;
+				} catch {
+					return _e.test(n.source);
+				}
+			}).map((e) => ({
+				message: "Unexpected RegExp Anchor Error:\n	Token Type: ->" + e.name + "<- static 'PATTERN' cannot contain end of input anchor '$'\n	See chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS	for details.",
+				type: H.EOI_ANCHOR_FOUND,
+				tokenTypes: [e]
+			}));
+		}(n)), t = t.concat(function(e) {
+			class t extends I {
+				constructor() {
+					super(...arguments), this.found = !1;
+				}
+				visitStartAnchor(e) {
+					this.found = !0;
+				}
+			}
+			return e.filter((e) => {
+				let n = e.PATTERN;
+				try {
+					let e = ie(n), r = new t();
+					return r.visit(e), r.found;
+				} catch {
+					return ve.test(n.source);
+				}
+			}).map((e) => ({
+				message: "Unexpected RegExp Anchor Error:\n	Token Type: ->" + e.name + "<- static 'PATTERN' cannot contain start of input anchor '^'\n	See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS	for details.",
+				type: H.SOI_ANCHOR_FOUND,
+				tokenTypes: [e]
+			}));
+		}(n)), t = t.concat(function(e) {
+			return e.filter((e) => {
+				let t = e[R];
+				return t instanceof RegExp && (t.multiline || t.global);
+			}).map((e) => ({
+				message: "Token Type: ->" + e.name + "<- static 'PATTERN' may NOT contain global('g') or multiline('m')",
+				type: H.UNSUPPORTED_FLAGS_FOUND,
+				tokenTypes: [e]
+			}));
+		}(n)), t = t.concat(function(e) {
+			let t = [], n = e.map((n) => e.reduce((e, r) => (n.PATTERN.source !== r.PATTERN.source || t.includes(r) || r.PATTERN === W.NA || (t.push(r), e.push(r)), e), []));
+			return n = n.filter(Boolean), n.filter((e) => e.length > 1).map((e) => {
+				let t = e.map((e) => e.name);
+				return {
+					message: `The same RegExp pattern ->${e[0].PATTERN}<-has been used in all of the following Token Types: ${t.join(", ")} <-`,
+					type: H.DUPLICATE_PATTERNS_FOUND,
+					tokenTypes: e
+				};
+			});
+		}(n)), t = t.concat(function(e) {
+			return e.filter((e) => e.PATTERN.test("")).map((e) => ({
+				message: "Token Type: ->" + e.name + "<- static 'PATTERN' must not match an empty string",
+				type: H.EMPTY_MATCH_PATTERN,
+				tokenTypes: [e]
+			}));
+		}(n)), t;
+	}(a)), n = n.concat(function(e) {
+		return e.filter((e) => {
+			if (!Object.hasOwn(e, "GROUP")) return !1;
+			let t = e.GROUP;
+			return t !== W.SKIPPED && t !== W.NA && typeof t != "string";
+		}).map((e) => ({
+			message: "Token Type: ->" + e.name + "<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String",
+			type: H.INVALID_GROUP_TYPE_FOUND,
+			tokenTypes: [e]
+		}));
+	}(a)), n = n.concat(function(e, t) {
+		return e.filter((e) => e.PUSH_MODE !== void 0 && !t.includes(e.PUSH_MODE)).map((e) => ({
+			message: `Token Type: ->${e.name}<- static 'PUSH_MODE' value cannot refer to a Lexer Mode ->${e.PUSH_MODE}<-which does not exist`,
+			type: H.PUSH_MODE_DOES_NOT_EXIST,
+			tokenTypes: [e]
+		}));
+	}(a, t)), n = n.concat(function(e) {
+		let t = [], n = e.reduce((e, t, n) => {
+			let r = t.PATTERN;
+			return r === W.NA || (typeof r == "string" ? e.push({
+				str: r,
+				idx: n,
+				tokenType: t
+			}) : r instanceof RegExp && (i = r, [
+				".",
+				"\\",
+				"[",
+				"]",
+				"|",
+				"^",
+				"$",
+				"(",
+				")",
+				"?",
+				"*",
+				"+",
+				"{"
+			].find((e) => i.source.indexOf(e) !== -1) === void 0) && e.push({
+				str: r.source,
+				idx: n,
+				tokenType: t
+			})), e;
+			var i;
+		}, []);
+		return e.forEach((e, r) => {
+			n.forEach(({ str: n, idx: i, tokenType: a }) => {
+				if (r < i && function(e, t) {
+					if (t instanceof RegExp) {
+						if (/(\(\?=)|(\(\?!)|(\(\?<=)|(\(\?<!)/.test(t.source)) return !1;
+						let n = t.exec(e);
+						return n !== null && n.index === 0;
+					}
+					if (typeof t == "function") return t(e, 0, [], {});
+					if (Object.hasOwn(t, "exec")) return t.exec(e, 0, [], {});
+					if (typeof t == "string") return t === e;
+					throw Error("non exhaustive match");
+				}(n, e.PATTERN)) {
+					let n = `Token: ->${a.name}<- can never be matched.\nBecause it appears AFTER the Token Type ->${e.name}<-in the lexer's definition.\nSee https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNREACHABLE`;
+					t.push({
+						message: n,
+						type: H.UNREACHABLE_PATTERN,
+						tokenTypes: [e, a]
+					});
+				}
+			});
+		}), t;
+	}(a)), n;
+}
+var _e = /[^\\][$]/, ve = /[^\\[][\^]|^\^/;
+function ye(e) {
+	let t = e.ignoreCase ? "iy" : "y";
+	return RegExp(`${e.source}`, t);
+}
+function be(e) {
+	let t = e.PATTERN;
+	if (t instanceof RegExp) return !1;
+	if (typeof t == "function" || Object.hasOwn(t, "exec")) return !0;
+	if (typeof t == "string") return !1;
+	throw Error("non exhaustive match");
+}
+function xe(e) {
+	return typeof e == "string" && e.length === 1 && e.charCodeAt(0);
+}
+var Se = {
+	test: function(e) {
+		let t = e.length;
+		for (let n = this.lastIndex; n < t; n++) {
+			let t = e.charCodeAt(n);
+			if (t === 10) return this.lastIndex = n + 1, !0;
+			if (t === 13) return e.charCodeAt(n + 1) === 10 ? this.lastIndex = n + 2 : this.lastIndex = n + 1, !0;
+		}
+		return !1;
+	},
+	lastIndex: 0
+};
+function Ce(e, t) {
+	if (Object.hasOwn(e, "LINE_BREAKS")) return !1;
+	if (e.PATTERN instanceof RegExp) {
+		try {
+			pe(t, e.PATTERN);
+		} catch (e) {
+			return {
+				issue: H.IDENTIFY_TERMINATOR,
+				errMsg: e.message
+			};
+		}
+		return !1;
+	}
+	if (typeof e.PATTERN == "string") return !1;
+	if (be(e)) return { issue: H.CUSTOM_LINE_BREAK };
+	throw Error("non exhaustive match");
+}
+function we(e, t) {
+	if (t.issue === H.IDENTIFY_TERMINATOR) return `Warning: unable to identify line terminator usage in pattern.\n\tThe problem is in the <${e.name}> Token Type\n\t Root cause: ${t.errMsg}.\n\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#IDENTIFY_TERMINATOR`;
+	if (t.issue === H.CUSTOM_LINE_BREAK) return `Warning: A Custom Token Pattern should specify the <line_breaks> option.\n\tThe problem is in the <${e.name}> Token Type\n\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_LINE_BREAK`;
+	throw Error("non exhaustive match");
+}
+function Te(e) {
+	return e.map((e) => typeof e == "string" ? e.charCodeAt(0) : e);
+}
+function Ee(e, t, n) {
+	e[t] === void 0 ? e[t] = [n] : e[t].push(n);
+}
+var De = [];
+function z(e) {
+	return e < 256 ? e : De[e];
+}
+function B(e, t) {
+	let n = e.tokenTypeIdx;
+	return n === t.tokenTypeIdx || !0 === t.isParent && !0 === t.categoryMatchesMap[n];
+}
+function Oe(e, t) {
+	return e.tokenTypeIdx === t.tokenTypeIdx;
+}
+var ke = 1, Ae = {};
+function V(e) {
+	let t = function(e) {
+		let t = [...e], n = e, r = !0;
+		for (; r;) {
+			n = n.map((e) => e.CATEGORIES).flat().filter(Boolean);
+			let e = n.filter((e) => !t.includes(e));
+			t = t.concat(e), e.length === 0 ? r = !1 : n = e;
+		}
+		return t;
+	}(e);
+	(function(e) {
+		e.forEach((e) => {
+			var t;
+			Me(e) || (Ae[ke] = e, e.tokenTypeIdx = ke++), Ne(e) && !Array.isArray(e.CATEGORIES) && (e.CATEGORIES = [e.CATEGORIES]), Ne(e) || (e.CATEGORIES = []), t = e, Object.hasOwn(t ?? {}, "categoryMatches") || (e.categoryMatches = []), function(e) {
+				return Object.hasOwn(e ?? {}, "categoryMatchesMap");
+			}(e) || (e.categoryMatchesMap = {});
+		});
+	})(t), function(e) {
+		e.forEach((e) => {
+			je([], e);
+		});
+	}(t), function(e) {
+		e.forEach((e) => {
+			e.categoryMatches = [], Object.keys(e.categoryMatchesMap).forEach((t) => {
+				e.categoryMatches.push(Ae[t].tokenTypeIdx);
+			});
+		});
+	}(t), t.forEach((e) => {
+		e.isParent = e.categoryMatches.length > 0;
+	});
+}
+function je(e, t) {
+	e.forEach((e) => {
+		t.categoryMatchesMap[e.tokenTypeIdx] = !0;
+	}), t.CATEGORIES.forEach((n) => {
+		let r = e.concat(t);
+		r.includes(n) || je(r, n);
+	});
+}
+function Me(e) {
+	return Object.hasOwn(e ?? {}, "tokenTypeIdx");
+}
+function Ne(e) {
+	return Object.hasOwn(e ?? {}, "CATEGORIES");
+}
+function Pe(e) {
+	return Object.hasOwn(e ?? {}, "tokenTypeIdx");
+}
+var H, Fe = {
+	buildUnableToPopLexerModeMessage: (e) => `Unable to pop Lexer Mode after encountering Token ->${e.image}<- The Mode Stack is empty`,
+	buildUnexpectedCharactersMessage: (e, t, n, r, i, a) => `unexpected character: ->${e.charAt(t)}<- at offset: ${t}, skipped ${n} characters.`
+};
+(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";
+})(H ||= {});
+var U = {
+	deferDefinitionErrorsHandling: !1,
+	positionTracking: "full",
+	lineTerminatorsPattern: /\n|\r\n?/g,
+	lineTerminatorCharacters: ["\n", "\r"],
+	ensureOptimizations: !1,
+	safeMode: !1,
+	errorMessageProvider: Fe,
+	traceInitPerf: !1,
+	skipValidations: !1,
+	recoveryEnabled: !0
+};
+Object.freeze(U);
+var W = class {
+	constructor(e, t = U) {
+		if (this.lexerDefinition = e, this.lexerDefinitionErrors = [], this.lexerDefinitionWarning = [], this.patternIdxToConfig = {}, this.charCodeToPatternIdxToConfig = {}, this.modes = [], this.emptyGroups = {}, this.cachedGroupKeys = [], this.trackStartLines = !0, this.trackEndLines = !0, this.hasCustom = !1, this.canModeBeOptimized = {}, this.TRACE_INIT = (e, t) => {
+			if (!0 === this.traceInitPerf) {
+				this.traceInitIndent++;
+				let n = Array(this.traceInitIndent + 1).join("	");
+				this.traceInitIndent < this.traceInitMaxIdent && console.log(`${n}--\x3e <${e}>`);
+				let { time: r, value: a } = i(t), o = r > 10 ? console.warn : console.log;
+				return this.traceInitIndent < this.traceInitMaxIdent && o(`${n}<-- <${e}> time: ${r}ms`), this.traceInitIndent--, a;
+			}
+			return t();
+		}, typeof t == "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 = Object.assign({}, U, t);
+		let n = this.config.traceInitPerf;
+		!0 === n ? (this.traceInitMaxIdent = Infinity, this.traceInitPerf = !0) : typeof n == "number" && (this.traceInitMaxIdent = n, this.traceInitPerf = !0), this.traceInitIndent = -1, this.TRACE_INIT("Lexer Constructor", () => {
+			let n, i = !0;
+			this.TRACE_INIT("Lexer Config handling", () => {
+				if (this.config.lineTerminatorsPattern === U.lineTerminatorsPattern) this.config.lineTerminatorsPattern = Se;
+				else if (this.config.lineTerminatorCharacters === U.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 (t.safeMode && t.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), Array.isArray(e) ? n = {
+					modes: { defaultMode: [...e] },
+					defaultMode: me
+				} : (i = !1, n = Object.assign({}, e));
+			}), !1 === this.config.skipValidations && (this.TRACE_INIT("performRuntimeChecks", () => {
+				this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(function(e) {
+					let t = [];
+					return Object.hasOwn(e, "defaultMode") || t.push({
+						message: "A MultiMode Lexer cannot be initialized without a <defaultMode> property in its definition\n",
+						type: H.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE
+					}), Object.hasOwn(e, "modes") || t.push({
+						message: "A MultiMode Lexer cannot be initialized without a <modes> property in its definition\n",
+						type: H.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY
+					}), Object.hasOwn(e, "modes") && Object.hasOwn(e, "defaultMode") && !Object.hasOwn(e.modes, e.defaultMode) && t.push({
+						message: `A MultiMode Lexer cannot be initialized with a ${me}: <${e.defaultMode}>which does not exist\n`,
+						type: H.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST
+					}), Object.hasOwn(e, "modes") && Object.keys(e.modes).forEach((n) => {
+						let r = e.modes[n];
+						r.forEach((e, i) => {
+							e === void 0 ? t.push({
+								message: `A Lexer cannot be initialized using an undefined Token Type. Mode:<${n}> at index: <${i}>\n`,
+								type: H.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED
+							}) : Object.hasOwn(e, "LONGER_ALT") && (Array.isArray(e.LONGER_ALT) ? e.LONGER_ALT : [e.LONGER_ALT]).forEach((i) => {
+								i === void 0 || r.includes(i) || t.push({
+									message: `A MultiMode Lexer cannot be initialized with a longer_alt <${i.name}> on token <${e.name}> outside of mode <${n}>\n`,
+									type: H.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE
+								});
+							});
+						});
+					}), t;
+				}(n, this.trackStartLines, this.config.lineTerminatorCharacters));
+			}), this.TRACE_INIT("performWarningRuntimeChecks", () => {
+				this.lexerDefinitionWarning = this.lexerDefinitionWarning.concat(function(e, t, n) {
+					let r = [], i = !1, a = Object.values(e.modes || {}).flat().filter(Boolean).filter((e) => e[R] !== W.NA), o = Te(n);
+					return t && a.forEach((e) => {
+						let t = Ce(e, o);
+						if (!1 !== t) {
+							let n = {
+								message: we(e, t),
+								type: t.issue,
+								tokenType: e
+							};
+							r.push(n);
+						} else Object.hasOwn(e, "LINE_BREAKS") ? !0 === e.LINE_BREAKS && (i = !0) : pe(o, e.PATTERN) && (i = !0);
+					}), t && !i && r.push({
+						message: "Warning: No LINE_BREAKS Found.\n	This Lexer has been defined to track line and column information,\n	But none of the Token Types can be identified as matching a line terminator.\n	See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#LINE_BREAKS \n	for details.",
+						type: H.NO_LINE_BREAKS_FLAGS
+					}), r;
+				}(n, this.trackStartLines, this.config.lineTerminatorCharacters));
+			})), n.modes = n.modes ? n.modes : {}, Object.entries(n.modes).forEach(([e, t]) => {
+				n.modes[e] = t.filter((e) => e !== void 0);
+			});
+			let o = Object.keys(n.modes);
+			if (Object.entries(n.modes).forEach(([e, n]) => {
+				this.TRACE_INIT(`Mode: <${e}> processing`, () => {
+					if (this.modes.push(e), !1 === this.config.skipValidations && this.TRACE_INIT("validatePatterns", () => {
+						this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(ge(n, o));
+					}), this.lexerDefinitionErrors.length === 0) {
+						let r;
+						V(n), this.TRACE_INIT("analyzeTokenTypes", () => {
+							r = he(n, {
+								lineTerminatorCharacters: this.config.lineTerminatorCharacters,
+								positionTracking: t.positionTracking,
+								ensureOptimizations: t.ensureOptimizations,
+								safeMode: t.safeMode,
+								tracer: this.TRACE_INIT
+							});
+						}), this.patternIdxToConfig[e] = r.patternIdxToConfig, this.charCodeToPatternIdxToConfig[e] = r.charCodeToPatternIdxToConfig, this.emptyGroups = Object.assign({}, this.emptyGroups, r.emptyGroups), this.hasCustom = r.hasCustom || this.hasCustom, this.canModeBeOptimized[e] = r.canBeOptimized;
+					}
+				});
+			}), this.defaultMode = n.defaultMode, this.cachedGroupKeys = Object.keys(this.emptyGroups), this.lexerDefinitionErrors.length > 0 && !this.config.deferDefinitionErrorsHandling) {
+				let e = this.lexerDefinitionErrors.map((e) => e.message).join("-----------------------\n");
+				throw Error("Errors detected in definition of Lexer:\n" + e);
+			}
+			this.lexerDefinitionWarning.forEach((e) => {
+				r(e.message);
+			}), this.TRACE_INIT("Choosing sub-methods implementations", () => {
+				if (i && (this.handleModes = () => {}), !1 === this.trackStartLines && (this.computeNewColumn = (e) => e), !1 === this.trackEndLines && (this.updateTokenEndLineColumnLocation = () => {}), /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)) throw Error(`Invalid <positionTracking> config option: "${this.config.positionTracking}"`);
+					this.createTokenInstance = this.createOffsetOnlyToken;
+				}
+				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 = Object.entries(this.canModeBeOptimized).reduce((e, [t, n]) => (!1 === n && e.push(t), e), []);
+				if (t.ensureOptimizations && e.length > 0) throw Error(`Lexer Modes: < ${e.join(", ")} > cannot be optimized.\n\t Disable the "ensureOptimizations" lexer config flag to silently ignore this and run the lexer in an un-optimized mode.\n\t Or inspect the console log for details on how to resolve these issues.`);
+			}), this.TRACE_INIT("clearRegExpParserCache", () => {
+				L = {};
+			}), this.TRACE_INIT("toFastProperties", () => {
+				a(this);
+			});
+		});
+	}
+	tokenize(e, t = this.defaultMode) {
+		if (this.lexerDefinitionErrors.length > 0) {
+			let e = this.lexerDefinitionErrors.map((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, s, c, l, u, d, f, p, m, h, g, _ = e, v = _.length, y = 0, b = 0, x = this.hasCustom ? 0 : Math.floor(e.length / 10), S = Array(x), C = [], w = this.trackStartLines ? 1 : void 0, T = this.trackStartLines ? 1 : void 0, E = {};
+		for (let e = 0; e < this.cachedGroupKeys.length; e++) E[this.cachedGroupKeys[e]] = [];
+		let D = this.trackStartLines, O = this.config.lineTerminatorsPattern, k = 0, A = [], j = [], M = [], N = [];
+		Object.freeze(N);
+		let P = !1, ee = (e) => {
+			if (M.length === 1 && e.tokenType.PUSH_MODE === void 0) {
+				let t = this.config.errorMessageProvider.buildUnableToPopLexerModeMessage(e);
+				C.push({
+					offset: e.startOffset,
+					line: e.startLine,
+					column: e.startColumn,
+					length: e.image.length,
+					message: t
+				});
+			} else {
+				M.pop();
+				let e = M.at(-1);
+				A = this.patternIdxToConfig[e], j = this.charCodeToPatternIdxToConfig[e], k = A.length;
+				let t = this.canModeBeOptimized[e] && !1 === this.config.safeMode;
+				P = !(!j || !t);
+			}
+		};
+		function te(e) {
+			M.push(e), j = this.charCodeToPatternIdxToConfig[e], A = this.patternIdxToConfig[e], k = A.length;
+			let t = this.canModeBeOptimized[e] && !1 === this.config.safeMode;
+			P = !(!j || !t);
+		}
+		let F;
+		te.call(this, t);
+		let ne = this.config.recoveryEnabled;
+		for (; y < v;) {
+			s = null, u = -1;
+			let t = _.charCodeAt(y), x;
+			if (P) {
+				let e = z(t), n = j[e];
+				x = n === void 0 ? N : n;
+			} else x = A;
+			let I = x.length;
+			for (n = 0; n < I; n++) {
+				F = x[n];
+				let r = F.pattern;
+				c = null;
+				let d = F.short;
+				if (!1 === d ? !0 === F.isCustom ? (g = r.exec(_, y, S, E), g === null ? s = null : (s = g[0], u = s.length, g.payload !== void 0 && (c = g.payload))) : (r.lastIndex = y, u = this.matchLength(r, e, y)) : t === d && (u = 1, s = r), u !== -1) {
+					if (o = F.longerAlt, o !== void 0) {
+						s = e.substring(y, y + u);
+						let t = o.length;
+						for (i = 0; i < t; i++) {
+							let t = A[o[i]], n = t.pattern;
+							if (l = null, !0 === t.isCustom ? (g = n.exec(_, y, S, E), g === null ? a = null : (a = g[0], g.payload !== void 0 && (l = g.payload))) : (n.lastIndex = y, a = this.match(n, e, y)), a && a.length > s.length) {
+								s = a, u = a.length, c = l, F = t;
+								break;
+							}
+						}
+					}
+					break;
+				}
+			}
+			if (u !== -1) {
+				if (d = F.group, d !== void 0 && (s = s === null ? e.substring(y, y + u) : s, f = F.tokenTypeIdx, p = this.createTokenInstance(s, y, f, F.tokenType, w, T, u), this.handlePayload(p, c), !1 === d ? b = this.addToken(S, b, p) : E[d].push(p)), !0 === D && !0 === F.canLineTerminator) {
+					let t, n, r = 0;
+					O.lastIndex = 0;
+					do
+						s = s === null ? e.substring(y, y + u) : s, t = O.test(s), !0 === t && (n = O.lastIndex - 1, r++);
+					while (!0 === t);
+					r === 0 ? T = this.computeNewColumn(T, u) : (w += r, T = u - n, this.updateTokenEndLineColumnLocation(p, d, n, r, w, T, u));
+				} else T = this.computeNewColumn(T, u);
+				y += u, this.handleModes(F, ee, te, p);
+			} else {
+				let t = y, n = w, i = T, a = !1 === ne;
+				for (; !1 === a && y < v;) for (y++, r = 0; r < k; r++) {
+					let t = A[r], n = t.pattern, i = t.short;
+					if (!1 === i ? !0 === t.isCustom ? a = n.exec(_, y, S, E) !== null : (n.lastIndex = y, a = n.exec(e) !== null) : _.charCodeAt(y) === i && (a = !0), !0 === a) break;
+				}
+				if (m = y - t, T = this.computeNewColumn(T, m), h = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(_, t, m, n, i, M.at(-1)), C.push({
+					offset: t,
+					line: n,
+					column: i,
+					length: m,
+					message: h
+				}), !1 === ne) break;
+			}
+		}
+		return this.hasCustom || (S.length = b), {
+			tokens: S,
+			groups: E,
+			errors: C
+		};
+	}
+	handleModes(e, t, n, r) {
+		if (!0 === e.pop) {
+			let i = e.push;
+			t(r), i !== void 0 && n.call(this, i);
+		} else e.push !== void 0 && n.call(this, e.push);
+	}
+	updateTokenEndLineColumnLocation(e, t, n, r, i, a, o) {
+		let s, c;
+		t !== void 0 && (s = n === o - 1, c = s ? -1 : 0, r === 1 && !0 === s || (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;
+	}
+	handlePayloadNoCustom(e, t) {}
+	handlePayloadWithCustom(e, t) {
+		t !== null && (e.payload = t);
+	}
+	match(e, t, n) {
+		return !0 === e.test(t) ? t.substring(n, e.lastIndex) : null;
+	}
+	matchLength(e, t, n) {
+		return !0 === e.test(t) ? e.lastIndex - n : -1;
+	}
+};
+function G(e) {
+	return Ie(e) ? e.LABEL : e.name;
+}
+function Ie(e) {
+	return typeof e.LABEL == "string" && e.LABEL !== "";
+}
+W.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.", W.NA = /NOT_APPLICABLE/;
+var Le = "parent", Re = "categories", ze = "label", Be = "group", Ve = "push_mode", He = "pop_mode", Ue = "longer_alt", We = "line_breaks", Ge = "start_chars_hint";
+function K(e) {
+	return function(e) {
+		let t = e.pattern, n = {};
+		if (n.name = e.name, t !== void 0 && (n.PATTERN = t), Object.hasOwn(e, Le)) throw "The parent property is no longer supported.\nSee: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.";
+		return Object.hasOwn(e, Re) && (n.CATEGORIES = e[Re]), V([n]), Object.hasOwn(e, ze) && (n.LABEL = e[ze]), Object.hasOwn(e, Be) && (n.GROUP = e[Be]), Object.hasOwn(e, He) && (n.POP_MODE = e[He]), Object.hasOwn(e, Ve) && (n.PUSH_MODE = e[Ve]), Object.hasOwn(e, Ue) && (n.LONGER_ALT = e[Ue]), Object.hasOwn(e, We) && (n.LINE_BREAKS = e[We]), Object.hasOwn(e, Ge) && (n.START_CHARS_HINT = e[Ge]), n;
+	}(e);
+}
+var q = K({
+	name: "EOF",
+	pattern: W.NA
+});
+function Ke(e, t, n, r, i, a, o, s) {
+	return {
+		image: t,
+		startOffset: n,
+		endOffset: r,
+		startLine: i,
+		endLine: a,
+		startColumn: o,
+		endColumn: s,
+		tokenTypeIdx: e.tokenTypeIdx,
+		tokenType: e
+	};
+}
+V([q]);
+var qe = {
+	buildMismatchTokenMessage: ({ expected: e, actual: t, previous: n, ruleName: r }) => `Expecting ${Ie(e) ? `--\x3e ${G(e)} <--` : `token of type --\x3e ${e.name} <--`} but found --\x3e '${t.image}' <--`,
+	buildNotAllInputParsedMessage: ({ firstRedundant: e, ruleName: t }) => "Redundant input, expecting EOF but found: " + e.image,
+	buildNoViableAltMessage({ expectedPathsPerAlt: e, actual: t, previous: n, customUserDescription: r, ruleName: i }) {
+		let a = "\nbut found: '" + t[0].image + "'";
+		return r ? "Expecting: " + r + a : `Expecting: one of these possible Token sequences:\n${e.reduce((e, t) => e.concat(t), []).map((e) => `[${e.map((e) => G(e)).join(", ")}]`).map((e, t) => `  ${t + 1}. ${e}`).join("\n")}` + a;
+	},
+	buildEarlyExitMessage({ expectedIterationPaths: e, actual: t, customUserDescription: n, ruleName: r }) {
+		let i = "\nbut found: '" + t[0].image + "'";
+		return n ? "Expecting: " + n + i : `Expecting: expecting at least one iteration which starts with one of these possible Token sequences::\n  <${e.map((e) => `[${e.map((e) => G(e)).join(",")}]`).join(" ,")}>` + i;
+	}
+};
+Object.freeze(qe);
+var Je = { buildRuleNotFoundError: (e, t) => "Invalid grammar, reference to a rule which is not defined: ->" + t.nonTerminalName + "<-\ninside top level rule: ->" + e.name + "<-" }, J = {
+	buildDuplicateFoundError(e, t) {
+		let n = e.name, r = t[0], i = r.idx, a = x(r), o = (c = r) instanceof g ? c.terminalType.name : c instanceof s ? c.nonTerminalName : "";
+		var c;
+		let l = `->${a}${i > 0 ? i : ""}<- ${o ? `with argument: ->${o}<-` : ""}\n                  appears more than once (${t.length} times) in the top level rule: ->${n}<-.                  \n                  For further details see: https://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES \n                  `;
+		return l = l.replace(/[ \t]+/g, " "), l = l.replace(/\s\s+/g, "\n"), l;
+	},
+	buildNamespaceConflictError: (e) => `Namespace conflict found in grammar.\nThe grammar has both a Terminal(Token) and a Non-Terminal(Rule) named: <${e.name}>.\nTo resolve this make sure each Terminal and Non-Terminal names are unique\nThis is easy to accomplish by using the convention that Terminal names start with an uppercase letter\nand Non-Terminal names start with a lower case letter.`,
+	buildAlternationPrefixAmbiguityError(e) {
+		let t = e.prefixPath.map((e) => G(e)).join(", "), n = e.alternation.idx === 0 ? "" : e.alternation.idx;
+		return `Ambiguous alternatives: <${e.ambiguityIndices.join(" ,")}> due to common lookahead prefix\nin <OR${n}> inside <${e.topLevelRule.name}> Rule,\n<${t}> may appears as a prefix path in all these alternatives.\nSee: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#COMMON_PREFIX\nFor Further details.`;
+	},
+	buildAlternationAmbiguityError(e) {
+		let t = e.alternation.idx === 0 ? "" : e.alternation.idx, n = e.prefixPath.length === 0, r = `Ambiguous Alternatives Detected: <${e.ambiguityIndices.join(" ,")}> in <OR${t}> inside <${e.topLevelRule.name}> Rule,\n`;
+		return n ? r += "These alternatives are all empty (match no tokens), making them indistinguishable.\nOnly the last alternative may be empty.\n" : r += `<${e.prefixPath.map((e) => G(e)).join(", ")}> may appears as a prefix path in all these alternatives.\n`, r += "See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\nFor Further details.", r;
+	},
+	buildEmptyRepetitionError(e) {
+		let t = x(e.repetition);
+		return e.repetition.idx !== 0 && (t += e.repetition.idx), `The repetition <${t}> within Rule <${e.topLevelRule.name}> can never consume any tokens.\nThis could lead to an infinite loop.`;
+	},
+	buildTokenNameError: (e) => "deprecated",
+	buildEmptyAlternationError: (e) => `Ambiguous empty alternative: <${e.emptyChoiceIdx + 1}> in <OR${e.alternation.idx}> inside <${e.topLevelRule.name}> Rule.\nOnly the last alternative may be an empty alternative.`,
+	buildTooManyAlternativesError: (e) => `An Alternation cannot have more than 256 alternatives:\n<OR${e.alternation.idx}> inside <${e.topLevelRule.name}> Rule.\n has ${e.alternation.definition.length + 1} alternatives.`,
+	buildLeftRecursionError(e) {
+		let t = e.topLevelRule.name;
+		return `Left Recursion found in grammar.\nrule: <${t}> can be invoked from itself (directly or indirectly)\nwithout consuming any Tokens. The grammar path that causes this is: \n ${t} --\x3e ${e.leftRecursionPath.map((e) => e.name).concat([t]).join(" --> ")}\n To fix this refactor your grammar to remove the left recursion.\nsee: https://en.wikipedia.org/wiki/LL_parser#Left_factoring.`;
+	},
+	buildInvalidRuleNameError: (e) => "deprecated",
+	buildDuplicateRuleNameError(e) {
+		let t;
+		return t = e.topLevelRule instanceof c ? e.topLevelRule.name : e.topLevelRule, `Duplicate definition, rule: ->${t}<- is already defined in the grammar: ->${e.grammarName}<-`;
+	}
+}, Y, Ye = class extends y {
+	constructor(e, t) {
+		super(), this.nameToTopRule = e, this.errMsgProvider = t, this.errors = [];
+	}
+	resolveRefs() {
+		Object.values(this.nameToTopRule).forEach((e) => {
+			this.currTopLevel = e, e.accept(this);
+		});
+	}
+	visitNonTerminal(e) {
+		let t = this.nameToTopRule[e.nonTerminalName];
+		if (t) e.referencedRule = t;
+		else {
+			let t = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, e);
+			this.errors.push({
+				message: t,
+				type: Q.UNRESOLVED_SUBRULE_REF,
+				ruleName: this.currTopLevel.name,
+				unresolvedRefName: e.nonTerminalName
+			});
+		}
+	}
+}, Xe = class extends S {
+	constructor(e, t) {
+		super(), this.topProd = e, this.path = t, this.possibleTokTypes = [], this.nextProductionName = "", this.nextProductionOccurrence = 0, this.found = !1, this.isAtEndOfPath = !1;
+	}
+	startWalking() {
+		if (this.found = !1, this.path.ruleStack[0] !== this.topProd.name) throw Error("The path does not start with the walker's top Rule!");
+		return this.ruleStack = [...this.path.ruleStack].reverse(), this.occurrenceStack = [...this.path.occurrenceStack].reverse(), this.ruleStack.pop(), this.occurrenceStack.pop(), this.updateExpectedNext(), this.walk(this.topProd), this.possibleTokTypes;
+	}
+	walk(e, t = []) {
+		this.found || super.walk(e, t);
+	}
+	walkProdRef(e, t, n) {
+		if (e.referencedRule.name === this.nextProductionName && e.idx === this.nextProductionOccurrence) {
+			let r = t.concat(n);
+			this.updateExpectedNext(), this.walk(e.referencedRule, r);
+		}
+	}
+	updateExpectedNext() {
+		this.ruleStack.length === 0 ? (this.nextProductionName = "", this.nextProductionOccurrence = 0, this.isAtEndOfPath = !0) : (this.nextProductionName = this.ruleStack.pop(), this.nextProductionOccurrence = this.occurrenceStack.pop());
+	}
+}, Ze = class extends Xe {
+	constructor(e, t) {
+		super(e, t), this.path = t, this.nextTerminalName = "", this.nextTerminalOccurrence = 0, this.nextTerminalName = this.path.lastTok.name, this.nextTerminalOccurrence = this.path.lastTokOccurrence;
+	}
+	walkTerminal(e, t, n) {
+		if (this.isAtEndOfPath && e.terminalType.name === this.nextTerminalName && e.idx === this.nextTerminalOccurrence && !this.found) {
+			let e = new l({ definition: t.concat(n) });
+			this.possibleTokTypes = w(e), this.found = !0;
+		}
+	}
+}, Qe = class extends S {
+	constructor(e, t) {
+		super(), this.topRule = e, this.occurrence = t, this.result = {
+			token: void 0,
+			occurrence: void 0,
+			isEndOfRule: void 0
+		};
+	}
+	startWalking() {
+		return this.walk(this.topRule), this.result;
+	}
+}, $e = class extends Qe {
+	walkMany(e, t, n) {
+		if (e.idx === this.occurrence) {
+			let e = t.concat(n)[0];
+			this.result.isEndOfRule = e === void 0, e instanceof g && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkMany(e, t, n);
+	}
+}, et = class extends Qe {
+	walkManySep(e, t, n) {
+		if (e.idx === this.occurrence) {
+			let e = t.concat(n)[0];
+			this.result.isEndOfRule = e === void 0, e instanceof g && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkManySep(e, t, n);
+	}
+}, tt = class extends Qe {
+	walkAtLeastOne(e, t, n) {
+		if (e.idx === this.occurrence) {
+			let e = t.concat(n)[0];
+			this.result.isEndOfRule = e === void 0, e instanceof g && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkAtLeastOne(e, t, n);
+	}
+}, nt = class extends Qe {
+	walkAtLeastOneSep(e, t, n) {
+		if (e.idx === this.occurrence) {
+			let e = t.concat(n)[0];
+			this.result.isEndOfRule = e === void 0, e instanceof g && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkAtLeastOneSep(e, t, n);
+	}
+};
+function rt(e, t, n = []) {
+	n = [...n];
+	let r = [], i = 0;
+	function a(a) {
+		let o = rt(a.concat(e.slice(i + 1)), t, n);
+		return r.concat(o);
+	}
+	for (; n.length < t && i < e.length;) {
+		let t = e[i];
+		if (t instanceof l || t instanceof s) return a(t.definition);
+		if (t instanceof u) r = a(t.definition);
+		else {
+			if (t instanceof d) return a(t.definition.concat([new p({ definition: t.definition })]));
+			if (t instanceof f) return a([new l({ definition: t.definition }), new p({ definition: [new g({ terminalType: t.separator })].concat(t.definition) })]);
+			if (t instanceof m) r = a(t.definition.concat([new p({ definition: [new g({ terminalType: t.separator })].concat(t.definition) })]));
+			else if (t instanceof p) r = a(t.definition.concat([new p({ definition: t.definition })]));
+			else {
+				if (t instanceof h) return t.definition.forEach((e) => {
+					e.definition.length !== 0 && (r = a(e.definition));
+				}), r;
+				if (!(t instanceof g)) throw Error("non exhaustive match");
+				n.push(t.terminalType);
+			}
+		}
+		i++;
+	}
+	return r.push({
+		partialPath: n,
+		suffixDef: e.slice(i)
+	}), r;
+}
+function it(e, t, n, r) {
+	let i = [...n];
+	i.push(e.name);
+	let a = [...r];
+	return a.push(1), {
+		idx: t,
+		def: e.definition,
+		ruleStack: i,
+		occurrenceStack: a
+	};
+}
+function at(e) {
+	if (e instanceof u || e === "Option") return Y.OPTION;
+	if (e instanceof p || e === "Repetition") return Y.REPETITION;
+	if (e instanceof d || e === "RepetitionMandatory") return Y.REPETITION_MANDATORY;
+	if (e instanceof f || e === "RepetitionMandatoryWithSeparator") return Y.REPETITION_MANDATORY_WITH_SEPARATOR;
+	if (e instanceof m || e === "RepetitionWithSeparator") return Y.REPETITION_WITH_SEPARATOR;
+	if (e instanceof h || e === "Alternation") return Y.ALTERNATION;
+	throw Error("non exhaustive match");
+}
+function ot(e, t, n, r) {
+	let i = e.length, a = e.every((e) => e.every((e) => e.length === 1));
+	if (t) return function(t) {
+		let r = t.map((e) => e.GATE);
+		for (let t = 0; t < i; t++) {
+			let i = e[t], a = i.length, o = r[t];
+			if (o === void 0 || !1 !== o.call(this)) e: for (let e = 0; e < a; e++) {
+				let r = i[e], a = r.length;
+				for (let e = 0; e < a; e++) if (!1 === n(this.LA_FAST(e + 1), r[e])) continue e;
+				return t;
+			}
+		}
+	};
+	if (a && !r) {
+		let t = e.map((e) => e.flat()).reduce((e, t, n) => (t.forEach((t) => {
+			t.tokenTypeIdx in e || (e[t.tokenTypeIdx] = n), t.categoryMatches.forEach((t) => {
+				Object.hasOwn(e, t) || (e[t] = n);
+			});
+		}), e), {});
+		return function() {
+			let e = this.LA_FAST(1);
+			return t[e.tokenTypeIdx];
+		};
+	}
+	return function() {
+		for (let t = 0; t < i; t++) {
+			let r = e[t], i = r.length;
+			e: for (let e = 0; e < i; e++) {
+				let i = r[e], a = i.length;
+				for (let e = 0; e < a; e++) if (!1 === n(this.LA_FAST(e + 1), i[e])) continue e;
+				return t;
+			}
+		}
+	};
+}
+function st(e, t, n) {
+	let r = e.every((e) => e.length === 1), i = e.length;
+	if (r && !n) {
+		let t = e.flat();
+		if (t.length === 1 && t[0].categoryMatches.length === 0) {
+			let e = t[0].tokenTypeIdx;
+			return function() {
+				return this.LA_FAST(1).tokenTypeIdx === e;
+			};
+		}
+		{
+			let e = t.reduce((e, t, n) => (e[t.tokenTypeIdx] = !0, t.categoryMatches.forEach((t) => {
+				e[t] = !0;
+			}), e), []);
+			return function() {
+				let t = this.LA_FAST(1);
+				return !0 === e[t.tokenTypeIdx];
+			};
+		}
+	}
+	return function() {
+		e: for (let n = 0; n < i; n++) {
+			let r = e[n], i = r.length;
+			for (let e = 0; e < i; e++) if (!1 === t(this.LA_FAST(e + 1), r[e])) continue e;
+			return !0;
+		}
+		return !1;
+	};
+}
+(function(e) {
+	e[e.OPTION = 0] = "OPTION", e[e.REPETITION = 1] = "REPETITION", e[e.REPETITION_MANDATORY = 2] = "REPETITION_MANDATORY", e[e.REPETITION_MANDATORY_WITH_SEPARATOR = 3] = "REPETITION_MANDATORY_WITH_SEPARATOR", e[e.REPETITION_WITH_SEPARATOR = 4] = "REPETITION_WITH_SEPARATOR", e[e.ALTERNATION = 5] = "ALTERNATION";
+})(Y ||= {});
+var ct = class extends S {
+	constructor(e, t, n) {
+		super(), this.topProd = e, this.targetOccurrence = t, this.targetProdType = n;
+	}
+	startWalking() {
+		return this.walk(this.topProd), this.restDef;
+	}
+	checkIsTarget(e, t, n, r) {
+		return e.idx === this.targetOccurrence && this.targetProdType === t && (this.restDef = n.concat(r), !0);
+	}
+	walkOption(e, t, n) {
+		this.checkIsTarget(e, Y.OPTION, t, n) || super.walkOption(e, t, n);
+	}
+	walkAtLeastOne(e, t, n) {
+		this.checkIsTarget(e, Y.REPETITION_MANDATORY, t, n) || super.walkOption(e, t, n);
+	}
+	walkAtLeastOneSep(e, t, n) {
+		this.checkIsTarget(e, Y.REPETITION_MANDATORY_WITH_SEPARATOR, t, n) || super.walkOption(e, t, n);
+	}
+	walkMany(e, t, n) {
+		this.checkIsTarget(e, Y.REPETITION, t, n) || super.walkOption(e, t, n);
+	}
+	walkManySep(e, t, n) {
+		this.checkIsTarget(e, Y.REPETITION_WITH_SEPARATOR, t, n) || super.walkOption(e, t, n);
+	}
+}, lt = class extends y {
+	constructor(e, t, n) {
+		super(), this.targetOccurrence = e, this.targetProdType = t, this.targetRef = n, this.result = [];
+	}
+	checkIsTarget(e, t) {
+		e.idx !== this.targetOccurrence || this.targetProdType !== t || this.targetRef !== void 0 && e !== this.targetRef || (this.result = e.definition);
+	}
+	visitOption(e) {
+		this.checkIsTarget(e, Y.OPTION);
+	}
+	visitRepetition(e) {
+		this.checkIsTarget(e, Y.REPETITION);
+	}
+	visitRepetitionMandatory(e) {
+		this.checkIsTarget(e, Y.REPETITION_MANDATORY);
+	}
+	visitRepetitionMandatoryWithSeparator(e) {
+		this.checkIsTarget(e, Y.REPETITION_MANDATORY_WITH_SEPARATOR);
+	}
+	visitRepetitionWithSeparator(e) {
+		this.checkIsTarget(e, Y.REPETITION_WITH_SEPARATOR);
+	}
+	visitAlternation(e) {
+		this.checkIsTarget(e, Y.ALTERNATION);
+	}
+};
+function ut(e) {
+	let t = Array(e);
+	for (let n = 0; n < e; n++) t[n] = [];
+	return t;
+}
+function dt(e) {
+	let t = [""];
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n], i = [];
+		for (let e = 0; e < t.length; e++) {
+			let n = t[e];
+			i.push(n + "_" + r.tokenTypeIdx);
+			for (let e = 0; e < r.categoryMatches.length; e++) {
+				let t = "_" + r.categoryMatches[e];
+				i.push(n + t);
+			}
+		}
+		t = i;
+	}
+	return t;
+}
+function ft(e, t, n) {
+	for (let r = 0; r < e.length; r++) {
+		if (r === n) continue;
+		let i = e[r];
+		for (let e = 0; e < t.length; e++) if (!0 === i[t[e]]) return !1;
+	}
+	return !0;
+}
+function pt(e, t) {
+	let n = e.map((e) => rt([e], 1)), r = ut(n.length), i = n.map((e) => {
+		let t = {};
+		return e.forEach((e) => {
+			dt(e.partialPath).forEach((e) => {
+				t[e] = !0;
+			});
+		}), t;
+	}), a = n;
+	for (let e = 1; e <= t; e++) {
+		let n = a;
+		a = ut(n.length);
+		for (let o = 0; o < n.length; o++) {
+			let s = n[o];
+			for (let n = 0; n < s.length; n++) {
+				let c = s[n].partialPath, l = s[n].suffixDef, u = dt(c);
+				if (ft(i, u, o) || l.length === 0 || c.length === t) {
+					let e = r[o];
+					if (!1 === gt(e, c)) {
+						e.push(c);
+						for (let e = 0; e < u.length; e++) {
+							let t = u[e];
+							i[o][t] = !0;
+						}
+					}
+				} else {
+					let t = rt(l, e + 1, c);
+					a[o] = a[o].concat(t), t.forEach((e) => {
+						dt(e.partialPath).forEach((e) => {
+							i[o][e] = !0;
+						});
+					});
+				}
+			}
+		}
+	}
+	return r;
+}
+function mt(e, t, n, r) {
+	let i = new lt(e, Y.ALTERNATION, r);
+	return t.accept(i), pt(i.result, n);
+}
+function ht(e, t, n, r) {
+	let i = new lt(e, n);
+	t.accept(i);
+	let a = i.result, o = new ct(t, e, n).startWalking();
+	return pt([new l({ definition: a }), new l({ definition: o })], r);
+}
+function gt(e, t) {
+	e: for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		if (r.length === t.length) {
+			for (let e = 0; e < r.length; e++) {
+				let n = t[e], i = r[e];
+				if ((n === i || i.categoryMatchesMap[n.tokenTypeIdx] !== void 0) == 0) continue e;
+			}
+			return !0;
+		}
+	}
+	return !1;
+}
+function _t(e) {
+	return e.every((e) => e.every((e) => e.every((e) => e.categoryMatches.length === 0)));
+}
+function vt(e, t, n, r) {
+	let i = e.flatMap((e) => function(e, t) {
+		let n = new xt();
+		e.accept(n);
+		let r = n.allProductions, i = Object.groupBy(r, yt), a = Object.fromEntries(Object.entries(i).filter(([e, t]) => t.length > 1));
+		return Object.values(a).map((n) => {
+			let r = n[0], i = t.buildDuplicateFoundError(e, n), a = x(r), o = {
+				message: i,
+				type: Q.DUPLICATE_PRODUCTIONS,
+				ruleName: e.name,
+				dslName: a,
+				occurrence: r.idx
+			}, s = bt(r);
+			return s && (o.parameter = s), o;
+		});
+	}(e, n)), a = function(e, t, n) {
+		let r = [], i = t.map((e) => e.name);
+		return e.forEach((e) => {
+			let t = e.name;
+			if (i.includes(t)) {
+				let i = n.buildNamespaceConflictError(e);
+				r.push({
+					message: i,
+					type: Q.CONFLICT_TOKENS_RULES_NAMESPACE,
+					ruleName: t
+				});
+			}
+		}), r;
+	}(e, t, n), o = e.flatMap((e) => function(e, t) {
+		let n = new wt();
+		return e.accept(n), n.alternations.flatMap((n) => n.definition.length > 255 ? [{
+			message: t.buildTooManyAlternativesError({
+				topLevelRule: e,
+				alternation: n
+			}),
+			type: Q.TOO_MANY_ALTS,
+			ruleName: e.name,
+			occurrence: n.idx
+		}] : []);
+	}(e, n)), s = e.flatMap((t) => function(e, t, n, r) {
+		let i = [];
+		if (t.reduce((t, n) => n.name === e.name ? t + 1 : t, 0) > 1) {
+			let t = r.buildDuplicateRuleNameError({
+				topLevelRule: e,
+				grammarName: n
+			});
+			i.push({
+				message: t,
+				type: Q.DUPLICATE_RULE_NAME,
+				ruleName: e.name
+			});
+		}
+		return i;
+	}(t, e, r, n));
+	return i.concat(a, o, s);
+}
+function yt(e) {
+	return `${x(e)}_#_${e.idx}_#_${bt(e)}`;
+}
+function bt(e) {
+	return e instanceof g ? e.terminalType.name : e instanceof s ? e.nonTerminalName : "";
+}
+var xt = class extends y {
+	constructor() {
+		super(...arguments), this.allProductions = [];
+	}
+	visitNonTerminal(e) {
+		this.allProductions.push(e);
+	}
+	visitOption(e) {
+		this.allProductions.push(e);
+	}
+	visitRepetitionWithSeparator(e) {
+		this.allProductions.push(e);
+	}
+	visitRepetitionMandatory(e) {
+		this.allProductions.push(e);
+	}
+	visitRepetitionMandatoryWithSeparator(e) {
+		this.allProductions.push(e);
+	}
+	visitRepetition(e) {
+		this.allProductions.push(e);
+	}
+	visitAlternation(e) {
+		this.allProductions.push(e);
+	}
+	visitTerminal(e) {
+		this.allProductions.push(e);
+	}
+};
+function St(e, t, n, r = []) {
+	let i = [], a = Ct(t.definition);
+	if (a.length === 0) return [];
+	{
+		let t = e.name;
+		a.includes(e) && i.push({
+			message: n.buildLeftRecursionError({
+				topLevelRule: e,
+				leftRecursionPath: r
+			}),
+			type: Q.LEFT_RECURSION,
+			ruleName: t
+		});
+		let o = r.concat([e]), s = a.filter((e) => !o.includes(e)).flatMap((t) => {
+			let i = [...r];
+			return i.push(t), St(e, t, n, i);
+		});
+		return i.concat(s);
+	}
+}
+function Ct(e) {
+	let t = [];
+	if (e.length === 0) return t;
+	let n = e[0];
+	if (n instanceof s) t.push(n.referencedRule);
+	else if (n instanceof l || n instanceof u || n instanceof d || n instanceof f || n instanceof m || n instanceof p) t = t.concat(Ct(n.definition));
+	else if (n instanceof h) t = n.definition.map((e) => Ct(e.definition)).flat();
+	else if (!(n instanceof g)) throw Error("non exhaustive match");
+	let r = b(n), i = e.length > 1;
+	if (r && i) {
+		let n = e.slice(1);
+		return t.concat(Ct(n));
+	}
+	return t;
+}
+var wt = class extends y {
+	constructor() {
+		super(...arguments), this.alternations = [];
+	}
+	visitAlternation(e) {
+		this.alternations.push(e);
+	}
+};
+function Tt(e, t) {
+	let n = new wt();
+	return e.accept(n), n.alternations.flatMap((n) => n.definition.slice(0, -1).flatMap((r, i) => function(e, t, n, r) {
+		let i = "EXIT_NONE_TERMINAL", a = [i], o = "EXIT_ALTERNATIVE", _ = !1, v = t.length, y = v - r - 1, b = [], x = [];
+		for (x.push({
+			idx: -1,
+			def: e,
+			ruleStack: [],
+			occurrenceStack: []
+		}); x.length !== 0;) {
+			let e = x.pop();
+			if (e === o) {
+				_ && x.at(-1).idx <= y && x.pop();
+				continue;
+			}
+			let r = e.def, S = e.idx, C = e.ruleStack, w = e.occurrenceStack;
+			if (r.length === 0) continue;
+			let T = r[0];
+			if (T === i) {
+				let e = {
+					idx: S,
+					def: r.slice(1),
+					ruleStack: C.slice(0, -1),
+					occurrenceStack: w.slice(0, -1)
+				};
+				x.push(e);
+			} else if (T instanceof g) if (S < v - 1) {
+				let e = S + 1;
+				if (n(t[e], T.terminalType)) {
+					let t = {
+						idx: e,
+						def: r.slice(1),
+						ruleStack: C,
+						occurrenceStack: w
+					};
+					x.push(t);
+				}
+			} else {
+				if (S !== v - 1) throw Error("non exhaustive match");
+				b.push({
+					nextTokenType: T.terminalType,
+					nextTokenOccurrence: T.idx,
+					ruleStack: C,
+					occurrenceStack: w
+				}), _ = !0;
+			}
+			else if (T instanceof s) {
+				let e = [...C];
+				e.push(T.nonTerminalName);
+				let t = [...w];
+				t.push(T.idx);
+				let n = {
+					idx: S,
+					def: T.definition.concat(a, r.slice(1)),
+					ruleStack: e,
+					occurrenceStack: t
+				};
+				x.push(n);
+			} else if (T instanceof u) {
+				let e = {
+					idx: S,
+					def: r.slice(1),
+					ruleStack: C,
+					occurrenceStack: w
+				};
+				x.push(e), x.push(o);
+				let t = {
+					idx: S,
+					def: T.definition.concat(r.slice(1)),
+					ruleStack: C,
+					occurrenceStack: w
+				};
+				x.push(t);
+			} else if (T instanceof d) {
+				let e = new p({
+					definition: T.definition,
+					idx: T.idx
+				}), t = {
+					idx: S,
+					def: T.definition.concat([e], r.slice(1)),
+					ruleStack: C,
+					occurrenceStack: w
+				};
+				x.push(t);
+			} else if (T instanceof f) {
+				let e = new p({
+					definition: [new g({ terminalType: T.separator })].concat(T.definition),
+					idx: T.idx
+				}), t = {
+					idx: S,
+					def: T.definition.concat([e], r.slice(1)),
+					ruleStack: C,
+					occurrenceStack: w
+				};
+				x.push(t);
+			} else if (T instanceof m) {
+				let e = {
+					idx: S,
+					def: r.slice(1),
+					ruleStack: C,
+					occurrenceStack: w
+				};
+				x.push(e), x.push(o);
+				let t = new p({
+					definition: [new g({ terminalType: T.separator })].concat(T.definition),
+					idx: T.idx
+				}), n = {
+					idx: S,
+					def: T.definition.concat([t], r.slice(1)),
+					ruleStack: C,
+					occurrenceStack: w
+				};
+				x.push(n);
+			} else if (T instanceof p) {
+				let e = {
+					idx: S,
+					def: r.slice(1),
+					ruleStack: C,
+					occurrenceStack: w
+				};
+				x.push(e), x.push(o);
+				let t = new p({
+					definition: T.definition,
+					idx: T.idx
+				}), n = {
+					idx: S,
+					def: T.definition.concat([t], r.slice(1)),
+					ruleStack: C,
+					occurrenceStack: w
+				};
+				x.push(n);
+			} else if (T instanceof h) for (let e = T.definition.length - 1; e >= 0; e--) {
+				let t = {
+					idx: S,
+					def: T.definition[e].definition.concat(r.slice(1)),
+					ruleStack: C,
+					occurrenceStack: w
+				};
+				x.push(t), x.push(o);
+			}
+			else if (T instanceof l) x.push({
+				idx: S,
+				def: T.definition.concat(r.slice(1)),
+				ruleStack: C,
+				occurrenceStack: w
+			});
+			else {
+				if (!(T instanceof c)) throw Error("non exhaustive match");
+				x.push(it(T, S, C, w));
+			}
+		}
+		return b;
+	}([r], [], B, 1).length === 0 ? [{
+		message: t.buildEmptyAlternationError({
+			topLevelRule: e,
+			alternation: n,
+			emptyChoiceIdx: i
+		}),
+		type: Q.NONE_LAST_EMPTY_ALT,
+		ruleName: e.name,
+		occurrence: n.idx,
+		alternative: i + 1
+	}] : []));
+}
+function Et(e, t, n) {
+	let r = new wt();
+	e.accept(r);
+	let i = r.alternations;
+	return i = i.filter((e) => !0 !== e.ignoreAmbiguities), i.flatMap((r) => {
+		let i = mt(r.idx, e, r.maxLookahead || t, r), a = function(e, t, n, r) {
+			let i = [];
+			return e.reduce((n, r, a) => (!0 === t.definition[a].ignoreAmbiguities || r.forEach((r) => {
+				let o = [a];
+				e.forEach((e, n) => {
+					a !== n && gt(e, r) && !0 !== t.definition[n].ignoreAmbiguities && o.push(n);
+				}), o.length > 1 && !gt(i, r) && (i.push(r), n.push({
+					alts: o,
+					path: r
+				}));
+			}), n), []).map((e) => {
+				let i = e.alts.map((e) => e + 1);
+				return {
+					message: r.buildAlternationAmbiguityError({
+						topLevelRule: n,
+						alternation: t,
+						ambiguityIndices: i,
+						prefixPath: e.path
+					}),
+					type: Q.AMBIGUOUS_ALTS,
+					ruleName: n.name,
+					occurrence: t.idx,
+					alternatives: e.alts
+				};
+			});
+		}(i, r, e, n), o = function(e, t, n, r) {
+			let i = e.reduce((e, t, n) => {
+				let r = t.map((e) => ({
+					idx: n,
+					path: e
+				}));
+				return e.concat(r);
+			}, []);
+			return i.flatMap((e) => {
+				if (!0 === t.definition[e.idx].ignoreAmbiguities) return [];
+				let a = e.idx, o = e.path;
+				return i.filter((e) => {
+					return !0 !== t.definition[e.idx].ignoreAmbiguities && e.idx < a && (n = e.path, r = o, n.length < r.length && n.every((e, t) => {
+						let n = r[t];
+						return e === n || n.categoryMatchesMap[e.tokenTypeIdx];
+					}));
+					var n, r;
+				}).map((e) => {
+					let i = [e.idx + 1, a + 1], o = t.idx === 0 ? "" : t.idx;
+					return {
+						message: r.buildAlternationPrefixAmbiguityError({
+							topLevelRule: n,
+							alternation: t,
+							ambiguityIndices: i,
+							prefixPath: e.path
+						}),
+						type: Q.AMBIGUOUS_PREFIX_ALTS,
+						ruleName: n.name,
+						occurrence: o,
+						alternatives: i
+					};
+				});
+			});
+		}(i, r, e, n);
+		return a.concat(o);
+	});
+}
+var Dt = class extends y {
+	constructor() {
+		super(...arguments), this.allProductions = [];
+	}
+	visitRepetitionWithSeparator(e) {
+		this.allProductions.push(e);
+	}
+	visitRepetitionMandatory(e) {
+		this.allProductions.push(e);
+	}
+	visitRepetitionMandatoryWithSeparator(e) {
+		this.allProductions.push(e);
+	}
+	visitRepetition(e) {
+		this.allProductions.push(e);
+	}
+};
+function Ot(e) {
+	let t = Object.assign({ errMsgProvider: Je }, e), n = {};
+	return e.rules.forEach((e) => {
+		n[e.name] = e;
+	}), function(e, t) {
+		let n = new Ye(e, t);
+		return n.resolveRefs(), n.errors;
+	}(n, t.errMsgProvider);
+}
+var kt = "MismatchedTokenException", At = "NoViableAltException", jt = "EarlyExitException", Mt = "NotAllInputParsedException", Nt = [
+	kt,
+	At,
+	jt,
+	Mt
+];
+function Pt(e) {
+	return Nt.includes(e.name);
+}
+Object.freeze(Nt);
+var Ft = class extends Error {
+	constructor(e, t) {
+		super(e), this.token = t, this.resyncedTokens = [], Object.setPrototypeOf(this, new.target.prototype), Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+	}
+}, It = class extends Ft {
+	constructor(e, t, n) {
+		super(e, t), this.previousToken = n, this.name = kt;
+	}
+}, Lt = class extends Ft {
+	constructor(e, t, n) {
+		super(e, t), this.previousToken = n, this.name = At;
+	}
+}, Rt = class extends Ft {
+	constructor(e, t) {
+		super(e, t), this.name = Mt;
+	}
+}, zt = class extends Ft {
+	constructor(e, t, n) {
+		super(e, t), this.previousToken = n, this.name = jt;
+	}
+}, Bt = {}, Vt = class extends Error {
+	constructor(e) {
+		super(e), this.name = "InRuleRecoveryException";
+	}
+};
+function Ht(e, t, n, r, i, a, o) {
+	let s = this.getKeyForAutomaticLookahead(r, i), c = this.firstAfterRepMap[s];
+	if (c === void 0) {
+		let e = this.getCurrRuleFullName();
+		c = new a(this.getGAstProductions()[e], i).startWalking(), this.firstAfterRepMap[s] = c;
+	}
+	let l = c.token, u = c.occurrence, d = c.isEndOfRule;
+	this.RULE_STACK_IDX === 0 && d && l === void 0 && (l = q, u = 1), l !== void 0 && u !== void 0 && this.shouldInRepetitionRecoveryBeTried(l, u, o) && this.tryInRepetitionRecovery(e, t, n, l);
+}
+var Ut = 1024, Wt = 1280, Gt = 1536;
+function Kt(e, t, n) {
+	return n | t | e;
+}
+var qt = class {
+	constructor(e) {
+		this.maxLookahead = e?.maxLookahead ?? $.maxLookahead;
+	}
+	validate(e) {
+		let t = this.validateNoLeftRecursion(e.rules);
+		if (t.length === 0) {
+			let n = this.validateEmptyOrAlternatives(e.rules), r = this.validateAmbiguousAlternationAlternatives(e.rules, this.maxLookahead), i = this.validateSomeNonEmptyLookaheadPath(e.rules, this.maxLookahead);
+			return [
+				...t,
+				...n,
+				...r,
+				...i
+			];
+		}
+		return t;
+	}
+	validateNoLeftRecursion(e) {
+		return e.flatMap((e) => St(e, e, J));
+	}
+	validateEmptyOrAlternatives(e) {
+		return e.flatMap((e) => Tt(e, J));
+	}
+	validateAmbiguousAlternationAlternatives(e, t) {
+		return e.flatMap((e) => Et(e, t, J));
+	}
+	validateSomeNonEmptyLookaheadPath(e, t) {
+		return function(e, t, n) {
+			let r = [];
+			return e.forEach((e) => {
+				let i = new Dt();
+				e.accept(i), i.allProductions.forEach((i) => {
+					let a = at(i), o = i.maxLookahead || t;
+					if (ht(i.idx, e, a, o)[0].flat().length === 0) {
+						let t = n.buildEmptyRepetitionError({
+							topLevelRule: e,
+							repetition: i
+						});
+						r.push({
+							message: t,
+							type: Q.NO_NON_EMPTY_LOOKAHEAD,
+							ruleName: e.name
+						});
+					}
+				});
+			}), r;
+		}(e, t, J);
+	}
+	buildLookaheadForAlternation(e) {
+		return function(e, t, n, r, i, a) {
+			let o = mt(e, t, n);
+			return a(o, r, _t(o) ? Oe : B, i);
+		}(e.prodOccurrence, e.rule, e.maxLookahead, e.hasPredicates, e.dynamicTokensEnabled, ot);
+	}
+	buildLookaheadForOptional(e) {
+		return function(e, t, n, r, i, a) {
+			let o = ht(e, t, i, n), s = _t(o) ? Oe : B;
+			return a(o[0], s, r);
+		}(e.prodOccurrence, e.rule, e.maxLookahead, e.dynamicTokensEnabled, at(e.prodType), st);
+	}
+}, Jt = new class extends y {
+	constructor() {
+		super(...arguments), this.dslMethods = {
+			option: [],
+			alternation: [],
+			repetition: [],
+			repetitionWithSeparator: [],
+			repetitionMandatory: [],
+			repetitionMandatoryWithSeparator: []
+		};
+	}
+	reset() {
+		this.dslMethods = {
+			option: [],
+			alternation: [],
+			repetition: [],
+			repetitionWithSeparator: [],
+			repetitionMandatory: [],
+			repetitionMandatoryWithSeparator: []
+		};
+	}
+	visitOption(e) {
+		this.dslMethods.option.push(e);
+	}
+	visitRepetitionWithSeparator(e) {
+		this.dslMethods.repetitionWithSeparator.push(e);
+	}
+	visitRepetitionMandatory(e) {
+		this.dslMethods.repetitionMandatory.push(e);
+	}
+	visitRepetitionMandatoryWithSeparator(e) {
+		this.dslMethods.repetitionMandatoryWithSeparator.push(e);
+	}
+	visitRepetition(e) {
+		this.dslMethods.repetition.push(e);
+	}
+	visitAlternation(e) {
+		this.dslMethods.alternation.push(e);
+	}
+}();
+function Yt(e, t) {
+	e.startOffset === -1 ? (e.startOffset = t.startOffset, e.endOffset = t.endOffset) : e.endOffset < t.endOffset == 1 && (e.endOffset = t.endOffset);
+}
+function Xt(e, t) {
+	e.startOffset === -1 ? (e.startOffset = t.startOffset, e.startColumn = t.startColumn, e.startLine = t.startLine, e.endOffset = t.endOffset, e.endColumn = t.endColumn, e.endLine = t.endLine) : e.endOffset < t.endOffset == 1 && (e.endOffset = t.endOffset, e.endColumn = t.endColumn, e.endLine = t.endLine);
+}
+var Zt;
+function Qt(e, t) {
+	Object.defineProperty(e, "name", {
+		enumerable: !1,
+		configurable: !0,
+		writable: !1,
+		value: t
+	});
+}
+function $t(e, t) {
+	let n = Object.keys(e), r = n.length;
+	for (let i = 0; i < r; i++) {
+		let r = e[n[i]], a = r.length;
+		for (let e = 0; e < a; e++) {
+			let n = r[e];
+			n.tokenTypeIdx === void 0 && this[n.name](n.children, t);
+		}
+	}
+}
+function en(e, t) {
+	let n = function() {};
+	return Qt(n, e + "BaseSemantics"), n.prototype = {
+		visit: function(e, t) {
+			if (Array.isArray(e) && (e = e[0]), e !== void 0) return this[e.name](e.children, t);
+		},
+		validateVisitor: function() {
+			let e = function(e, t) {
+				return function(e, t) {
+					return t.filter((t) => typeof e[t] == "function" == 0).map((t) => ({
+						msg: `Missing visitor method: <${t}> on ${e.constructor.name} CST Visitor.`,
+						type: Zt.MISSING_METHOD,
+						methodName: t
+					})).filter(Boolean);
+				}(e, t);
+			}(this, t);
+			if (e.length !== 0) {
+				let t = e.map((e) => e.msg);
+				throw Error(`Errors Detected in CST Visitor <${this.constructor.name}>:\n\t${t.join("\n\n").replace(/\n/g, "\n	")}`);
+			}
+		}
+	}, n.prototype.constructor = n, n._RULE_NAMES = t, n;
+}
+(function(e) {
+	e[e.REDUNDANT_METHOD = 0] = "REDUNDANT_METHOD", e[e.MISSING_METHOD = 1] = "MISSING_METHOD";
+})(Zt ||= {});
+var tn = { description: "This Object indicates the Parser is during Recording Phase" };
+Object.freeze(tn);
+var nn = !0, rn = 2 ** 8 - 1, an = K({
+	name: "RECORDING_PHASE_TOKEN",
+	pattern: W.NA
+});
+V([an]);
+var on = Ke(an, "This IToken indicates the Parser is in Recording Phase\n	See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details", -1, -1, -1, -1, -1, -1);
+Object.freeze(on);
+var sn = {
+	name: "This CSTNode indicates the Parser is in Recording Phase\n	See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
+	children: {}
+};
+function X(e, t, n, r = !1) {
+	un(n);
+	let i = this.recordingProdStack.at(-1), a = typeof t == "function" ? t : t.DEF, o = new e({
+		definition: [],
+		idx: n
+	});
+	return r && (o.separator = t.SEP), Object.hasOwn(t, "MAX_LOOKAHEAD") && (o.maxLookahead = t.MAX_LOOKAHEAD), this.recordingProdStack.push(o), a.call(this), i.definition.push(o), this.recordingProdStack.pop(), tn;
+}
+function cn(e, t) {
+	un(t);
+	let n = this.recordingProdStack.at(-1), r = !1 === Array.isArray(e), i = !1 === r ? e : e.DEF, a = new h({
+		definition: [],
+		idx: t,
+		ignoreAmbiguities: r && !0 === e.IGNORE_AMBIGUITIES
+	});
+	return Object.hasOwn(e, "MAX_LOOKAHEAD") && (a.maxLookahead = e.MAX_LOOKAHEAD), a.hasPredicates = i.some((e) => typeof e.GATE == "function"), n.definition.push(a), i.forEach((e) => {
+		let t = new l({ definition: [] });
+		a.definition.push(t), Object.hasOwn(e, "IGNORE_AMBIGUITIES") ? t.ignoreAmbiguities = e.IGNORE_AMBIGUITIES : Object.hasOwn(e, "GATE") && (t.ignoreAmbiguities = !0), this.recordingProdStack.push(t), e.ALT.call(this), this.recordingProdStack.pop();
+	}), tn;
+}
+function ln(e) {
+	return e === 0 ? "" : `${e}`;
+}
+function un(e) {
+	if (e < 0 || e > rn) {
+		let t = /* @__PURE__ */ Error(`Invalid DSL Method idx value: <${e}>\n\tIdx value must be a none negative value smaller than ${rn + 1}`);
+		throw t.KNOWN_RECORDER_ERROR = !0, t;
+	}
+}
+var Z = Ke(q, "", -1, -1, -1, -1, -1, -1);
+Object.freeze(Z);
+var Q, $ = Object.freeze({
+	recoveryEnabled: !1,
+	maxLookahead: 3,
+	dynamicTokensEnabled: !1,
+	outputCst: !0,
+	errorMessageProvider: qe,
+	nodeLocationTracking: "none",
+	traceInitPerf: !1,
+	skipValidations: !1
+}), dn = Object.freeze({
+	recoveryValueFunc: () => {},
+	resyncEnabled: !0
+});
+(function(e) {
+	e[e.INVALID_RULE_NAME = 0] = "INVALID_RULE_NAME", e[e.DUPLICATE_RULE_NAME = 1] = "DUPLICATE_RULE_NAME", e[e.INVALID_RULE_OVERRIDE = 2] = "INVALID_RULE_OVERRIDE", e[e.DUPLICATE_PRODUCTIONS = 3] = "DUPLICATE_PRODUCTIONS", e[e.UNRESOLVED_SUBRULE_REF = 4] = "UNRESOLVED_SUBRULE_REF", e[e.LEFT_RECURSION = 5] = "LEFT_RECURSION", e[e.NONE_LAST_EMPTY_ALT = 6] = "NONE_LAST_EMPTY_ALT", e[e.AMBIGUOUS_ALTS = 7] = "AMBIGUOUS_ALTS", e[e.CONFLICT_TOKENS_RULES_NAMESPACE = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE", e[e.INVALID_TOKEN_NAME = 9] = "INVALID_TOKEN_NAME", e[e.NO_NON_EMPTY_LOOKAHEAD = 10] = "NO_NON_EMPTY_LOOKAHEAD", e[e.AMBIGUOUS_PREFIX_ALTS = 11] = "AMBIGUOUS_PREFIX_ALTS", e[e.TOO_MANY_ALTS = 12] = "TOO_MANY_ALTS", e[e.CUSTOM_LOOKAHEAD_VALIDATION = 13] = "CUSTOM_LOOKAHEAD_VALIDATION";
+})(Q ||= {});
+var fn, pn = class e {
+	static performSelfAnalysis(e) {
+		throw Error("The **static** `performSelfAnalysis` method has been deprecated.	\nUse the **instance** method with the same name instead.");
+	}
+	performSelfAnalysis() {
+		this.TRACE_INIT("performSelfAnalysis", () => {
+			let t;
+			this.selfAnalysisDone = !0;
+			let n = this.className;
+			this.TRACE_INIT("toFastProps", () => {
+				a(this);
+			}), this.TRACE_INIT("Grammar Recording", () => {
+				try {
+					this.enableRecording(), this.definedRulesNames.forEach((e) => {
+						let t = this[e].originalGrammarAction, n;
+						this.TRACE_INIT(`${e} Rule`, () => {
+							n = this.topLevelRuleRecord(e, t);
+						}), this.gastProductionsCache[e] = n;
+					});
+				} finally {
+					this.disableRecording();
+				}
+			});
+			let r = [];
+			if (this.TRACE_INIT("Grammar Resolving", () => {
+				r = Ot({ rules: Object.values(this.gastProductionsCache) }), this.definitionErrors = this.definitionErrors.concat(r);
+			}), this.TRACE_INIT("Grammar Validations", () => {
+				if (r.length === 0 && !1 === this.skipValidations) {
+					let t = function(e) {
+						let t = e.errMsgProvider ?? J;
+						return vt(e.rules, e.tokenTypes, t, e.grammarName);
+					}({
+						rules: Object.values(this.gastProductionsCache),
+						tokenTypes: Object.values(this.tokensMap),
+						errMsgProvider: J,
+						grammarName: n
+					}), r = (e = {
+						lookaheadStrategy: this.lookaheadStrategy,
+						rules: Object.values(this.gastProductionsCache),
+						tokenTypes: Object.values(this.tokensMap),
+						grammarName: n
+					}).lookaheadStrategy.validate({
+						rules: e.rules,
+						tokenTypes: e.tokenTypes,
+						grammarName: e.grammarName
+					}).map((e) => Object.assign({ type: Q.CUSTOM_LOOKAHEAD_VALIDATION }, e));
+					this.definitionErrors = this.definitionErrors.concat(t, r);
+				}
+				var e;
+			}), this.definitionErrors.length === 0 && (this.recoveryEnabled && this.TRACE_INIT("computeAllProdsFollows", () => {
+				let e = function(e) {
+					let t = {};
+					return e.forEach((e) => {
+						let n = new E(e).startWalking();
+						Object.assign(t, n);
+					}), t;
+				}(Object.values(this.gastProductionsCache));
+				this.resyncFollows = e;
+			}), this.TRACE_INIT("ComputeLookaheadFunctions", () => {
+				var e, t;
+				(t = (e = this.lookaheadStrategy).initialize) == null || t.call(e, { rules: Object.values(this.gastProductionsCache) }), this.preComputeLookaheadFunctions(Object.values(this.gastProductionsCache));
+			})), !e.DEFER_DEFINITION_ERRORS_HANDLING && this.definitionErrors.length !== 0) throw t = this.definitionErrors.map((e) => e.message), /* @__PURE__ */ Error(`Parser Definition Errors detected:\n ${t.join("\n-------------------------------\n")}`);
+		});
+	}
+	constructor(e, t) {
+		this.definitionErrors = [], this.selfAnalysisDone = !1;
+		let n = this;
+		if (n.initErrorHandler(t), n.initLexerAdapter(), n.initLooksAhead(t), n.initRecognizerEngine(e, t), n.initRecoverable(t), n.initTreeBuilder(t), n.initGastRecorder(t), n.initPerformanceTracer(t), Object.hasOwn(t, "ignoredIssues")) throw Error("The <ignoredIssues> IParserConfig property has been deprecated.\n	Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\n	See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\n	For further details.");
+		this.skipValidations = Object.hasOwn(t, "skipValidations") ? t.skipValidations : $.skipValidations;
+	}
+};
+pn.DEFER_DEFINITION_ERRORS_HANDLING = !1, fn = pn, [
+	class {
+		initRecoverable(e) {
+			this.firstAfterRepMap = {}, this.resyncFollows = {}, this.recoveryEnabled = Object.hasOwn(e, "recoveryEnabled") ? e.recoveryEnabled : $.recoveryEnabled, this.recoveryEnabled && (this.attemptInRepetitionRecovery = Ht);
+		}
+		getTokenToInsert(e) {
+			let t = Ke(e, "", -1, -1, -1, -1, -1, -1);
+			return t.isInsertedInRecovery = !0, t;
+		}
+		canTokenTypeBeInsertedInRecovery(e) {
+			return !0;
+		}
+		canTokenTypeBeDeletedInRecovery(e) {
+			return !0;
+		}
+		tryInRepetitionRecovery(e, t, n, r) {
+			let i = this.findReSyncTokenType(), a = this.exportLexerState(), o = [], s = !1, c = this.LA_FAST(1), l = this.LA_FAST(1), u = () => {
+				let e = this.LA(0), t = new It(this.errorMessageProvider.buildMismatchTokenMessage({
+					expected: r,
+					actual: c,
+					previous: e,
+					ruleName: this.getCurrRuleFullName()
+				}), c, this.LA(0));
+				t.resyncedTokens = o.slice(0, -1), this.SAVE_ERROR(t);
+			};
+			for (; !s;) {
+				if (this.tokenMatcher(l, r)) return void u();
+				if (n.call(this)) return u(), void e.apply(this, t);
+				this.tokenMatcher(l, i) ? s = !0 : (l = this.SKIP_TOKEN(), this.addToResyncTokens(l, o));
+			}
+			this.importLexerState(a);
+		}
+		shouldInRepetitionRecoveryBeTried(e, t, n) {
+			return !1 !== n && !this.tokenMatcher(this.LA_FAST(1), e) && !this.isBackTracking() && !this.canPerformInRuleRecovery(e, this.getFollowsForInRuleRecovery(e, t));
+		}
+		getNextPossibleTokenTypes(e) {
+			let t = e.ruleStack[0], n = this.getGAstProductions()[t];
+			return new Ze(n, e).startWalking();
+		}
+		getFollowsForInRuleRecovery(e, t) {
+			let n = this.getCurrentGrammarPath(e, t);
+			return this.getNextPossibleTokenTypes(n);
+		}
+		tryInRuleRecovery(e, t) {
+			if (this.canRecoverWithSingleTokenInsertion(e, t)) return this.getTokenToInsert(e);
+			if (this.canRecoverWithSingleTokenDeletion(e)) {
+				let e = this.SKIP_TOKEN();
+				return this.consumeToken(), e;
+			}
+			throw new Vt("sad sad panda");
+		}
+		canPerformInRuleRecovery(e, t) {
+			return this.canRecoverWithSingleTokenInsertion(e, t) || this.canRecoverWithSingleTokenDeletion(e);
+		}
+		canRecoverWithSingleTokenInsertion(e, t) {
+			if (!this.canTokenTypeBeInsertedInRecovery(e) || t.length === 0) return !1;
+			let n = this.LA_FAST(1);
+			return t.find((e) => this.tokenMatcher(n, e)) !== void 0;
+		}
+		canRecoverWithSingleTokenDeletion(e) {
+			return !!this.canTokenTypeBeDeletedInRecovery(e) && this.tokenMatcher(this.LA(2), e);
+		}
+		isInCurrentRuleReSyncSet(e) {
+			let t = this.getCurrFollowKey();
+			return this.getFollowSetFromFollowKey(t).includes(e);
+		}
+		findReSyncTokenType() {
+			let e = this.flattenFollowSet(), t = this.LA_FAST(1), n = 2;
+			for (;;) {
+				let r = e.find((e) => B(t, e));
+				if (r !== void 0) return r;
+				t = this.LA(n), n++;
+			}
+		}
+		getCurrFollowKey() {
+			if (this.RULE_STACK_IDX === 0) return Bt;
+			let e = this.currRuleShortName, t = this.getLastExplicitRuleOccurrenceIndex(), n = this.getPreviousExplicitRuleShortName();
+			return {
+				ruleName: this.shortRuleNameToFullName(e),
+				idxInCallingRule: t,
+				inRule: this.shortRuleNameToFullName(n)
+			};
+		}
+		buildFullFollowKeyStack() {
+			let e = this.RULE_STACK, t = this.RULE_OCCURRENCE_STACK, n = this.RULE_STACK_IDX + 1, r = Array(n);
+			for (let i = 0; i < n; i++) r[i] = i === 0 ? Bt : {
+				ruleName: this.shortRuleNameToFullName(e[i]),
+				idxInCallingRule: t[i],
+				inRule: this.shortRuleNameToFullName(e[i - 1])
+			};
+			return r;
+		}
+		flattenFollowSet() {
+			return this.buildFullFollowKeyStack().map((e) => this.getFollowSetFromFollowKey(e)).flat();
+		}
+		getFollowSetFromFollowKey(e) {
+			if (e === Bt) return [q];
+			let t = e.ruleName + e.idxInCallingRule + T + e.inRule;
+			return this.resyncFollows[t];
+		}
+		addToResyncTokens(e, t) {
+			return this.tokenMatcher(e, q) || t.push(e), t;
+		}
+		reSyncTo(e) {
+			let t = [], n = this.LA_FAST(1);
+			for (; !1 === this.tokenMatcher(n, e);) n = this.SKIP_TOKEN(), this.addToResyncTokens(n, t);
+			return t.slice(0, -1);
+		}
+		attemptInRepetitionRecovery(e, t, n, r, i, a, o) {}
+		getCurrentGrammarPath(e, t) {
+			return {
+				ruleStack: this.getHumanReadableRuleStack(),
+				occurrenceStack: this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1),
+				lastTok: e,
+				lastTokOccurrence: t
+			};
+		}
+		getHumanReadableRuleStack() {
+			let e = this.RULE_STACK_IDX + 1, t = Array(e);
+			for (let n = 0; n < e; n++) t[n] = this.shortRuleNameToFullName(this.RULE_STACK[n]);
+			return t;
+		}
+	},
+	class {
+		initLooksAhead(e) {
+			this.dynamicTokensEnabled = Object.hasOwn(e, "dynamicTokensEnabled") ? e.dynamicTokensEnabled : $.dynamicTokensEnabled, this.maxLookahead = Object.hasOwn(e, "maxLookahead") ? e.maxLookahead : $.maxLookahead, this.lookaheadStrategy = Object.hasOwn(e, "lookaheadStrategy") ? e.lookaheadStrategy : new qt({ maxLookahead: this.maxLookahead }), this.lookAheadFuncsCache = /* @__PURE__ */ new Map();
+		}
+		preComputeLookaheadFunctions(e) {
+			e.forEach((e) => {
+				this.TRACE_INIT(`${e.name} Rule Lookahead`, () => {
+					let { alternation: t, repetition: n, option: r, repetitionMandatory: i, repetitionMandatoryWithSeparator: a, repetitionWithSeparator: o } = function(e) {
+						Jt.reset(), e.accept(Jt);
+						let t = Jt.dslMethods;
+						return Jt.reset(), t;
+					}(e);
+					t.forEach((t) => {
+						let n = t.idx === 0 ? "" : t.idx;
+						this.TRACE_INIT(`${x(t)}${n}`, () => {
+							let n = this.lookaheadStrategy.buildLookaheadForAlternation({
+								prodOccurrence: t.idx,
+								rule: e,
+								maxLookahead: t.maxLookahead || this.maxLookahead,
+								hasPredicates: t.hasPredicates,
+								dynamicTokensEnabled: this.dynamicTokensEnabled
+							}), r = Kt(this.fullRuleNameToShort[e.name], 256, t.idx);
+							this.setLaFuncCache(r, n);
+						});
+					}), n.forEach((t) => {
+						this.computeLookaheadFunc(e, t.idx, 768, "Repetition", t.maxLookahead, x(t));
+					}), r.forEach((t) => {
+						this.computeLookaheadFunc(e, t.idx, 512, "Option", t.maxLookahead, x(t));
+					}), i.forEach((t) => {
+						this.computeLookaheadFunc(e, t.idx, Ut, "RepetitionMandatory", t.maxLookahead, x(t));
+					}), a.forEach((t) => {
+						this.computeLookaheadFunc(e, t.idx, Gt, "RepetitionMandatoryWithSeparator", t.maxLookahead, x(t));
+					}), o.forEach((t) => {
+						this.computeLookaheadFunc(e, t.idx, Wt, "RepetitionWithSeparator", t.maxLookahead, x(t));
+					});
+				});
+			});
+		}
+		computeLookaheadFunc(e, t, n, r, i, a) {
+			this.TRACE_INIT(`${a}${t === 0 ? "" : t}`, () => {
+				let a = this.lookaheadStrategy.buildLookaheadForOptional({
+					prodOccurrence: t,
+					rule: e,
+					maxLookahead: i || this.maxLookahead,
+					dynamicTokensEnabled: this.dynamicTokensEnabled,
+					prodType: r
+				}), o = Kt(this.fullRuleNameToShort[e.name], n, t);
+				this.setLaFuncCache(o, a);
+			});
+		}
+		getKeyForAutomaticLookahead(e, t) {
+			return Kt(this.currRuleShortName, e, t);
+		}
+		getLaFuncFromCache(e) {
+			return this.lookAheadFuncsCache.get(e);
+		}
+		setLaFuncCache(e, t) {
+			this.lookAheadFuncsCache.set(e, t);
+		}
+	},
+	class {
+		initTreeBuilder(e) {
+			if (this.CST_STACK = [], this.outputCst = e.outputCst, this.nodeLocationTracking = Object.hasOwn(e, "nodeLocationTracking") ? e.nodeLocationTracking : $.nodeLocationTracking, this.outputCst) if (/full/i.test(this.nodeLocationTracking)) this.recoveryEnabled ? (this.setNodeLocationFromToken = Xt, this.setNodeLocationFromNode = Xt, this.cstPostRule = () => {}, this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery) : (this.setNodeLocationFromToken = () => {}, this.setNodeLocationFromNode = () => {}, this.cstPostRule = this.cstPostRuleFull, this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular);
+			else if (/onlyOffset/i.test(this.nodeLocationTracking)) this.recoveryEnabled ? (this.setNodeLocationFromToken = Yt, this.setNodeLocationFromNode = Yt, this.cstPostRule = () => {}, this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRecovery) : (this.setNodeLocationFromToken = () => {}, this.setNodeLocationFromNode = () => {}, this.cstPostRule = this.cstPostRuleOnlyOffset, this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRegular);
+			else {
+				if (!/none/i.test(this.nodeLocationTracking)) throw Error(`Invalid <nodeLocationTracking> config option: "${e.nodeLocationTracking}"`);
+				this.setNodeLocationFromToken = () => {}, this.setNodeLocationFromNode = () => {}, this.cstPostRule = () => {}, this.setInitialNodeLocation = () => {};
+			}
+			else this.cstInvocationStateUpdate = () => {}, this.cstFinallyStateUpdate = () => {}, this.cstPostTerminal = () => {}, this.cstPostNonTerminal = () => {}, this.cstPostRule = () => {};
+		}
+		setInitialNodeLocationOnlyOffsetRecovery(e) {
+			e.location = {
+				startOffset: -1,
+				endOffset: -1
+			};
+		}
+		setInitialNodeLocationOnlyOffsetRegular(e) {
+			e.location = {
+				startOffset: this.LA_FAST(1).startOffset,
+				endOffset: -1
+			};
+		}
+		setInitialNodeLocationFullRecovery(e) {
+			e.location = {
+				startOffset: -1,
+				startLine: -1,
+				startColumn: -1,
+				endOffset: -1,
+				endLine: -1,
+				endColumn: -1
+			};
+		}
+		setInitialNodeLocationFullRegular(e) {
+			let t = this.LA_FAST(1);
+			e.location = {
+				startOffset: t.startOffset,
+				startLine: t.startLine,
+				startColumn: t.startColumn,
+				endOffset: -1,
+				endLine: -1,
+				endColumn: -1
+			};
+		}
+		cstInvocationStateUpdate(e) {
+			let t = {
+				name: e,
+				children: Object.create(null)
+			};
+			this.setInitialNodeLocation(t), this.CST_STACK.push(t);
+		}
+		cstFinallyStateUpdate() {
+			this.CST_STACK.pop();
+		}
+		cstPostRuleFull(e) {
+			let t = this.LA(0), n = e.location;
+			n.startOffset !== -1 && n.startOffset <= t.startOffset == 1 ? (n.endOffset = t.endOffset, n.endLine = t.endLine, n.endColumn = t.endColumn) : (n.startOffset = -1, n.startLine = -1, n.startColumn = -1);
+		}
+		cstPostRuleOnlyOffset(e) {
+			let t = this.LA(0), n = e.location;
+			n.startOffset !== -1 && n.startOffset <= t.startOffset == 1 ? n.endOffset = t.endOffset : n.startOffset = -1;
+		}
+		cstPostTerminal(e, t) {
+			let n = this.CST_STACK[this.CST_STACK.length - 1];
+			var r, i = t, a = e;
+			(r = n).children[a] === void 0 ? r.children[a] = [i] : r.children[a].push(i), this.setNodeLocationFromToken(n.location, t);
+		}
+		cstPostNonTerminal(e, t) {
+			let n = this.CST_STACK[this.CST_STACK.length - 1];
+			(function(e, t, n) {
+				e.children[t] === void 0 ? e.children[t] = [n] : e.children[t].push(n);
+			})(n, t, e), this.setNodeLocationFromNode(n.location, e.location);
+		}
+		get currCSTNode() {
+			return this.CST_STACK[this.CST_STACK.length - 1];
+		}
+		getBaseCstVisitorConstructor() {
+			if (this.baseCstVisitorConstructor === void 0) {
+				let e = en(this.className, Object.keys(this.gastProductionsCache));
+				return this.baseCstVisitorConstructor = e, e;
+			}
+			return this.baseCstVisitorConstructor;
+		}
+		getBaseCstVisitorConstructorWithDefaults() {
+			if (this.baseCstVisitorWithDefaultsConstructor === void 0) {
+				let e = function(e, t, n) {
+					let r = function() {};
+					Qt(r, e + "BaseSemanticsWithDefaults");
+					let i = Object.create(n.prototype);
+					return t.forEach((e) => {
+						i[e] = $t;
+					}), (r.prototype = i).constructor = r, r;
+				}(this.className, Object.keys(this.gastProductionsCache), this.getBaseCstVisitorConstructor());
+				return this.baseCstVisitorWithDefaultsConstructor = e, e;
+			}
+			return this.baseCstVisitorWithDefaultsConstructor;
+		}
+		getPreviousExplicitRuleShortName() {
+			return this.RULE_STACK[this.RULE_STACK_IDX - 1];
+		}
+		getLastExplicitRuleOccurrenceIndex() {
+			return this.RULE_OCCURRENCE_STACK[this.RULE_OCCURRENCE_STACK_IDX];
+		}
+	},
+	class {
+		initLexerAdapter() {
+			this.tokVector = [], this.tokVectorLength = 0, this.currIdx = -1;
+		}
+		set input(e) {
+			if (!0 !== this.selfAnalysisDone) throw Error("Missing <performSelfAnalysis> invocation at the end of the Parser's constructor.");
+			this.reset(), this.tokVector = e, this.tokVectorLength = e.length;
+		}
+		get input() {
+			return this.tokVector;
+		}
+		SKIP_TOKEN() {
+			return this.currIdx <= this.tokVectorLength - 2 ? (this.consumeToken(), this.LA_FAST(1)) : Z;
+		}
+		LA_FAST(e) {
+			let t = this.currIdx + e;
+			return this.tokVector[t];
+		}
+		LA(e) {
+			let t = this.currIdx + e;
+			return t < 0 || this.tokVectorLength <= t ? Z : this.tokVector[t];
+		}
+		consumeToken() {
+			this.currIdx++;
+		}
+		exportLexerState() {
+			return this.currIdx;
+		}
+		importLexerState(e) {
+			this.currIdx = e;
+		}
+		resetLexerState() {
+			this.currIdx = -1;
+		}
+		moveToTerminatedState() {
+			this.currIdx = this.tokVectorLength - 1;
+		}
+		getLexerPosition() {
+			return this.exportLexerState();
+		}
+	},
+	class {
+		initRecognizerEngine(e, t) {
+			if (this.className = this.constructor.name, this.shortRuleNameToFull = {}, this.fullRuleNameToShort = {}, this.ruleShortNameIdx = 256, this.tokenMatcher = Oe, this.subruleIdx = 0, this.currRuleShortName = 0, this.definedRulesNames = [], this.tokensMap = {}, this.isBackTrackingStack = [], this.RULE_STACK = [], this.RULE_STACK_IDX = -1, this.RULE_OCCURRENCE_STACK = [], this.RULE_OCCURRENCE_STACK_IDX = -1, this.gastProductionsCache = {}, Object.hasOwn(t, "serializedGrammar")) throw Error("The Parser's configuration can no longer contain a <serializedGrammar> property.\n	See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\n	For Further details.");
+			if (Array.isArray(e)) {
+				if (e.length === 0) throw Error("A Token Vocabulary cannot be empty.\n	Note that the first argument for the parser constructor\n	is no longer a Token vector (since v4.0).");
+				if (typeof e[0].startOffset == "number") throw Error("The Parser constructor no longer accepts a token vector as the first argument.\n	See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0\n	For Further details.");
+			}
+			if (Array.isArray(e)) this.tokensMap = e.reduce((e, t) => (e[t.name] = t, e), {});
+			else if (Object.hasOwn(e, "modes") && Object.values(e.modes).flat().every(Pe)) {
+				let t = Object.values(e.modes).flat(), n = [...new Set(t)];
+				this.tokensMap = n.reduce((e, t) => (e[t.name] = t, e), {});
+			} else {
+				if (typeof e != "object" || !e) throw Error("<tokensDictionary> argument must be An Array of Token constructors, A dictionary of Token constructors or an IMultiModeLexerDefinition");
+				this.tokensMap = Object.assign({}, e);
+			}
+			this.tokensMap.EOF = q;
+			let n = (Object.hasOwn(e, "modes") ? Object.values(e.modes).flat() : Object.values(e)).every((e) => e.categoryMatches?.length == 0);
+			this.tokenMatcher = n ? Oe : B, V(Object.values(this.tokensMap));
+		}
+		defineRule(e, t, n) {
+			if (this.selfAnalysisDone) throw Error(`Grammar rule <${e}> may not be defined after the 'performSelfAnalysis' method has been called'\nMake sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);
+			let r = Object.hasOwn(n, "resyncEnabled") ? n.resyncEnabled : dn.resyncEnabled, i = Object.hasOwn(n, "recoveryValueFunc") ? n.recoveryValueFunc : dn.recoveryValueFunc, a = this.ruleShortNameIdx << 12, o;
+			return this.ruleShortNameIdx++, this.shortRuleNameToFull[a] = e, this.fullRuleNameToShort[e] = a, o = !0 === this.outputCst ? function(...n) {
+				try {
+					this.ruleInvocationStateUpdate(a, e, this.subruleIdx), t.apply(this, n);
+					let r = this.CST_STACK[this.CST_STACK.length - 1];
+					return this.cstPostRule(r), r;
+				} catch (e) {
+					return this.invokeRuleCatch(e, r, i);
+				} finally {
+					this.ruleFinallyStateUpdate();
+				}
+			} : function(...n) {
+				try {
+					return this.ruleInvocationStateUpdate(a, e, this.subruleIdx), t.apply(this, n);
+				} catch (e) {
+					return this.invokeRuleCatch(e, r, i);
+				} finally {
+					this.ruleFinallyStateUpdate();
+				}
+			}, Object.assign(function(...t) {
+				this.onBeforeParse(e);
+				try {
+					return o.apply(this, t);
+				} finally {
+					this.onAfterParse(e);
+				}
+			}, {
+				ruleName: e,
+				originalGrammarAction: t,
+				coreRule: o
+			});
+		}
+		invokeRuleCatch(e, t, n) {
+			let r = this.RULE_STACK_IDX === 0, i = t && !this.isBackTracking() && this.recoveryEnabled;
+			if (Pt(e)) {
+				let t = e;
+				if (i) {
+					let r = this.findReSyncTokenType();
+					if (this.isInCurrentRuleReSyncSet(r)) {
+						if (t.resyncedTokens = this.reSyncTo(r), this.outputCst) {
+							let e = this.CST_STACK[this.CST_STACK.length - 1];
+							return e.recoveredNode = !0, e;
+						}
+						return n(e);
+					}
+					if (this.outputCst) {
+						let e = this.CST_STACK[this.CST_STACK.length - 1];
+						e.recoveredNode = !0, t.partialCstResult = e;
+					}
+					throw t;
+				}
+				if (r) return this.moveToTerminatedState(), n(e);
+				throw t;
+			}
+			throw e;
+		}
+		optionInternal(e, t) {
+			let n = this.getKeyForAutomaticLookahead(512, t);
+			return this.optionInternalLogic(e, t, n);
+		}
+		optionInternalLogic(e, t, n) {
+			let r, i = this.getLaFuncFromCache(n);
+			if (typeof e != "function") {
+				r = e.DEF;
+				let t = e.GATE;
+				if (t !== void 0) {
+					let e = i;
+					i = () => t.call(this) && e.call(this);
+				}
+			} else r = e;
+			if (!0 === i.call(this)) return r.call(this);
+		}
+		atLeastOneInternal(e, t) {
+			let n = this.getKeyForAutomaticLookahead(Ut, e);
+			return this.atLeastOneInternalLogic(e, t, n);
+		}
+		atLeastOneInternalLogic(e, t, n) {
+			let r, i = this.getLaFuncFromCache(n);
+			if (typeof t != "function") {
+				r = t.DEF;
+				let e = t.GATE;
+				if (e !== void 0) {
+					let t = i;
+					i = () => e.call(this) && t.call(this);
+				}
+			} else r = t;
+			if (!0 !== i.call(this)) throw this.raiseEarlyExitException(e, Y.REPETITION_MANDATORY, t.ERR_MSG);
+			{
+				let e = this.doSingleRepetition(r);
+				for (; !0 === i.call(this) && !0 === e;) e = this.doSingleRepetition(r);
+			}
+			this.attemptInRepetitionRecovery(this.atLeastOneInternal, [e, t], i, Ut, e, tt);
+		}
+		atLeastOneSepFirstInternal(e, t) {
+			let n = this.getKeyForAutomaticLookahead(Gt, e);
+			this.atLeastOneSepFirstInternalLogic(e, t, n);
+		}
+		atLeastOneSepFirstInternalLogic(e, t, n) {
+			let r = t.DEF, i = t.SEP;
+			if (!0 !== this.getLaFuncFromCache(n).call(this)) throw this.raiseEarlyExitException(e, Y.REPETITION_MANDATORY_WITH_SEPARATOR, t.ERR_MSG);
+			{
+				r.call(this);
+				let t = () => this.tokenMatcher(this.LA_FAST(1), i);
+				for (; !0 === this.tokenMatcher(this.LA_FAST(1), i);) this.CONSUME(i), r.call(this);
+				this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
+					e,
+					i,
+					t,
+					r,
+					nt
+				], t, Gt, e, nt);
+			}
+		}
+		manyInternal(e, t) {
+			let n = this.getKeyForAutomaticLookahead(768, e);
+			return this.manyInternalLogic(e, t, n);
+		}
+		manyInternalLogic(e, t, n) {
+			let r, i = this.getLaFuncFromCache(n);
+			if (typeof t != "function") {
+				r = t.DEF;
+				let e = t.GATE;
+				if (e !== void 0) {
+					let t = i;
+					i = () => e.call(this) && t.call(this);
+				}
+			} else r = t;
+			let a = !0;
+			for (; !0 === i.call(this) && !0 === a;) a = this.doSingleRepetition(r);
+			this.attemptInRepetitionRecovery(this.manyInternal, [e, t], i, 768, e, $e, a);
+		}
+		manySepFirstInternal(e, t) {
+			let n = this.getKeyForAutomaticLookahead(Wt, e);
+			this.manySepFirstInternalLogic(e, t, n);
+		}
+		manySepFirstInternalLogic(e, t, n) {
+			let r = t.DEF, i = t.SEP;
+			if (!0 === this.getLaFuncFromCache(n).call(this)) {
+				r.call(this);
+				let t = () => this.tokenMatcher(this.LA_FAST(1), i);
+				for (; !0 === this.tokenMatcher(this.LA_FAST(1), i);) this.CONSUME(i), r.call(this);
+				this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
+					e,
+					i,
+					t,
+					r,
+					et
+				], t, Wt, e, et);
+			}
+		}
+		repetitionSepSecondInternal(e, t, n, r, i) {
+			for (; n();) this.CONSUME(t), r.call(this);
+			this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
+				e,
+				t,
+				n,
+				r,
+				i
+			], n, Gt, e, i);
+		}
+		doSingleRepetition(e) {
+			let t = this.getLexerPosition();
+			return e.call(this), this.getLexerPosition() > t;
+		}
+		orInternal(e, t) {
+			let n = this.getKeyForAutomaticLookahead(256, t), r = Array.isArray(e) ? e : e.DEF, i = this.getLaFuncFromCache(n).call(this, r);
+			if (i !== void 0) return r[i].ALT.call(this);
+			this.raiseNoAltException(t, e.ERR_MSG);
+		}
+		ruleFinallyStateUpdate() {
+			this.RULE_STACK_IDX--, this.RULE_OCCURRENCE_STACK_IDX--, this.RULE_STACK_IDX >= 0 && (this.currRuleShortName = this.RULE_STACK[this.RULE_STACK_IDX]), this.cstFinallyStateUpdate();
+		}
+		subruleInternal(e, t, n) {
+			let r;
+			try {
+				let i = n === void 0 ? void 0 : n.ARGS;
+				return this.subruleIdx = t, r = e.coreRule.apply(this, i), this.cstPostNonTerminal(r, n !== void 0 && n.LABEL !== void 0 ? n.LABEL : e.ruleName), r;
+			} catch (t) {
+				throw this.subruleInternalError(t, n, e.ruleName);
+			}
+		}
+		subruleInternalError(e, t, n) {
+			throw Pt(e) && e.partialCstResult !== void 0 && (this.cstPostNonTerminal(e.partialCstResult, t !== void 0 && t.LABEL !== void 0 ? t.LABEL : n), delete e.partialCstResult), e;
+		}
+		consumeInternal(e, t, n) {
+			let r;
+			try {
+				let t = this.LA_FAST(1);
+				!0 === this.tokenMatcher(t, e) ? (this.consumeToken(), r = t) : this.consumeInternalError(e, t, n);
+			} catch (n) {
+				r = this.consumeInternalRecovery(e, t, n);
+			}
+			return this.cstPostTerminal(n !== void 0 && n.LABEL !== void 0 ? n.LABEL : e.name, r), r;
+		}
+		consumeInternalError(e, t, n) {
+			let r, i = this.LA(0);
+			throw r = n !== void 0 && n.ERR_MSG ? n.ERR_MSG : this.errorMessageProvider.buildMismatchTokenMessage({
+				expected: e,
+				actual: t,
+				previous: i,
+				ruleName: this.getCurrRuleFullName()
+			}), this.SAVE_ERROR(new It(r, t, i));
+		}
+		consumeInternalRecovery(e, t, n) {
+			if (!this.recoveryEnabled || n.name !== "MismatchedTokenException" || this.isBackTracking()) throw n;
+			{
+				let r = this.getFollowsForInRuleRecovery(e, t);
+				try {
+					return this.tryInRuleRecovery(e, r);
+				} catch (e) {
+					throw e.name === "InRuleRecoveryException" ? n : e;
+				}
+			}
+		}
+		saveRecogState() {
+			let e = this.errors, t = this.RULE_STACK.slice(0, this.RULE_STACK_IDX + 1);
+			return {
+				errors: e,
+				lexerState: this.exportLexerState(),
+				RULE_STACK: t,
+				CST_STACK: this.CST_STACK
+			};
+		}
+		reloadRecogState(e) {
+			this.errors = e.errors, this.importLexerState(e.lexerState);
+			let t = e.RULE_STACK;
+			for (let e = 0; e < t.length; e++) this.RULE_STACK[e] = t[e];
+			this.RULE_STACK_IDX = t.length - 1, this.RULE_STACK_IDX >= 0 && (this.currRuleShortName = this.RULE_STACK[this.RULE_STACK_IDX]);
+		}
+		ruleInvocationStateUpdate(e, t, n) {
+			this.RULE_OCCURRENCE_STACK[++this.RULE_OCCURRENCE_STACK_IDX] = n, this.RULE_STACK[++this.RULE_STACK_IDX] = e, this.currRuleShortName = e, this.cstInvocationStateUpdate(t);
+		}
+		isBackTracking() {
+			return this.isBackTrackingStack.length !== 0;
+		}
+		getCurrRuleFullName() {
+			let e = this.currRuleShortName;
+			return this.shortRuleNameToFull[e];
+		}
+		shortRuleNameToFullName(e) {
+			return this.shortRuleNameToFull[e];
+		}
+		isAtEndOfInput() {
+			return this.tokenMatcher(this.LA(1), q);
+		}
+		reset() {
+			this.resetLexerState(), this.subruleIdx = 0, this.currRuleShortName = 0, this.isBackTrackingStack = [], this.errors = [], this.RULE_STACK_IDX = -1, this.RULE_OCCURRENCE_STACK_IDX = -1, this.CST_STACK = [];
+		}
+		onBeforeParse(e) {
+			for (let e = 0; e < this.maxLookahead + 1; e++) this.tokVector.push(Z);
+		}
+		onAfterParse(e) {
+			if (!1 === this.isAtEndOfInput()) {
+				let e = this.LA(1), t = this.errorMessageProvider.buildNotAllInputParsedMessage({
+					firstRedundant: e,
+					ruleName: this.getCurrRuleFullName()
+				});
+				this.SAVE_ERROR(new Rt(t, e));
+			}
+			for (; this.tokVector.at(-1) === Z;) this.tokVector.pop();
+		}
+	},
+	class {
+		ACTION(e) {
+			return e.call(this);
+		}
+		consume(e, t, n) {
+			return this.consumeInternal(t, e, n);
+		}
+		subrule(e, t, n) {
+			return this.subruleInternal(t, e, n);
+		}
+		option(e, t) {
+			return this.optionInternal(t, e);
+		}
+		or(e, t) {
+			return this.orInternal(t, e);
+		}
+		many(e, t) {
+			return this.manyInternal(e, t);
+		}
+		atLeastOne(e, t) {
+			return this.atLeastOneInternal(e, t);
+		}
+		CONSUME(e, t) {
+			return this.consumeInternal(e, 0, t);
+		}
+		CONSUME1(e, t) {
+			return this.consumeInternal(e, 1, t);
+		}
+		CONSUME2(e, t) {
+			return this.consumeInternal(e, 2, t);
+		}
+		CONSUME3(e, t) {
+			return this.consumeInternal(e, 3, t);
+		}
+		CONSUME4(e, t) {
+			return this.consumeInternal(e, 4, t);
+		}
+		CONSUME5(e, t) {
+			return this.consumeInternal(e, 5, t);
+		}
+		CONSUME6(e, t) {
+			return this.consumeInternal(e, 6, t);
+		}
+		CONSUME7(e, t) {
+			return this.consumeInternal(e, 7, t);
+		}
+		CONSUME8(e, t) {
+			return this.consumeInternal(e, 8, t);
+		}
+		CONSUME9(e, t) {
+			return this.consumeInternal(e, 9, t);
+		}
+		SUBRULE(e, t) {
+			return this.subruleInternal(e, 0, t);
+		}
+		SUBRULE1(e, t) {
+			return this.subruleInternal(e, 1, t);
+		}
+		SUBRULE2(e, t) {
+			return this.subruleInternal(e, 2, t);
+		}
+		SUBRULE3(e, t) {
+			return this.subruleInternal(e, 3, t);
+		}
+		SUBRULE4(e, t) {
+			return this.subruleInternal(e, 4, t);
+		}
+		SUBRULE5(e, t) {
+			return this.subruleInternal(e, 5, t);
+		}
+		SUBRULE6(e, t) {
+			return this.subruleInternal(e, 6, t);
+		}
+		SUBRULE7(e, t) {
+			return this.subruleInternal(e, 7, t);
+		}
+		SUBRULE8(e, t) {
+			return this.subruleInternal(e, 8, t);
+		}
+		SUBRULE9(e, t) {
+			return this.subruleInternal(e, 9, t);
+		}
+		OPTION(e) {
+			return this.optionInternal(e, 0);
+		}
+		OPTION1(e) {
+			return this.optionInternal(e, 1);
+		}
+		OPTION2(e) {
+			return this.optionInternal(e, 2);
+		}
+		OPTION3(e) {
+			return this.optionInternal(e, 3);
+		}
+		OPTION4(e) {
+			return this.optionInternal(e, 4);
+		}
+		OPTION5(e) {
+			return this.optionInternal(e, 5);
+		}
+		OPTION6(e) {
+			return this.optionInternal(e, 6);
+		}
+		OPTION7(e) {
+			return this.optionInternal(e, 7);
+		}
+		OPTION8(e) {
+			return this.optionInternal(e, 8);
+		}
+		OPTION9(e) {
+			return this.optionInternal(e, 9);
+		}
+		OR(e) {
+			return this.orInternal(e, 0);
+		}
+		OR1(e) {
+			return this.orInternal(e, 1);
+		}
+		OR2(e) {
+			return this.orInternal(e, 2);
+		}
+		OR3(e) {
+			return this.orInternal(e, 3);
+		}
+		OR4(e) {
+			return this.orInternal(e, 4);
+		}
+		OR5(e) {
+			return this.orInternal(e, 5);
+		}
+		OR6(e) {
+			return this.orInternal(e, 6);
+		}
+		OR7(e) {
+			return this.orInternal(e, 7);
+		}
+		OR8(e) {
+			return this.orInternal(e, 8);
+		}
+		OR9(e) {
+			return this.orInternal(e, 9);
+		}
+		MANY(e) {
+			this.manyInternal(0, e);
+		}
+		MANY1(e) {
+			this.manyInternal(1, e);
+		}
+		MANY2(e) {
+			this.manyInternal(2, e);
+		}
+		MANY3(e) {
+			this.manyInternal(3, e);
+		}
+		MANY4(e) {
+			this.manyInternal(4, e);
+		}
+		MANY5(e) {
+			this.manyInternal(5, e);
+		}
+		MANY6(e) {
+			this.manyInternal(6, e);
+		}
+		MANY7(e) {
+			this.manyInternal(7, e);
+		}
+		MANY8(e) {
+			this.manyInternal(8, e);
+		}
+		MANY9(e) {
+			this.manyInternal(9, e);
+		}
+		MANY_SEP(e) {
+			this.manySepFirstInternal(0, e);
+		}
+		MANY_SEP1(e) {
+			this.manySepFirstInternal(1, e);
+		}
+		MANY_SEP2(e) {
+			this.manySepFirstInternal(2, e);
+		}
+		MANY_SEP3(e) {
+			this.manySepFirstInternal(3, e);
+		}
+		MANY_SEP4(e) {
+			this.manySepFirstInternal(4, e);
+		}
+		MANY_SEP5(e) {
+			this.manySepFirstInternal(5, e);
+		}
+		MANY_SEP6(e) {
+			this.manySepFirstInternal(6, e);
+		}
+		MANY_SEP7(e) {
+			this.manySepFirstInternal(7, e);
+		}
+		MANY_SEP8(e) {
+			this.manySepFirstInternal(8, e);
+		}
+		MANY_SEP9(e) {
+			this.manySepFirstInternal(9, e);
+		}
+		AT_LEAST_ONE(e) {
+			this.atLeastOneInternal(0, e);
+		}
+		AT_LEAST_ONE1(e) {
+			return this.atLeastOneInternal(1, e);
+		}
+		AT_LEAST_ONE2(e) {
+			this.atLeastOneInternal(2, e);
+		}
+		AT_LEAST_ONE3(e) {
+			this.atLeastOneInternal(3, e);
+		}
+		AT_LEAST_ONE4(e) {
+			this.atLeastOneInternal(4, e);
+		}
+		AT_LEAST_ONE5(e) {
+			this.atLeastOneInternal(5, e);
+		}
+		AT_LEAST_ONE6(e) {
+			this.atLeastOneInternal(6, e);
+		}
+		AT_LEAST_ONE7(e) {
+			this.atLeastOneInternal(7, e);
+		}
+		AT_LEAST_ONE8(e) {
+			this.atLeastOneInternal(8, e);
+		}
+		AT_LEAST_ONE9(e) {
+			this.atLeastOneInternal(9, e);
+		}
+		AT_LEAST_ONE_SEP(e) {
+			this.atLeastOneSepFirstInternal(0, e);
+		}
+		AT_LEAST_ONE_SEP1(e) {
+			this.atLeastOneSepFirstInternal(1, e);
+		}
+		AT_LEAST_ONE_SEP2(e) {
+			this.atLeastOneSepFirstInternal(2, e);
+		}
+		AT_LEAST_ONE_SEP3(e) {
+			this.atLeastOneSepFirstInternal(3, e);
+		}
+		AT_LEAST_ONE_SEP4(e) {
+			this.atLeastOneSepFirstInternal(4, e);
+		}
+		AT_LEAST_ONE_SEP5(e) {
+			this.atLeastOneSepFirstInternal(5, e);
+		}
+		AT_LEAST_ONE_SEP6(e) {
+			this.atLeastOneSepFirstInternal(6, e);
+		}
+		AT_LEAST_ONE_SEP7(e) {
+			this.atLeastOneSepFirstInternal(7, e);
+		}
+		AT_LEAST_ONE_SEP8(e) {
+			this.atLeastOneSepFirstInternal(8, e);
+		}
+		AT_LEAST_ONE_SEP9(e) {
+			this.atLeastOneSepFirstInternal(9, e);
+		}
+		RULE(e, t, n = dn) {
+			if (this.definedRulesNames.includes(e)) {
+				let t = {
+					message: J.buildDuplicateRuleNameError({
+						topLevelRule: e,
+						grammarName: this.className
+					}),
+					type: Q.DUPLICATE_RULE_NAME,
+					ruleName: e
+				};
+				this.definitionErrors.push(t);
+			}
+			this.definedRulesNames.push(e);
+			let r = this.defineRule(e, t, n);
+			return this[e] = r, r;
+		}
+		OVERRIDE_RULE(e, t, n = dn) {
+			let r = function(e, t, n) {
+				let r = [], i;
+				return t.includes(e) || (i = `Invalid rule override, rule: ->${e}<- cannot be overridden in the grammar: ->${n}<-as it is not defined in any of the super grammars `, r.push({
+					message: i,
+					type: Q.INVALID_RULE_OVERRIDE,
+					ruleName: e
+				})), r;
+			}(e, this.definedRulesNames, this.className);
+			this.definitionErrors = this.definitionErrors.concat(r);
+			let i = this.defineRule(e, t, n);
+			return this[e] = i, i;
+		}
+		BACKTRACK(e, t) {
+			let n = e.coreRule ?? e;
+			return function() {
+				this.isBackTrackingStack.push(1);
+				let e = this.saveRecogState();
+				try {
+					return n.apply(this, t), !0;
+				} catch (e) {
+					if (Pt(e)) return !1;
+					throw e;
+				} finally {
+					this.reloadRecogState(e), this.isBackTrackingStack.pop();
+				}
+			};
+		}
+		getGAstProductions() {
+			return this.gastProductionsCache;
+		}
+		getSerializedGastProductions() {
+			return Object.values(this.gastProductionsCache).map(_);
+		}
+	},
+	class {
+		initErrorHandler(e) {
+			this._errors = [], this.errorMessageProvider = Object.hasOwn(e, "errorMessageProvider") ? e.errorMessageProvider : $.errorMessageProvider;
+		}
+		SAVE_ERROR(e) {
+			if (Pt(e)) return e.context = {
+				ruleStack: this.getHumanReadableRuleStack(),
+				ruleOccurrenceStack: this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1)
+			}, this._errors.push(e), e;
+			throw Error("Trying to save an Error which is not a RecognitionException");
+		}
+		get errors() {
+			return [...this._errors];
+		}
+		set errors(e) {
+			this._errors = e;
+		}
+		raiseEarlyExitException(e, t, n) {
+			let r = this.getCurrRuleFullName(), i = ht(e, this.getGAstProductions()[r], t, this.maxLookahead)[0], a = [];
+			for (let e = 1; e <= this.maxLookahead; e++) a.push(this.LA(e));
+			let o = this.errorMessageProvider.buildEarlyExitMessage({
+				expectedIterationPaths: i,
+				actual: a,
+				previous: this.LA(0),
+				customUserDescription: n,
+				ruleName: r
+			});
+			throw this.SAVE_ERROR(new zt(o, this.LA(1), this.LA(0)));
+		}
+		raiseNoAltException(e, t) {
+			let n = this.getCurrRuleFullName(), r = mt(e, this.getGAstProductions()[n], this.maxLookahead), i = [];
+			for (let e = 1; e <= this.maxLookahead; e++) i.push(this.LA(e));
+			let a = this.LA(0), o = this.errorMessageProvider.buildNoViableAltMessage({
+				expectedPathsPerAlt: r,
+				actual: i,
+				previous: a,
+				customUserDescription: t,
+				ruleName: this.getCurrRuleFullName()
+			});
+			throw this.SAVE_ERROR(new Lt(o, this.LA(1), a));
+		}
+	},
+	class {
+		initGastRecorder(e) {
+			this.recordingProdStack = [], this.RECORDING_PHASE = !1;
+		}
+		enableRecording() {
+			this.RECORDING_PHASE = !0, this.TRACE_INIT("Enable Recording", () => {
+				for (let e = 0; e < 10; e++) {
+					let t = e > 0 ? e : "";
+					this[`CONSUME${t}`] = function(t, n) {
+						return this.consumeInternalRecord(t, e, n);
+					}, this[`SUBRULE${t}`] = function(t, n) {
+						return this.subruleInternalRecord(t, e, n);
+					}, this[`OPTION${t}`] = function(t) {
+						return this.optionInternalRecord(t, e);
+					}, this[`OR${t}`] = function(t) {
+						return this.orInternalRecord(t, e);
+					}, this[`MANY${t}`] = function(t) {
+						this.manyInternalRecord(e, t);
+					}, this[`MANY_SEP${t}`] = function(t) {
+						this.manySepFirstInternalRecord(e, t);
+					}, this[`AT_LEAST_ONE${t}`] = function(t) {
+						this.atLeastOneInternalRecord(e, t);
+					}, this[`AT_LEAST_ONE_SEP${t}`] = function(t) {
+						this.atLeastOneSepFirstInternalRecord(e, t);
+					};
+				}
+				this.consume = function(e, t, n) {
+					return this.consumeInternalRecord(t, e, n);
+				}, this.subrule = function(e, t, n) {
+					return this.subruleInternalRecord(t, e, n);
+				}, this.option = function(e, t) {
+					return this.optionInternalRecord(t, e);
+				}, this.or = function(e, t) {
+					return this.orInternalRecord(t, e);
+				}, this.many = function(e, t) {
+					this.manyInternalRecord(e, t);
+				}, this.atLeastOne = function(e, t) {
+					this.atLeastOneInternalRecord(e, t);
+				}, this.ACTION = this.ACTION_RECORD, this.BACKTRACK = this.BACKTRACK_RECORD, this.LA = this.LA_RECORD;
+			});
+		}
+		disableRecording() {
+			this.RECORDING_PHASE = !1, this.TRACE_INIT("Deleting Recording methods", () => {
+				let e = this;
+				for (let t = 0; t < 10; t++) {
+					let n = t > 0 ? t : "";
+					delete e[`CONSUME${n}`], delete e[`SUBRULE${n}`], delete e[`OPTION${n}`], delete e[`OR${n}`], delete e[`MANY${n}`], delete e[`MANY_SEP${n}`], delete e[`AT_LEAST_ONE${n}`], delete e[`AT_LEAST_ONE_SEP${n}`];
+				}
+				delete e.consume, delete e.subrule, delete e.option, delete e.or, delete e.many, delete e.atLeastOne, delete e.ACTION, delete e.BACKTRACK, delete e.LA;
+			});
+		}
+		ACTION_RECORD(e) {}
+		BACKTRACK_RECORD(e, t) {
+			return () => !0;
+		}
+		LA_RECORD(e) {
+			return Z;
+		}
+		topLevelRuleRecord(e, t) {
+			try {
+				let n = new c({
+					definition: [],
+					name: e
+				});
+				return n.name = e, this.recordingProdStack.push(n), t.call(this), this.recordingProdStack.pop(), n;
+			} catch (e) {
+				if (!0 !== e.KNOWN_RECORDER_ERROR) try {
+					e.message += "\n	 This error was thrown during the \"grammar recording phase\" For more info see:\n	https://chevrotain.io/docs/guide/internals.html#grammar-recording";
+				} catch {
+					throw e;
+				}
+				throw e;
+			}
+		}
+		optionInternalRecord(e, t) {
+			return X.call(this, u, e, t);
+		}
+		atLeastOneInternalRecord(e, t) {
+			X.call(this, d, t, e);
+		}
+		atLeastOneSepFirstInternalRecord(e, t) {
+			X.call(this, f, t, e, nn);
+		}
+		manyInternalRecord(e, t) {
+			X.call(this, p, t, e);
+		}
+		manySepFirstInternalRecord(e, t) {
+			X.call(this, m, t, e, nn);
+		}
+		orInternalRecord(e, t) {
+			return cn.call(this, e, t);
+		}
+		subruleInternalRecord(e, t, n) {
+			if (un(t), !e || !Object.hasOwn(e, "ruleName")) {
+				let n = /* @__PURE__ */ Error(`<SUBRULE${ln(t)}> argument is invalid expecting a Parser method reference but got: <${JSON.stringify(e)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
+				throw n.KNOWN_RECORDER_ERROR = !0, n;
+			}
+			let r = this.recordingProdStack.at(-1), i = e.ruleName, a = new s({
+				idx: t,
+				nonTerminalName: i,
+				label: n?.LABEL,
+				referencedRule: void 0
+			});
+			return r.definition.push(a), this.outputCst ? sn : tn;
+		}
+		consumeInternalRecord(e, t, n) {
+			if (un(t), !Me(e)) {
+				let n = /* @__PURE__ */ Error(`<CONSUME${ln(t)}> argument is invalid expecting a TokenType reference but got: <${JSON.stringify(e)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
+				throw n.KNOWN_RECORDER_ERROR = !0, n;
+			}
+			let r = this.recordingProdStack.at(-1), i = new g({
+				idx: t,
+				terminalType: e,
+				label: n?.LABEL
+			});
+			return r.definition.push(i), on;
+		}
+	},
+	class {
+		initPerformanceTracer(e) {
+			if (Object.hasOwn(e, "traceInitPerf")) {
+				let t = e.traceInitPerf, n = typeof t == "number";
+				this.traceInitMaxIdent = n ? t : Infinity, this.traceInitPerf = n ? t > 0 : t;
+			} else this.traceInitMaxIdent = 0, this.traceInitPerf = $.traceInitPerf;
+			this.traceInitIndent = -1;
+		}
+		TRACE_INIT(e, t) {
+			if (!0 === this.traceInitPerf) {
+				this.traceInitIndent++;
+				let n = Array(this.traceInitIndent + 1).join("	");
+				this.traceInitIndent < this.traceInitMaxIdent && console.log(`${n}--\x3e <${e}>`);
+				let { time: r, value: a } = i(t), o = r > 10 ? console.warn : console.log;
+				return this.traceInitIndent < this.traceInitMaxIdent && o(`${n}<-- <${e}> time: ${r}ms`), this.traceInitIndent--, a;
+			}
+			return t();
+		}
+	}
+].forEach((e) => {
+	let t = e.prototype;
+	Object.getOwnPropertyNames(t).forEach((n) => {
+		if (n === "constructor") return;
+		let r = Object.getOwnPropertyDescriptor(t, n);
+		r && (r.get || r.set) ? Object.defineProperty(fn.prototype, n, r) : fn.prototype[n] = e.prototype[n];
+	});
+});
+var mn = class extends pn {
+	constructor(e, t = $) {
+		let n = Object.assign({}, t);
+		n.outputCst = !1, super(e, n);
+	}
+}, hn = class n {
+	static shared(t) {
+		let r = t?.locale ?? e, i = t?.maxColumn ?? yn, a = t?.maxRow ?? bn, o = vn.get(r);
+		o || (o = /* @__PURE__ */ new Map(), vn.set(r, o));
+		let s = `${i}:${a}`, c = o.get(s);
+		return c || (c = new n({
+			locale: r,
+			maxColumn: i,
+			maxRow: a
+		}), o.set(s, c)), c;
+	}
+	constructor(t) {
+		let n = t?.maxColumn ?? yn, r = t?.maxRow ?? bn, i = t?.locale ?? e;
+		this._locale = i, this._maxColumn = n, this._maxRow = r;
+		let { separatorFunction: a, separatorColumn: o, separatorRow: s, separatorDecimal: c } = i.separators;
+		if (o === s) throw Error(`FormulaLexer: separatorColumn and separatorRow must differ (both '${o}')`);
+		let l = K({
+			name: "WhiteSpace",
+			pattern: /\s+/,
+			group: W.SKIPPED
+		}), u = K({
+			name: "StringToken",
+			pattern: /"(""|[^"])*"/
+		}), d = K({
+			name: "FunctionToken",
+			pattern: /[a-zA-Z_\u007F-\uFFFF]+[a-zA-Z0-9_.\u007F-\uFFFF]*(?=\()/
+		}), f = K({
+			name: "TableReference",
+			pattern: { exec: wn },
+			line_breaks: !1,
+			start_chars_hint: _n
+		}), p = K({
+			name: "BracketedString",
+			pattern: { exec: En },
+			line_breaks: !1,
+			start_chars_hint: [91],
+			longer_alt: [f, u]
+		}), m = (e) => (e ?? []).map((e) => e?.trim()).filter(Boolean).map((e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).map((e) => e + "|").join(""), h = K({
+			name: "LiteralError",
+			pattern: RegExp(m(i.errorLiterals) + "#PARSE!|#NULL!|#DIV\\/0!|#VALUE!|#NUM!|#FIELD!|#N\\/A|#GETTING_DATA|#SPILL!|#CONNECT!|#BLOCKED!|#UNKNOWN!|#CALC!|#BUSY!|#PYTHON!|#TIMEOUT!")
+		}), g = K({
+			name: "RefError",
+			pattern: RegExp(m(i.errorRefs) + "#REF!|#NAME\\?")
+		}), _ = K({
+			name: "SingleQuotedString",
+			pattern: /'(''|[^'])*'/
+		}), v = K({
+			name: "SheetQuoted",
+			pattern: /'(?:''|[^'])*?'!/
+		}), y = K({
+			name: "Sheet",
+			pattern: /[A-Za-z_.\d\u007F-\uFFFF]*!/
+		}), b = /[a-zA-Z_\\\u007F-\uFFFF][a-zA-Z0-9_.?\\\u007F-\uFFFF]*:?/y, x = K({
+			name: "NamedToken",
+			pattern: { exec: (e, t) => {
+				b.lastIndex = t;
+				let n = b.exec(e);
+				if (!n) return null;
+				let r = n[0], i = r.indexOf(".:");
+				return i === -1 ? r.endsWith(":") && (r = r.slice(0, -1)) : r = r.substring(0, i), [r];
+			} },
+			line_breaks: !1,
+			start_chars_hint: _n
+		}), S = K({
+			name: "Cell",
+			pattern: { exec: Cn(n, r) },
+			line_breaks: !1,
+			start_chars_hint: [36, ...gn],
+			longer_alt: x
+		}), C = K({
+			name: "Column",
+			pattern: { exec: Sn(n) },
+			line_breaks: !1,
+			start_chars_hint: [36, ...gn],
+			longer_alt: x
+		}), w = K({
+			name: "AbsRow",
+			pattern: /[$][0-9]+/
+		}), T = c === "." ? "\\." : c, E = K({
+			name: "NumberToken",
+			pattern: RegExp(`[0-9]+${T}(?!:)[0-9]*([eE][+-]?[0-9]+|\\*\\*[+-]?[0-9]+)?|${T}[0-9]+([eE][+-]?[0-9]+|\\*\\*[+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+`)
+		}), D = K({
+			name: "ScientificDigit",
+			pattern: /[0-9]+\*\*[+-]?[0-9]+/
+		}), O = K({
+			name: "DigitToken",
+			pattern: /[0-9]+/
+		}), k = ["TRUE", "FALSE"];
+		for (let e of [i.booleanTrue, i.booleanFalse]) {
+			let t = e?.trim();
+			t && !k.some((e) => e.toLowerCase() === t.toLowerCase()) && k.push(t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+		}
+		let A = K({
+			name: "BooleanToken",
+			pattern: new RegExp(k.join("|"), "i")
+		}), j = K({
+			name: "ArgSeparator",
+			pattern: Tn(a)
+		}), M = K({
+			name: "ColSeparator",
+			pattern: Tn(o)
+		}), N = K({
+			name: "RowSeparator",
+			pattern: Tn(s)
+		}), P = K({
+			name: "RangeOp",
+			pattern: /:/
+		}), ee = K({
+			name: "RangeTrimFullOp",
+			pattern: /\.:\./
+		}), te = K({
+			name: "RangeTrimLeadingOp",
+			pattern: /\.:/
+		}), F = K({
+			name: "RangeTrimTrailingOp",
+			pattern: /:\./
+		}), ne = K({
+			name: "OpenParen",
+			pattern: /\(/
+		}), I = K({
+			name: "CloseParen",
+			pattern: /\)/
+		}), L = K({
+			name: "OpenCurlyParen",
+			pattern: /{/
+		}), re = K({
+			name: "CloseCurlyParen",
+			pattern: /}/
+		}), ie = K({
+			name: "QuoteS",
+			pattern: /'/
+		}), ae = K({
+			name: "MulOp",
+			pattern: /\*(?!\*)/
+		}), oe = K({
+			name: "PlusOp",
+			pattern: /\+/
+		}), se = K({
+			name: "DivOp",
+			pattern: /\//
+		}), ce = K({
+			name: "MinOp",
+			pattern: /-/
+		}), le = K({
+			name: "ImplicitIntersectOp",
+			pattern: /@/
+		}), ue = K({
+			name: "ConcatOp",
+			pattern: /&/
+		}), de = K({
+			name: "ExOp",
+			pattern: /\^/
+		}), fe = K({
+			name: "PercentOp",
+			pattern: /%/
+		}), pe = K({
+			name: "ArrayAnchorOp",
+			pattern: /#/,
+			longer_alt: [h, g]
+		}), R = K({
+			name: "GtOp",
+			pattern: />/
+		}), me = K({
+			name: "EqOp",
+			pattern: /=/
+		}), he = K({
+			name: "LtOp",
+			pattern: /</
+		}), ge = [
+			l,
+			u,
+			v,
+			_,
+			y,
+			d,
+			f,
+			p,
+			h,
+			g,
+			j,
+			...o === a ? [] : [M],
+			N,
+			ee,
+			te,
+			F,
+			P,
+			S,
+			A,
+			C,
+			w,
+			E,
+			D,
+			O,
+			pe,
+			le,
+			x,
+			ne,
+			I,
+			L,
+			re,
+			ie,
+			ae,
+			oe,
+			se,
+			ce,
+			ue,
+			de,
+			fe,
+			K({
+				name: "NeqOp",
+				pattern: /<>/
+			}),
+			K({
+				name: "GteOp",
+				pattern: />=/
+			}),
+			K({
+				name: "LteOp",
+				pattern: /<=/
+			}),
+			R,
+			me,
+			he
+		];
+		this._lexer = new W(ge, { ensureOptimizations: !0 });
+		let _e = {};
+		ge.forEach((e) => {
+			_e[e.name] = e;
+		}), o === a && (_e.ColSeparator = j), this._vocabulary = _e;
+	}
+	tokenize(e, n = !0) {
+		let r = this._lexer.tokenize(e);
+		if (n && r.errors.length > 0) {
+			let n = r.errors[0], i = n.line, a = n.column, o = e.substr(n.offset, n.length || 1), s = o ? `Unexpected character '${o}'` : n.message;
+			throw new t.Parse(s, {
+				line: i,
+				column: a,
+				offset: n.offset,
+				length: n.length
+			});
+		}
+		return r;
+	}
+	getVocabulary() {
+		return this._vocabulary;
+	}
+	getLocale() {
+		return this._locale;
+	}
+	getMaxColumn() {
+		return this._maxColumn;
+	}
+	getMaxRow() {
+		return this._maxRow;
+	}
+	getSeparators() {
+		return this._locale.separators;
+	}
+}, gn = (() => {
+	let e = [];
+	for (let t = 65; t <= 90; t++) e.push(t);
+	for (let t = 97; t <= 122; t++) e.push(t);
+	for (let t = 48; t <= 57; t++) e.push(t);
+	return e;
+})().filter((e) => e < 48 || e > 57), _n = (() => {
+	let e = [
+		...gn,
+		95,
+		92
+	];
+	for (let t = 127; t <= 65535; t++) e.push(t);
+	return e;
+})(), vn = /* @__PURE__ */ new WeakMap(), yn = 16384, bn = 1048576;
+function xn(e, t, n) {
+	let r = 0;
+	for (let i = t; i < n; i++) {
+		let t = e.charCodeAt(i);
+		r = 26 * r + (t >= 97 ? t - 96 : t - 64);
+	}
+	return r;
+}
+function Sn(e) {
+	return (t, n) => {
+		let r = n;
+		t.charCodeAt(r) === 36 && r++;
+		let i = r;
+		for (; r < t.length && r - i < 3;) {
+			let e = t.charCodeAt(r);
+			if (!(e >= 65 && e <= 90 || e >= 97 && e <= 122)) break;
+			r++;
+		}
+		if (r - i === 0 || xn(t, i, r) > e) return null;
+		if (r < t.length) {
+			let e = t.charCodeAt(r);
+			if (e >= 48 && e <= 57) return null;
+		}
+		return [t.substring(n, r)];
+	};
+}
+function Cn(e, t) {
+	return (n, r) => {
+		let i = r;
+		n.charCodeAt(i) === 36 && i++;
+		let a = i;
+		for (; i < n.length && i - a < 3;) {
+			let e = n.charCodeAt(i);
+			if (!(e >= 65 && e <= 90 || e >= 97 && e <= 122)) break;
+			i++;
+		}
+		if (i - a === 0 || xn(n, a, i) > e) return null;
+		i < n.length && n.charCodeAt(i) === 36 && i++;
+		let o = i;
+		if (i >= n.length) return null;
+		let s = n.charCodeAt(i);
+		if (s < 49 || s > 57) return null;
+		for (i++; i < n.length;) {
+			let e = n.charCodeAt(i);
+			if (!(e >= 48 && e <= 57)) break;
+			i++;
+		}
+		return parseInt(n.substring(o, i), 10) > t ? null : [n.substring(r, i)];
+	};
+}
+function wn(e, t) {
+	let n = e.charCodeAt(t);
+	if (!(n >= 65 && n <= 90 || n >= 97 && n <= 122 || n === 95 || n >= 127 && n <= 65535)) return null;
+	let r = t + 1;
+	for (; r < e.length;) {
+		let t = e.charCodeAt(r);
+		if (!(t >= 65 && t <= 90 || t >= 97 && t <= 122 || t >= 48 && t <= 57 || t === 95 || t === 46 || t >= 127 && t <= 65535)) break;
+		r++;
+	}
+	if (r >= e.length || e.charCodeAt(r) !== 91) return null;
+	let i = 0;
+	for (; r < e.length;) {
+		let n = e.charCodeAt(r);
+		if (n === 91) i++;
+		else if (n === 93 && (i--, i === 0)) return [e.substring(t, r + 1)];
+		r++;
+	}
+	return null;
+}
+function Tn(e) {
+	return new RegExp(e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+}
+function En(e, t) {
+	if (e.charCodeAt(t) !== 91) return null;
+	let n = 0, r = t;
+	for (; r < e.length;) {
+		let i = e.charCodeAt(r);
+		if (i === 91) n++;
+		else if (i === 93 && (n--, n === 0)) return [e.substring(t, r + 1)];
+		r++;
+	}
+	return null;
+}
+export { K as a, q as i, mn as n, W as o, qe as r, hn as t };