@sheetxl/studio-vanilla 0.8.0-beta.1 → 0.8.0-beta.2

package/browser/esm/BkSb_vyWe-AhyEDa.mjs

@@ -1,4423 +0,0 @@
-/**
-* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.1
-*
-* (C) 2026-present SheetXL Inc. & Michael T. Ford
-* License: The license can be found at https://www.sheetxl.com/license.
-*/
-import { o as e } from "./D_t53-8k73CNpV-p.mjs";
-import { Vt as t } from "./At60x9FEPePwPP_J.mjs";
-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 = [], r = e.definition, i = 0, a = r.length > i, o = !0;
-		for (; a && o;) t = r[i], o = b(t), n = n.concat(w(t)), i += 1, a = r.length > i;
-		return [...new Set(n)];
-	}(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 F = [
-	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("")
-], ee = /[0-9a-fA-F]/, I = /[0-9]/, te = /[1-9]/, L = 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) {}
-}, R = {}, ne = 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 = F;
-				break;
-			case "S":
-				e = F, 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 === te.test(e)) throw Error("Expecting a positive integer");
-		for (; I.test(this.peekChar(0));) e += this.popChar();
-		return parseInt(e, 10);
-	}
-	integerIncludingZero() {
-		let e = this.popChar();
-		if (!1 === I.test(e)) throw Error("Expecting an integer");
-		for (; I.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 I.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 === ee.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 z(e) {
-	let t = e.toString();
-	if (R.hasOwnProperty(t)) return R[t];
-	{
-		let e = ne.pattern(t);
-		return R[t] = e, e;
-	}
-}
-var re = "Complement Sets are not supported for first char optimization", ie = "Unable to use \"first char\" lexer optimizations:\n";
-function ae(e, t = !1) {
-	try {
-		let t = z(e);
-		return oe(t.value, {}, t.flags.ignoreCase);
-	} catch (i) {
-		if (i.message === re) t && r(`${ie}\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(`${ie}\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 oe(e, t, n) {
-	switch (e.type) {
-		case "Disjunction":
-			for (let r = 0; r < e.value.length; r++) oe(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":
-						se(a.value, t, n);
-						break;
-					case "Set":
-						if (!0 === a.complement) throw Error(re);
-						a.value.forEach((e) => {
-							if (typeof e == "number") se(e, t, n);
-							else {
-								let r = e;
-								if (!0 === n) for (let e = r.from; e <= r.to; e++) se(e, t, n);
-								else {
-									for (let e = r.from; e <= r.to && e < 256; e++) se(e, t, n);
-									if (r.to >= 256) {
-										let e = r.from >= 256 ? r.from : 256, n = r.to, i = V(e), a = V(n);
-										for (let e = i; e <= a; e++) t[e] = e;
-									}
-								}
-							}
-						});
-						break;
-					case "Group":
-						oe(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 === le(a) || a.type !== "Group" && !1 === o) break;
-			}
-			break;
-		default: throw Error("non exhaustive match!");
-	}
-	return Object.values(t);
-}
-function se(e, t, n) {
-	let r = V(e);
-	t[r] = r, !0 === n && function(e, t) {
-		let n = String.fromCharCode(e), r = n.toUpperCase();
-		if (r !== n) {
-			let e = V(r.charCodeAt(0));
-			t[e] = e;
-		} else {
-			let e = n.toLowerCase();
-			if (e !== n) {
-				let n = V(e.charCodeAt(0));
-				t[n] = n;
-			}
-		}
-	}(e, t);
-}
-function ce(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 le(e) {
-	let t = e.quantifier;
-	return !(!t || t.atLeast !== 0) || !!e.value && (Array.isArray(e.value) ? e.value.every(le) : le(e.value));
-}
-var ue = class extends L {
-	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 ? ce(e, this.targetCharCodes) === void 0 && (this.found = !0) : ce(e, this.targetCharCodes) !== void 0 && (this.found = !0);
-	}
-};
-function de(e, t) {
-	if (t instanceof RegExp) {
-		let n = z(t), r = new ue(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 B = "PATTERN", fe = "defaultMode";
-function pe(e, t) {
-	let r, i = (t = Object.assign({
-		safeMode: !1,
-		positionTracking: "full",
-		lineTerminatorCharacters: ["\r", "\n"],
-		tracer: (e, t) => t()
-	}, t)).tracer;
-	i("initCharCodeToOptimizedIndexMap", () => {
-		(function() {
-			if (we.length === 0) {
-				we = Array(65536);
-				for (let e = 0; e < 65536; e++) we[e] = e > 255 ? 255 + ~~(e / 255) : e;
-			}
-		})();
-	}), i("Reject Lexer.NA", () => {
-		r = e.filter((e) => e[B] !== K.NA);
-	});
-	let a, o, s, c, l, u, d, f, p, m, h, g = !1;
-	i("Transform Patterns", () => {
-		g = !1, a = r.map((e) => {
-			let t = e[B];
-			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]) ? ge(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 ge(new RegExp(e));
-				}
-			}
-			throw Error("non exhaustive match");
-		});
-	}), i("misc mapping", () => {
-		o = r.map((e) => e.tokenTypeIdx), s = r.map((e) => {
-			let t = e.GROUP;
-			if (t !== K.SKIPPED) {
-				if (typeof t == "string") return t;
-				if (t === void 0) return !1;
-				throw Error("non exhaustive match");
-			}
-		}), c = r.map((e) => {
-			let t = e.LONGER_ALT;
-			if (t) return Array.isArray(t) ? t.map((e) => r.indexOf(e)) : [r.indexOf(t)];
-		}), l = r.map((e) => e.PUSH_MODE), u = r.map((e) => Object.hasOwn(e, "POP_MODE"));
-	}), i("Line Terminator Handling", () => {
-		let e = Se(t.lineTerminatorCharacters);
-		d = r.map((e) => !1), t.positionTracking !== "onlyOffset" && (d = r.map((t) => Object.hasOwn(t, "LINE_BREAKS") ? !!t.LINE_BREAKS : !1 === be(t, e) && de(e, t.PATTERN)));
-	}), i("Misc Mapping #2", () => {
-		f = r.map(_e), p = a.map(ve), m = r.reduce((e, t) => {
-			let n = t.GROUP;
-			return typeof n == "string" && n !== K.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: r[t]
-		}));
-	});
-	let _ = !0, v = [];
-	return t.safeMode || i("First Char Optimization", () => {
-		v = r.reduce((e, r, i) => {
-			if (typeof r.PATTERN == "string") Ce(e, V(r.PATTERN.charCodeAt(0)), h[i]);
-			else if (Array.isArray(r.START_CHARS_HINT)) {
-				let t;
-				r.START_CHARS_HINT.forEach((n) => {
-					let r = V(typeof n == "string" ? n.charCodeAt(0) : n);
-					t !== r && (t = r, Ce(e, r, h[i]));
-				});
-			} else if (r.PATTERN instanceof RegExp) if (r.PATTERN.unicode) _ = !1, t.ensureOptimizations && n(`${ie}\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 = ae(r.PATTERN, t.ensureOptimizations);
-				n.length === 0 && (_ = !1), n.forEach((t) => {
-					Ce(e, t, h[i]);
-				});
-			}
-			else t.ensureOptimizations && n(`${ie}\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: _
-	};
-}
-var me = /[^\\][$]/, he = /[^\\[][\^]|^\^/;
-function ge(e) {
-	let t = e.ignoreCase ? "iy" : "y";
-	return RegExp(`${e.source}`, t);
-}
-function _e(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 ve(e) {
-	return typeof e == "string" && e.length === 1 && e.charCodeAt(0);
-}
-var ye = {
-	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 be(e, t) {
-	if (Object.hasOwn(e, "LINE_BREAKS")) return !1;
-	if (e.PATTERN instanceof RegExp) {
-		try {
-			de(t, e.PATTERN);
-		} catch (e) {
-			return {
-				issue: U.IDENTIFY_TERMINATOR,
-				errMsg: e.message
-			};
-		}
-		return !1;
-	}
-	if (typeof e.PATTERN == "string") return !1;
-	if (_e(e)) return { issue: U.CUSTOM_LINE_BREAK };
-	throw Error("non exhaustive match");
-}
-function xe(e, t) {
-	if (t.issue === U.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 === U.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 Se(e) {
-	return e.map((e) => typeof e == "string" ? e.charCodeAt(0) : e);
-}
-function Ce(e, t, n) {
-	e[t] === void 0 ? e[t] = [n] : e[t].push(n);
-}
-var we = [];
-function V(e) {
-	return e < 256 ? e : we[e];
-}
-function H(e, t) {
-	let n = e.tokenTypeIdx;
-	return n === t.tokenTypeIdx || !0 === t.isParent && !0 === t.categoryMatchesMap[n];
-}
-function Te(e, t) {
-	return e.tokenTypeIdx === t.tokenTypeIdx;
-}
-var U, Ee = 1, De = {};
-function W(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;
-			ke(e) || (De[Ee] = e, e.tokenTypeIdx = Ee++), Ae(e) && !Array.isArray(e.CATEGORIES) && (e.CATEGORIES = [e.CATEGORIES]), Ae(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) => {
-			Oe([], e);
-		});
-	}(t), function(e) {
-		e.forEach((e) => {
-			e.categoryMatches = [], Object.keys(e.categoryMatchesMap).forEach((t) => {
-				e.categoryMatches.push(De[t].tokenTypeIdx);
-			});
-		});
-	}(t), t.forEach((e) => {
-		e.isParent = e.categoryMatches.length > 0;
-	});
-}
-function Oe(e, t) {
-	e.forEach((e) => {
-		t.categoryMatchesMap[e.tokenTypeIdx] = !0;
-	}), t.CATEGORIES.forEach((n) => {
-		let r = e.concat(t);
-		r.includes(n) || Oe(r, n);
-	});
-}
-function ke(e) {
-	return Object.hasOwn(e ?? {}, "tokenTypeIdx");
-}
-function Ae(e) {
-	return Object.hasOwn(e ?? {}, "CATEGORIES");
-}
-function je(e) {
-	return Object.hasOwn(e ?? {}, "tokenTypeIdx");
-}
-var G;
-(G = U ||= {})[G.MISSING_PATTERN = 0] = "MISSING_PATTERN", G[G.INVALID_PATTERN = 1] = "INVALID_PATTERN", G[G.EOI_ANCHOR_FOUND = 2] = "EOI_ANCHOR_FOUND", G[G.UNSUPPORTED_FLAGS_FOUND = 3] = "UNSUPPORTED_FLAGS_FOUND", G[G.DUPLICATE_PATTERNS_FOUND = 4] = "DUPLICATE_PATTERNS_FOUND", G[G.INVALID_GROUP_TYPE_FOUND = 5] = "INVALID_GROUP_TYPE_FOUND", G[G.PUSH_MODE_DOES_NOT_EXIST = 6] = "PUSH_MODE_DOES_NOT_EXIST", G[G.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE = 7] = "MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE", G[G.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY = 8] = "MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY", G[G.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST = 9] = "MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST", G[G.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED = 10] = "LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED", G[G.SOI_ANCHOR_FOUND = 11] = "SOI_ANCHOR_FOUND", G[G.EMPTY_MATCH_PATTERN = 12] = "EMPTY_MATCH_PATTERN", G[G.NO_LINE_BREAKS_FLAGS = 13] = "NO_LINE_BREAKS_FLAGS", G[G.UNREACHABLE_PATTERN = 14] = "UNREACHABLE_PATTERN", G[G.IDENTIFY_TERMINATOR = 15] = "IDENTIFY_TERMINATOR", G[G.CUSTOM_LINE_BREAK = 16] = "CUSTOM_LINE_BREAK", G[G.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE = 17] = "MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE";
-var Me = {
-	deferDefinitionErrorsHandling: !1,
-	positionTracking: "full",
-	lineTerminatorsPattern: /\n|\r\n?/g,
-	lineTerminatorCharacters: ["\n", "\r"],
-	ensureOptimizations: !1,
-	safeMode: !1,
-	errorMessageProvider: {
-		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.`
-	},
-	traceInitPerf: !1,
-	skipValidations: !1,
-	recoveryEnabled: !0
-};
-Object.freeze(Me);
-var K = class {
-	constructor(e, t = Me) {
-		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({}, Me, 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 === Me.lineTerminatorsPattern) this.config.lineTerminatorsPattern = ye;
-				else if (this.config.lineTerminatorCharacters === Me.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: fe
-				} : (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: U.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: U.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 ${fe}: <${e.defaultMode}>which does not exist\n`,
-						type: U.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: U.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: U.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[B] !== K.NA), o = Se(n);
-					return t && a.forEach((e) => {
-						let t = be(e, o);
-						if (!1 !== t) {
-							let n = {
-								message: xe(e, t),
-								type: t.issue,
-								tokenType: e
-							};
-							r.push(n);
-						} else Object.hasOwn(e, "LINE_BREAKS") ? !0 === e.LINE_BREAKS && (i = !0) : de(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: U.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(function(e, t) {
-							let n = [], r = function(e) {
-								let t = e.filter((e) => !Object.hasOwn(e, B));
-								return {
-									errors: t.map((e) => ({
-										message: "Token Type: ->" + e.name + "<- missing static 'PATTERN' property",
-										type: U.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[B];
-									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: U.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[B] instanceof RegExp);
-								return t = t.concat(function(e) {
-									class t extends L {
-										constructor() {
-											super(...arguments), this.found = !1;
-										}
-										visitEndAnchor(e) {
-											this.found = !0;
-										}
-									}
-									return e.filter((e) => {
-										let n = e.PATTERN;
-										try {
-											let e = z(n), r = new t();
-											return r.visit(e), r.found;
-										} catch {
-											return me.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: U.EOI_ANCHOR_FOUND,
-										tokenTypes: [e]
-									}));
-								}(n)), t = t.concat(function(e) {
-									class t extends L {
-										constructor() {
-											super(...arguments), this.found = !1;
-										}
-										visitStartAnchor(e) {
-											this.found = !0;
-										}
-									}
-									return e.filter((e) => {
-										let n = e.PATTERN;
-										try {
-											let e = z(n), r = new t();
-											return r.visit(e), r.found;
-										} catch {
-											return he.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: U.SOI_ANCHOR_FOUND,
-										tokenTypes: [e]
-									}));
-								}(n)), t = t.concat(function(e) {
-									return e.filter((e) => {
-										let t = e[B];
-										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: U.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 === K.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: U.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: U.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 !== K.SKIPPED && t !== K.NA && typeof t != "string";
-								}).map((e) => ({
-									message: "Token Type: ->" + e.name + "<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String",
-									type: U.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: U.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 === K.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: U.UNREACHABLE_PATTERN,
-												tokenTypes: [e, a]
-											});
-										}
-									});
-								}), t;
-							}(a)), n;
-						}(n, o));
-					}), this.lexerDefinitionErrors.length === 0) {
-						let r;
-						W(n), this.TRACE_INIT("analyzeTokenTypes", () => {
-							r = pe(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", () => {
-				R = {};
-			}), 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, F = !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;
-				F = !(!j || !t);
-			}
-		};
-		function I(e) {
-			M.push(e), j = this.charCodeToPatternIdxToConfig[e], A = this.patternIdxToConfig[e], k = A.length;
-			let t = this.canModeBeOptimized[e] && !1 === this.config.safeMode;
-			F = !(!j || !t);
-		}
-		I.call(this, t);
-		let te = this.config.recoveryEnabled;
-		for (; y < v;) {
-			s = null, u = -1;
-			let t, x = _.charCodeAt(y);
-			if (F) {
-				let e = V(x), n = j[e];
-				t = n === void 0 ? N : n;
-			} else t = A;
-			let L = t.length;
-			for (n = 0; n < L; n++) {
-				P = t[n];
-				let r = P.pattern;
-				c = null;
-				let d = P.short;
-				if (!1 === d ? !0 === P.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)) : x === d && (u = 1, s = r), u !== -1) {
-					if (o = P.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, P = t;
-								break;
-							}
-						}
-					}
-					break;
-				}
-			}
-			if (u !== -1) {
-				if (d = P.group, d !== void 0 && (s = s === null ? e.substring(y, y + u) : s, f = P.tokenTypeIdx, p = this.createTokenInstance(s, y, f, P.tokenType, w, T, u), this.handlePayload(p, c), !1 === d ? b = this.addToken(S, b, p) : E[d].push(p)), !0 === D && !0 === P.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(P, ee, I, p);
-			} else {
-				let t = y, n = w, i = T, a = !1 === te;
-				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 === te) 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 Ne(e) {
-	return Pe(e) ? e.LABEL : e.name;
-}
-function Pe(e) {
-	return typeof e.LABEL == "string" && e.LABEL !== "";
-}
-K.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.", K.NA = /NOT_APPLICABLE/;
-var Fe = "categories", Ie = "label", Le = "group", Re = "push_mode", ze = "pop_mode", Be = "longer_alt", Ve = "line_breaks", He = "start_chars_hint";
-function q(e) {
-	return function(e) {
-		let t = e.pattern, n = {};
-		if (n.name = e.name, t !== void 0 && (n.PATTERN = t), Object.hasOwn(e, "parent")) throw "The parent property is no longer supported.\nSee: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.";
-		return Object.hasOwn(e, Fe) && (n.CATEGORIES = e[Fe]), W([n]), Object.hasOwn(e, Ie) && (n.LABEL = e[Ie]), Object.hasOwn(e, Le) && (n.GROUP = e[Le]), Object.hasOwn(e, ze) && (n.POP_MODE = e[ze]), Object.hasOwn(e, Re) && (n.PUSH_MODE = e[Re]), Object.hasOwn(e, Be) && (n.LONGER_ALT = e[Be]), Object.hasOwn(e, Ve) && (n.LINE_BREAKS = e[Ve]), Object.hasOwn(e, He) && (n.START_CHARS_HINT = e[He]), n;
-	}(e);
-}
-var J = q({
-	name: "EOF",
-	pattern: K.NA
-});
-function Ue(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
-	};
-}
-W([J]);
-var We = {
-	buildMismatchTokenMessage: ({ expected: e, actual: t, previous: n, ruleName: r }) => `Expecting ${Pe(e) ? `--\x3e ${Ne(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) => Ne(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) => Ne(e)).join(",")}]`).join(" ,")}>` + i;
-	}
-};
-Object.freeze(We);
-var Y, Ge = { buildRuleNotFoundError: (e, t) => "Invalid grammar, reference to a rule which is not defined: ->" + t.nonTerminalName + "<-\ninside top level rule: ->" + e.name + "<-" }, X = {
-	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) => Ne(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 r += n ? "These alternatives are all empty (match no tokens), making them indistinguishable.\nOnly the last alternative may be empty.\n" : `<${e.prefixPath.map((e) => Ne(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}<-`;
-	}
-}, Ke = 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: Z.UNRESOLVED_SUBRULE_REF,
-				ruleName: this.currTopLevel.name,
-				unresolvedRefName: e.nonTerminalName
-			});
-		}
-	}
-}, qe = 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());
-	}
-}, Je = class extends qe {
-	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;
-		}
-	}
-}, Ye = 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;
-	}
-}, Xe = class extends Ye {
-	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);
-	}
-}, Ze = class extends Ye {
-	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);
-	}
-}, Qe = class extends Ye {
-	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);
-	}
-}, $e = class extends Ye {
-	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 et(e, t, n = []) {
-	n = [...n];
-	let r = [], i = 0;
-	function a(a) {
-		let o = et(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 tt(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 nt(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 rt(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 it(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 at = 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);
-	}
-}, ot = 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 st(e) {
-	let t = Array(e);
-	for (let n = 0; n < e; n++) t[n] = [];
-	return t;
-}
-function ct(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 lt(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 ut(e, t) {
-	let n = e.map((e) => et([e], 1)), r = st(n.length), i = n.map((e) => {
-		let t = {};
-		return e.forEach((e) => {
-			ct(e.partialPath).forEach((e) => {
-				t[e] = !0;
-			});
-		}), t;
-	}), a = n;
-	for (let e = 1; e <= t; e++) {
-		let n = a;
-		a = st(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 = ct(c);
-				if (lt(i, u, o) || l.length === 0 || c.length === t) {
-					let e = r[o];
-					if (!1 === pt(e, c)) {
-						e.push(c);
-						for (let e = 0; e < u.length; e++) {
-							let t = u[e];
-							i[o][t] = !0;
-						}
-					}
-				} else {
-					let t = et(l, e + 1, c);
-					a[o] = a[o].concat(t), t.forEach((e) => {
-						ct(e.partialPath).forEach((e) => {
-							i[o][e] = !0;
-						});
-					});
-				}
-			}
-		}
-	}
-	return r;
-}
-function dt(e, t, n, r) {
-	let i = new ot(e, Y.ALTERNATION, r);
-	return t.accept(i), ut(i.result, n);
-}
-function ft(e, t, n, r) {
-	let i = new ot(e, n);
-	t.accept(i);
-	let a = i.result, o = new at(t, e, n).startWalking();
-	return ut([new l({ definition: a }), new l({ definition: o })], r);
-}
-function pt(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 mt(e) {
-	return e.every((e) => e.every((e) => e.every((e) => e.categoryMatches.length === 0)));
-}
-function ht(e) {
-	return `${x(e)}_#_${e.idx}_#_${gt(e)}`;
-}
-function gt(e) {
-	return e instanceof g ? e.terminalType.name : e instanceof s ? e.nonTerminalName : "";
-}
-var _t = 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 vt(e, t, n, r = []) {
-	let i = [], a = yt(t.definition);
-	if (a.length === 0) return [];
-	{
-		let t = e.name;
-		a.includes(e) && i.push({
-			message: n.buildLeftRecursionError({
-				topLevelRule: e,
-				leftRecursionPath: r
-			}),
-			type: Z.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), vt(e, t, n, i);
-		});
-		return i.concat(s);
-	}
-}
-function yt(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(yt(n.definition));
-	else if (n instanceof h) t = n.definition.map((e) => yt(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(yt(n));
-	}
-	return t;
-}
-var bt = class extends y {
-	constructor() {
-		super(...arguments), this.alternations = [];
-	}
-	visitAlternation(e) {
-		this.alternations.push(e);
-	}
-}, xt = 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);
-	}
-}, St = "MismatchedTokenException", Ct = "NoViableAltException", wt = "EarlyExitException", Tt = "NotAllInputParsedException", Et = [
-	St,
-	Ct,
-	wt,
-	Tt
-];
-function Dt(e) {
-	return Et.includes(e.name);
-}
-Object.freeze(Et);
-var Ot = 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);
-	}
-}, kt = class extends Ot {
-	constructor(e, t, n) {
-		super(e, t), this.previousToken = n, this.name = St;
-	}
-}, At = class extends Ot {
-	constructor(e, t, n) {
-		super(e, t), this.previousToken = n, this.name = Ct;
-	}
-}, jt = class extends Ot {
-	constructor(e, t) {
-		super(e, t), this.name = Tt;
-	}
-}, Mt = class extends Ot {
-	constructor(e, t, n) {
-		super(e, t), this.previousToken = n, this.name = wt;
-	}
-}, Nt = {}, Pt = class extends Error {
-	constructor(e) {
-		super(e), this.name = "InRuleRecoveryException";
-	}
-};
-function Ft(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 = J, u = 1), l !== void 0 && u !== void 0 && this.shouldInRepetitionRecoveryBeTried(l, u, o) && this.tryInRepetitionRecovery(e, t, n, l);
-}
-var It = 1024, Lt = 1280, Rt = 1536;
-function zt(e, t, n) {
-	return n | t | e;
-}
-var Bt, Vt = 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) => vt(e, e, X));
-	}
-	validateEmptyOrAlternatives(e) {
-		return e.flatMap((e) => function(e, t) {
-			let n = new bt();
-			return e.accept(n), n.alternations.flatMap((n) => n.definition.slice(0, -1).flatMap((r, i) => function(e, t, n) {
-				let r = "EXIT_NONE_TERMINAL", i = [r], a = "EXIT_ALTERNATIVE", o = !1, _ = t.length, v = _ - 1 - 1, y = [], b = [];
-				for (b.push({
-					idx: -1,
-					def: e,
-					ruleStack: [],
-					occurrenceStack: []
-				}); b.length !== 0;) {
-					let e = b.pop();
-					if (e === a) {
-						o && b.at(-1).idx <= v && b.pop();
-						continue;
-					}
-					let x = e.def, S = e.idx, C = e.ruleStack, w = e.occurrenceStack;
-					if (x.length === 0) continue;
-					let T = x[0];
-					if (T === r) {
-						let e = {
-							idx: S,
-							def: x.slice(1),
-							ruleStack: C.slice(0, -1),
-							occurrenceStack: w.slice(0, -1)
-						};
-						b.push(e);
-					} else if (T instanceof g) if (S < _ - 1) {
-						let e = S + 1;
-						if (n(t[e], T.terminalType)) {
-							let t = {
-								idx: e,
-								def: x.slice(1),
-								ruleStack: C,
-								occurrenceStack: w
-							};
-							b.push(t);
-						}
-					} else {
-						if (S !== _ - 1) throw Error("non exhaustive match");
-						y.push({
-							nextTokenType: T.terminalType,
-							nextTokenOccurrence: T.idx,
-							ruleStack: C,
-							occurrenceStack: w
-						}), o = !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(i, x.slice(1)),
-							ruleStack: e,
-							occurrenceStack: t
-						};
-						b.push(n);
-					} else if (T instanceof u) {
-						let e = {
-							idx: S,
-							def: x.slice(1),
-							ruleStack: C,
-							occurrenceStack: w
-						};
-						b.push(e), b.push(a);
-						let t = {
-							idx: S,
-							def: T.definition.concat(x.slice(1)),
-							ruleStack: C,
-							occurrenceStack: w
-						};
-						b.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], x.slice(1)),
-							ruleStack: C,
-							occurrenceStack: w
-						};
-						b.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], x.slice(1)),
-							ruleStack: C,
-							occurrenceStack: w
-						};
-						b.push(t);
-					} else if (T instanceof m) {
-						let e = {
-							idx: S,
-							def: x.slice(1),
-							ruleStack: C,
-							occurrenceStack: w
-						};
-						b.push(e), b.push(a);
-						let t = new p({
-							definition: [new g({ terminalType: T.separator })].concat(T.definition),
-							idx: T.idx
-						}), n = {
-							idx: S,
-							def: T.definition.concat([t], x.slice(1)),
-							ruleStack: C,
-							occurrenceStack: w
-						};
-						b.push(n);
-					} else if (T instanceof p) {
-						let e = {
-							idx: S,
-							def: x.slice(1),
-							ruleStack: C,
-							occurrenceStack: w
-						};
-						b.push(e), b.push(a);
-						let t = new p({
-							definition: T.definition,
-							idx: T.idx
-						}), n = {
-							idx: S,
-							def: T.definition.concat([t], x.slice(1)),
-							ruleStack: C,
-							occurrenceStack: w
-						};
-						b.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(x.slice(1)),
-							ruleStack: C,
-							occurrenceStack: w
-						};
-						b.push(t), b.push(a);
-					}
-					else if (T instanceof l) b.push({
-						idx: S,
-						def: T.definition.concat(x.slice(1)),
-						ruleStack: C,
-						occurrenceStack: w
-					});
-					else {
-						if (!(T instanceof c)) throw Error("non exhaustive match");
-						b.push(tt(T, S, C, w));
-					}
-				}
-				return y;
-			}([r], [], H).length === 0 ? [{
-				message: t.buildEmptyAlternationError({
-					topLevelRule: e,
-					alternation: n,
-					emptyChoiceIdx: i
-				}),
-				type: Z.NONE_LAST_EMPTY_ALT,
-				ruleName: e.name,
-				occurrence: n.idx,
-				alternative: i + 1
-			}] : []));
-		}(e, X));
-	}
-	validateAmbiguousAlternationAlternatives(e, t) {
-		return e.flatMap((e) => function(e, t, n) {
-			let r = new bt();
-			e.accept(r);
-			let i = r.alternations;
-			return i = i.filter((e) => !0 !== e.ignoreAmbiguities), i.flatMap((r) => {
-				let i = dt(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 && pt(e, r) && !0 !== t.definition[n].ignoreAmbiguities && o.push(n);
-						}), o.length > 1 && !pt(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: Z.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: Z.AMBIGUOUS_PREFIX_ALTS,
-								ruleName: n.name,
-								occurrence: o,
-								alternatives: i
-							};
-						});
-					});
-				}(i, r, e, n);
-				return a.concat(o);
-			});
-		}(e, t, X));
-	}
-	validateSomeNonEmptyLookaheadPath(e, t) {
-		return function(e, t, n) {
-			let r = [];
-			return e.forEach((e) => {
-				let i = new xt();
-				e.accept(i), i.allProductions.forEach((i) => {
-					let a = nt(i), o = i.maxLookahead || t;
-					if (ft(i.idx, e, a, o)[0].flat().length === 0) {
-						let t = n.buildEmptyRepetitionError({
-							topLevelRule: e,
-							repetition: i
-						});
-						r.push({
-							message: t,
-							type: Z.NO_NON_EMPTY_LOOKAHEAD,
-							ruleName: e.name
-						});
-					}
-				});
-			}), r;
-		}(e, t, X);
-	}
-	buildLookaheadForAlternation(e) {
-		return function(e, t, n, r, i, a) {
-			let o = dt(e, t, n);
-			return a(o, r, mt(o) ? Te : H, i);
-		}(e.prodOccurrence, e.rule, e.maxLookahead, e.hasPredicates, e.dynamicTokensEnabled, rt);
-	}
-	buildLookaheadForOptional(e) {
-		return function(e, t, n, r, i, a) {
-			let o = ft(e, t, i, n), s = mt(o) ? Te : H;
-			return a(o[0], s, r);
-		}(e.prodOccurrence, e.rule, e.maxLookahead, e.dynamicTokensEnabled, nt(e.prodType), it);
-	}
-}, Ht = 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 Ut(e, t) {
-	e.startOffset === -1 ? (e.startOffset = t.startOffset, e.endOffset = t.endOffset) : e.endOffset < t.endOffset == 1 && (e.endOffset = t.endOffset);
-}
-function Wt(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);
-}
-function Gt(e, t) {
-	Object.defineProperty(e, "name", {
-		enumerable: !1,
-		configurable: !0,
-		writable: !1,
-		value: t
-	});
-}
-function Kt(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(e) {
-	e[e.REDUNDANT_METHOD = 0] = "REDUNDANT_METHOD", e[e.MISSING_METHOD = 1] = "MISSING_METHOD";
-})(Bt ||= {});
-var qt = { description: "This Object indicates the Parser is during Recording Phase" };
-Object.freeze(qt);
-var Jt = !0, Yt = q({
-	name: "RECORDING_PHASE_TOKEN",
-	pattern: K.NA
-});
-W([Yt]);
-var Xt = Ue(Yt, "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(Xt);
-var Zt = {
-	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 Qt(e, t, n, r = !1) {
-	tn(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(), qt;
-}
-function $t(e, t) {
-	tn(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();
-	}), qt;
-}
-function en(e) {
-	return e === 0 ? "" : `${e}`;
-}
-function tn(e) {
-	if (e < 0 || e > 255) {
-		let t = Error(`Invalid DSL Method idx value: <${e}>\n\tIdx value must be a none negative value smaller than 256`);
-		throw t.KNOWN_RECORDER_ERROR = !0, t;
-	}
-}
-var Z, Q = Ue(J, "", -1, -1, -1, -1, -1, -1);
-Object.freeze(Q);
-var nn, $ = Object.freeze({
-	recoveryEnabled: !1,
-	maxLookahead: 3,
-	dynamicTokensEnabled: !1,
-	outputCst: !0,
-	errorMessageProvider: We,
-	nodeLocationTracking: "none",
-	traceInitPerf: !1,
-	skipValidations: !1
-}), rn = 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";
-})(Z ||= {});
-var an = 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, n = this[e].originalGrammarAction;
-						this.TRACE_INIT(`${e} Rule`, () => {
-							t = this.topLevelRuleRecord(e, n);
-						}), this.gastProductionsCache[e] = t;
-					});
-				} finally {
-					this.disableRecording();
-				}
-			});
-			let r = [];
-			if (this.TRACE_INIT("Grammar Resolving", () => {
-				r = function(e) {
-					let t = Object.assign({ errMsgProvider: Ge }, e), n = {};
-					return e.rules.forEach((e) => {
-						n[e.name] = e;
-					}), function(e, t) {
-						let n = new Ke(e, t);
-						return n.resolveRefs(), n.errors;
-					}(n, t.errMsgProvider);
-				}({ 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) {
-						return function(e, t, n, r) {
-							let i = e.flatMap((e) => function(e, t) {
-								let n = new _t();
-								e.accept(n);
-								let r = n.allProductions, i = Object.groupBy(r, ht), 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: Z.DUPLICATE_PRODUCTIONS,
-										ruleName: e.name,
-										dslName: a,
-										occurrence: r.idx
-									}, s = gt(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: Z.CONFLICT_TOKENS_RULES_NAMESPACE,
-											ruleName: t
-										});
-									}
-								}), r;
-							}(e, t, n), o = e.flatMap((e) => function(e, t) {
-								let n = new bt();
-								return e.accept(n), n.alternations.flatMap((n) => n.definition.length > 255 ? [{
-									message: t.buildTooManyAlternativesError({
-										topLevelRule: e,
-										alternation: n
-									}),
-									type: Z.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: Z.DUPLICATE_RULE_NAME,
-										ruleName: e.name
-									});
-								}
-								return i;
-							}(t, e, r, n));
-							return i.concat(a, o, s);
-						}(e.rules, e.tokenTypes, e.errMsgProvider ?? X, e.grammarName);
-					}({
-						rules: Object.values(this.gastProductionsCache),
-						tokenTypes: Object.values(this.tokensMap),
-						errMsgProvider: X,
-						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: Z.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), 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;
-	}
-};
-an.DEFER_DEFINITION_ERRORS_HANDLING = !1, nn = an, [
-	class {
-		initRecoverable(e) {
-			this.firstAfterRepMap = {}, this.resyncFollows = {}, this.recoveryEnabled = Object.hasOwn(e, "recoveryEnabled") ? e.recoveryEnabled : $.recoveryEnabled, this.recoveryEnabled && (this.attemptInRepetitionRecovery = Ft);
-		}
-		getTokenToInsert(e) {
-			let t = Ue(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 kt(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 Je(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 Pt("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) => H(t, e));
-				if (r !== void 0) return r;
-				t = this.LA(n), n++;
-			}
-		}
-		getCurrFollowKey() {
-			if (this.RULE_STACK_IDX === 0) return Nt;
-			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 ? Nt : {
-				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 === Nt) return [J];
-			let t = e.ruleName + e.idxInCallingRule + T + e.inRule;
-			return this.resyncFollows[t];
-		}
-		addToResyncTokens(e, t) {
-			return this.tokenMatcher(e, J) || 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 Vt({ 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) {
-						Ht.reset(), e.accept(Ht);
-						let t = Ht.dslMethods;
-						return Ht.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 = zt(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, It, "RepetitionMandatory", t.maxLookahead, x(t));
-					}), a.forEach((t) => {
-						this.computeLookaheadFunc(e, t.idx, Rt, "RepetitionMandatoryWithSeparator", t.maxLookahead, x(t));
-					}), o.forEach((t) => {
-						this.computeLookaheadFunc(e, t.idx, Lt, "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 = zt(this.fullRuleNameToShort[e.name], n, t);
-				this.setLaFuncCache(o, a);
-			});
-		}
-		getKeyForAutomaticLookahead(e, t) {
-			return zt(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 = Wt, this.setNodeLocationFromNode = Wt, 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 = Ut, this.setNodeLocationFromNode = Ut, 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 = function(e, t) {
-					let n = function() {};
-					return Gt(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: Bt.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;
-				}(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() {};
-					Gt(r, e + "BaseSemanticsWithDefaults");
-					let i = Object.create(n.prototype);
-					return t.forEach((e) => {
-						i[e] = Kt;
-					}), (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)) : Q;
-		}
-		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 ? Q : 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 = Te, 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(je)) {
-				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 = J;
-			let n = (Object.hasOwn(e, "modes") ? Object.values(e.modes).flat() : Object.values(e)).every((e) => e.categoryMatches?.length == 0);
-			this.tokenMatcher = n ? Te : H, W(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, i = Object.hasOwn(n, "resyncEnabled") ? n.resyncEnabled : rn.resyncEnabled, a = Object.hasOwn(n, "recoveryValueFunc") ? n.recoveryValueFunc : rn.recoveryValueFunc, o = this.ruleShortNameIdx << 12;
-			return this.ruleShortNameIdx++, this.shortRuleNameToFull[o] = e, this.fullRuleNameToShort[e] = o, r = !0 === this.outputCst ? function(...n) {
-				try {
-					this.ruleInvocationStateUpdate(o, 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, i, a);
-				} finally {
-					this.ruleFinallyStateUpdate();
-				}
-			} : function(...n) {
-				try {
-					return this.ruleInvocationStateUpdate(o, e, this.subruleIdx), t.apply(this, n);
-				} catch (e) {
-					return this.invokeRuleCatch(e, i, a);
-				} finally {
-					this.ruleFinallyStateUpdate();
-				}
-			}, Object.assign(function(...t) {
-				this.onBeforeParse(e);
-				try {
-					return r.apply(this, t);
-				} finally {
-					this.onAfterParse(e);
-				}
-			}, {
-				ruleName: e,
-				originalGrammarAction: t,
-				coreRule: r
-			});
-		}
-		invokeRuleCatch(e, t, n) {
-			let r = this.RULE_STACK_IDX === 0, i = t && !this.isBackTracking() && this.recoveryEnabled;
-			if (Dt(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(It, 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, It, e, Qe);
-		}
-		atLeastOneSepFirstInternal(e, t) {
-			let n = this.getKeyForAutomaticLookahead(Rt, 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,
-					$e
-				], t, Rt, e, $e);
-			}
-		}
-		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, Xe, a);
-		}
-		manySepFirstInternal(e, t) {
-			let n = this.getKeyForAutomaticLookahead(Lt, 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,
-					Ze
-				], t, Lt, e, Ze);
-			}
-		}
-		repetitionSepSecondInternal(e, t, n, r, i) {
-			for (; n();) this.CONSUME(t), r.call(this);
-			this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
-				e,
-				t,
-				n,
-				r,
-				i
-			], n, Rt, 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 Dt(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 kt(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), J);
-		}
-		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(Q);
-		}
-		onAfterParse(e) {
-			if (!1 === this.isAtEndOfInput()) {
-				let e = this.LA(1), t = this.errorMessageProvider.buildNotAllInputParsedMessage({
-					firstRedundant: e,
-					ruleName: this.getCurrRuleFullName()
-				});
-				this.SAVE_ERROR(new jt(t, e));
-			}
-			for (; this.tokVector.at(-1) === Q;) 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 = rn) {
-			if (this.definedRulesNames.includes(e)) {
-				let t = {
-					message: X.buildDuplicateRuleNameError({
-						topLevelRule: e,
-						grammarName: this.className
-					}),
-					type: Z.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 = rn) {
-			let r = function(e, t, n) {
-				let r, i = [];
-				return t.includes(e) || (r = `Invalid rule override, rule: ->${e}<- cannot be overridden in the grammar: ->${n}<-as it is not defined in any of the super grammars `, i.push({
-					message: r,
-					type: Z.INVALID_RULE_OVERRIDE,
-					ruleName: e
-				})), i;
-			}(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 (Dt(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 (Dt(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 = ft(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 Mt(o, this.LA(1), this.LA(0)));
-		}
-		raiseNoAltException(e, t) {
-			let n = this.getCurrRuleFullName(), r = dt(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 At(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 Q;
-		}
-		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 Qt.call(this, u, e, t);
-		}
-		atLeastOneInternalRecord(e, t) {
-			Qt.call(this, d, t, e);
-		}
-		atLeastOneSepFirstInternalRecord(e, t) {
-			Qt.call(this, f, t, e, Jt);
-		}
-		manyInternalRecord(e, t) {
-			Qt.call(this, p, t, e);
-		}
-		manySepFirstInternalRecord(e, t) {
-			Qt.call(this, m, t, e, Jt);
-		}
-		orInternalRecord(e, t) {
-			return $t.call(this, e, t);
-		}
-		subruleInternalRecord(e, t, n) {
-			if (tn(t), !e || !Object.hasOwn(e, "ruleName")) {
-				let n = Error(`<SUBRULE${en(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 ? Zt : qt;
-		}
-		consumeInternalRecord(e, t, n) {
-			if (tn(t), !ke(e)) {
-				let n = Error(`<CONSUME${en(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), Xt;
-		}
-	},
-	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(nn.prototype, n, r) : nn.prototype[n] = e.prototype[n];
-	});
-});
-var on = class extends an {
-	constructor(e, t = $) {
-		let n = Object.assign({}, t);
-		n.outputCst = !1, super(e, n);
-	}
-}, sn = class n {
-	static shared(e) {
-		let r = e?.locale ?? t, i = e?.maxColumn ?? dn, a = e?.maxRow ?? fn, o = un.get(r);
-		o || (o = /* @__PURE__ */ new Map(), un.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(e) {
-		let n = e?.maxColumn ?? dn, r = e?.maxRow ?? fn, i = e?.locale ?? t;
-		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 = q({
-			name: "WhiteSpace",
-			pattern: /\s+/,
-			group: K.SKIPPED
-		}), u = q({
-			name: "StringToken",
-			pattern: /"(""|[^"])*"/
-		}), d = q({
-			name: "FunctionToken",
-			pattern: /[a-zA-Z_\u007F-\uFFFF]+[a-zA-Z0-9_.\u007F-\uFFFF]*(?=\()/
-		}), f = q({
-			name: "TableReference",
-			pattern: { exec: gn },
-			line_breaks: !1,
-			start_chars_hint: ln
-		}), p = q({
-			name: "BracketedString",
-			pattern: { exec: vn },
-			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 = q({
-			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 = q({
-			name: "RefError",
-			pattern: RegExp(m(i.errorRefs) + "#REF!|#NAME\\?")
-		}), _ = q({
-			name: "SingleQuotedString",
-			pattern: /'(''|[^'])*'/
-		}), v = q({
-			name: "SheetQuoted",
-			pattern: /'(?:''|[^'])*?'!/
-		}), y = q({
-			name: "Sheet",
-			pattern: /[A-Za-z_.\d\u007F-\uFFFF]*!/
-		}), b = /[a-zA-Z_\\\u007F-\uFFFF][a-zA-Z0-9_.?\\\u007F-\uFFFF]*:?/y, x = q({
-			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: ln
-		}), S = q({
-			name: "Cell",
-			pattern: { exec: hn(n, r) },
-			line_breaks: !1,
-			start_chars_hint: [36, ...cn],
-			longer_alt: x
-		}), C = q({
-			name: "Column",
-			pattern: { exec: mn(n) },
-			line_breaks: !1,
-			start_chars_hint: [36, ...cn],
-			longer_alt: x
-		}), w = q({
-			name: "AbsRow",
-			pattern: /[$][0-9]+/
-		}), T = c === "." ? "\\." : c, E = q({
-			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 = q({
-			name: "ScientificDigit",
-			pattern: /[0-9]+\*\*[+-]?[0-9]+/
-		}), O = q({
-			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 = q({
-			name: "BooleanToken",
-			pattern: new RegExp(k.join("|"), "i")
-		}), j = q({
-			name: "ArgSeparator",
-			pattern: _n(a)
-		}), M = q({
-			name: "ColSeparator",
-			pattern: _n(o)
-		}), N = q({
-			name: "RowSeparator",
-			pattern: _n(s)
-		}), P = q({
-			name: "RangeOp",
-			pattern: /:/
-		}), F = q({
-			name: "RangeTrimFullOp",
-			pattern: /\.:\./
-		}), ee = q({
-			name: "RangeTrimLeadingOp",
-			pattern: /\.:/
-		}), I = q({
-			name: "RangeTrimTrailingOp",
-			pattern: /:\./
-		}), te = q({
-			name: "OpenParen",
-			pattern: /\(/
-		}), L = q({
-			name: "CloseParen",
-			pattern: /\)/
-		}), R = q({
-			name: "OpenCurlyParen",
-			pattern: /{/
-		}), ne = q({
-			name: "CloseCurlyParen",
-			pattern: /}/
-		}), z = q({
-			name: "QuoteS",
-			pattern: /'/
-		}), re = q({
-			name: "MulOp",
-			pattern: /\*(?!\*)/
-		}), ie = q({
-			name: "PlusOp",
-			pattern: /\+/
-		}), ae = q({
-			name: "DivOp",
-			pattern: /\//
-		}), oe = q({
-			name: "MinOp",
-			pattern: /-/
-		}), se = q({
-			name: "ImplicitIntersectOp",
-			pattern: /@/
-		}), ce = q({
-			name: "ConcatOp",
-			pattern: /&/
-		}), le = q({
-			name: "ExOp",
-			pattern: /\^/
-		}), ue = q({
-			name: "PercentOp",
-			pattern: /%/
-		}), de = q({
-			name: "ArrayAnchorOp",
-			pattern: /#/,
-			longer_alt: [h, g]
-		}), B = q({
-			name: "GtOp",
-			pattern: />/
-		}), fe = q({
-			name: "EqOp",
-			pattern: /=/
-		}), pe = q({
-			name: "LtOp",
-			pattern: /</
-		}), me = [
-			l,
-			u,
-			v,
-			_,
-			y,
-			d,
-			f,
-			p,
-			h,
-			g,
-			j,
-			...o === a ? [] : [M],
-			N,
-			F,
-			ee,
-			I,
-			P,
-			S,
-			A,
-			C,
-			w,
-			E,
-			D,
-			O,
-			de,
-			se,
-			x,
-			te,
-			L,
-			R,
-			ne,
-			z,
-			re,
-			ie,
-			ae,
-			oe,
-			ce,
-			le,
-			ue,
-			q({
-				name: "NeqOp",
-				pattern: /<>/
-			}),
-			q({
-				name: "GteOp",
-				pattern: />=/
-			}),
-			q({
-				name: "LteOp",
-				pattern: /<=/
-			}),
-			B,
-			fe,
-			pe
-		];
-		this._lexer = new K(me, { ensureOptimizations: !0 });
-		let he = {};
-		me.forEach((e) => {
-			he[e.name] = e;
-		}), o === a && (he.ColSeparator = j), this._vocabulary = he;
-	}
-	tokenize(t, n = !0) {
-		let r = this._lexer.tokenize(t);
-		if (n && r.errors.length > 0) {
-			let n = r.errors[0], i = n.line, a = n.column, o = t.substr(n.offset, n.length || 1), s = o ? `Unexpected character '${o}'` : n.message;
-			throw new e.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;
-	}
-}, cn = (() => {
-	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), ln = (() => {
-	let e = [
-		...cn,
-		95,
-		92
-	];
-	for (let t = 127; t <= 65535; t++) e.push(t);
-	return e;
-})(), un = /* @__PURE__ */ new WeakMap(), dn = 16384, fn = 1048576;
-function pn(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 mn(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 || pn(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 hn(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 || pn(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 gn(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 _n(e) {
-	return new RegExp(e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-}
-function vn(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 { J as a, on as i, K as n, We as o, sn as r, q as t };