@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.11

package/node/esm/CwePQwTILHHjGDkZ.mjs

@@ -0,0 +1,1033 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.8.0-beta.11
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { An as e, Bn as t, Dn as s, Fn as r, Gn as i, Hn as n, In as o, Jn as a, Kn as h, Ln as l, Nn as u, Pn as c, Rn as p, Tn as g, Un as m, Vn as O, Wn as _, Xn as E, Yn as L, Zn as f, dr as A, ir as C, jn as T, kn as N, nr as U, or as S, qn as d, rr as x, sr as R, zn as I } from "./OVfaSb506tNSIvbv.mjs";
+import { FormulaError as M } from "@sheetxl/primitives";
+import { EOF as P, EmbeddedActionsParser as b, Lexer as v, createToken as k, defaultParserErrorProvider as w } from "chevrotain";
+var y = class e {
+	static shared(t) {
+		const s = t?.locale ?? R, r = t?.maxColumn ?? D, i = t?.maxRow ?? G;
+		let n = $.get(s);
+		n || (n = /* @__PURE__ */ new Map(), $.set(s, n));
+		const o = `${r}:${i}`;
+		let a = n.get(o);
+		return a || (a = new e({
+			locale: s,
+			maxColumn: r,
+			maxRow: i
+		}), n.set(o, a)), a;
+	}
+	constructor(e) {
+		const t = e?.maxColumn ?? D, s = e?.maxRow ?? G, r = e?.locale ?? R;
+		this._locale = r, this._maxColumn = t, this._maxRow = s;
+		const { separatorFunction: i, separatorColumn: n, separatorRow: o, separatorDecimal: a } = r.separators;
+		if (n === o) throw new Error(`FormulaLexer: separatorColumn and separatorRow must differ (both '${n}')`);
+		const h = k({
+			name: "WhiteSpace",
+			pattern: /[ \n\v\f\r\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/,
+			group: v.SKIPPED
+		}), l = k({
+			name: "StringToken",
+			pattern: /"(""|[^"])*"/
+		}), u = k({
+			name: "FunctionToken",
+			pattern: /[a-zA-Z_\u007F-\uFFFF]+[a-zA-Z0-9_.\u007F-\uFFFF]*(?=\()/
+		}), c = k({
+			name: "TableReference",
+			pattern: { exec: x },
+			line_breaks: !1,
+			start_chars_hint: B
+		}), p = k({
+			name: "BracketedString",
+			pattern: { exec: U },
+			line_breaks: !1,
+			start_chars_hint: [91],
+			longer_alt: [c, l]
+		}), g = (e) => (e ?? []).map((e) => e?.trim()).filter(Boolean).map((e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).map((e) => e + "|").join(""), m = (e) => e.replace(/[A-Za-z]/g, (e) => `[${e.toUpperCase()}${e.toLowerCase()}]`), O = k({
+			name: "LiteralError",
+			pattern: new RegExp(g(r.errorLiterals) + [
+				"#PARSE!",
+				"#NULL!",
+				"#DIV\\/0!",
+				"#VALUE!",
+				"#NUM!",
+				"#FIELD!",
+				"#N\\/A",
+				"#GETTING_DATA",
+				"#SPILL!",
+				"#CONNECT!",
+				"#BLOCKED!",
+				"#UNKNOWN!",
+				"#CALC!",
+				"#BUSY!",
+				"#PYTHON!",
+				"#TIMEOUT!"
+			].map(m).join("|"))
+		}), _ = k({
+			name: "RefError",
+			pattern: new RegExp(g(r.errorRefs) + ["#REF!", "#NAME\\?"].map(m).join("|"))
+		}), E = k({
+			name: "SingleQuotedString",
+			pattern: /'(''|[^'])*'/
+		}), L = k({
+			name: "SheetQuoted",
+			pattern: /'(?:''|[^'])*?'!/
+		}), f = k({
+			name: "Sheet",
+			pattern: /[A-Za-z_.\d\u007F-\uFFFF]*!/
+		}), A = /[a-zA-Z_\\\u007F-\uFFFF][a-zA-Z0-9_.?\\\u007F-\uFFFF]*:?/y, C = k({
+			name: "NamedToken",
+			pattern: { exec: (e, t) => {
+				A.lastIndex = t;
+				const s = A.exec(e);
+				if (!s) return null;
+				let r = s[0];
+				const i = r.indexOf(".:");
+				return -1 !== i ? r = r.substring(0, i) : r.endsWith(":") && (r = r.slice(0, -1)), [r];
+			} },
+			line_breaks: !1,
+			start_chars_hint: B
+		}), T = k({
+			name: "Cell",
+			pattern: { exec: W(t, s) },
+			line_breaks: !1,
+			start_chars_hint: [36, ...F],
+			longer_alt: C
+		}), N = k({
+			name: "Column",
+			pattern: { exec: z(t) },
+			line_breaks: !1,
+			start_chars_hint: [36, ...F],
+			longer_alt: C
+		}), S = k({
+			name: "AbsRow",
+			pattern: /[$][0-9]+/
+		}), d = "." === a ? "\\." : a, I = k({
+			name: "NumberToken",
+			pattern: new RegExp(`[0-9]+${d}(?!:)[0-9]*([eE][+-]?[0-9]+|\\*\\*[+-]?[0-9]+)?|${d}[0-9]+([eE][+-]?[0-9]+|\\*\\*[+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+`)
+		}), M = k({
+			name: "ScientificDigit",
+			pattern: /[0-9]+\*\*[+-]?[0-9]+/
+		}), P = k({
+			name: "DigitToken",
+			pattern: /[0-9]+/
+		}), b = ["TRUE", "FALSE"];
+		for (const e of [r.booleanTrue, r.booleanFalse]) {
+			const t = e?.trim();
+			t && !b.some((e) => e.toLowerCase() === t.toLowerCase()) && b.push(t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+		}
+		const w = k({
+			name: "BooleanToken",
+			pattern: new RegExp(b.join("|"), "i")
+		}), y = k({
+			name: "ArgSeparator",
+			pattern: V(i)
+		}), $ = k({
+			name: "ColSeparator",
+			pattern: V(n)
+		}), Y = k({
+			name: "RowSeparator",
+			pattern: V(o)
+		}), j = k({
+			name: "RangeOp",
+			pattern: /:/
+		}), Z = k({
+			name: "RangeTrimFullOp",
+			pattern: /\.:\./
+		}), Q = k({
+			name: "RangeTrimLeadingOp",
+			pattern: /\.:/
+		}), q = k({
+			name: "RangeTrimTrailingOp",
+			pattern: /:\./
+		}), K = k({
+			name: "OpenParen",
+			pattern: /\(/
+		}), H = k({
+			name: "CloseParen",
+			pattern: /\)/
+		}), J = k({
+			name: "OpenCurlyParen",
+			pattern: /{/
+		}), X = k({
+			name: "CloseCurlyParen",
+			pattern: /}/
+		}), ee = k({
+			name: "QuoteS",
+			pattern: /'/
+		}), te = k({
+			name: "MulOp",
+			pattern: /\*(?!\*)/
+		}), se = k({
+			name: "PlusOp",
+			pattern: /\+/
+		}), re = k({
+			name: "DivOp",
+			pattern: /\//
+		}), ie = k({
+			name: "MinOp",
+			pattern: /-/
+		}), ne = k({
+			name: "ImplicitIntersectOp",
+			pattern: /@/
+		}), oe = k({
+			name: "ConcatOp",
+			pattern: /&/
+		}), ae = k({
+			name: "ExOp",
+			pattern: /\^/
+		}), he = k({
+			name: "PercentOp",
+			pattern: /%/
+		}), le = k({
+			name: "ArrayAnchorOp",
+			pattern: /#/,
+			longer_alt: [O, _]
+		}), ue = k({
+			name: "GtOp",
+			pattern: />/
+		}), ce = k({
+			name: "EqOp",
+			pattern: /=/
+		}), pe = k({
+			name: "LtOp",
+			pattern: /</
+		}), ge = [
+			h,
+			l,
+			L,
+			E,
+			f,
+			u,
+			c,
+			p,
+			O,
+			_,
+			y,
+			...n !== i ? [$] : [],
+			Y,
+			Z,
+			Q,
+			q,
+			j,
+			T,
+			w,
+			N,
+			S,
+			I,
+			M,
+			P,
+			le,
+			ne,
+			C,
+			K,
+			H,
+			J,
+			X,
+			ee,
+			te,
+			se,
+			re,
+			ie,
+			oe,
+			ae,
+			he,
+			k({
+				name: "NeqOp",
+				pattern: /<>/
+			}),
+			k({
+				name: "GteOp",
+				pattern: />=/
+			}),
+			k({
+				name: "LteOp",
+				pattern: /<=/
+			}),
+			ue,
+			ce,
+			pe
+		];
+		this._lexer = new v(ge, { ensureOptimizations: !0 });
+		const me = {};
+		ge.forEach((e) => {
+			me[e.name] = e;
+		}), n === i && (me.ColSeparator = y), this._vocabulary = me;
+	}
+	tokenize(e, t = !0) {
+		const s = this._lexer.tokenize(e);
+		if (t && s.errors.length > 0) {
+			const t = s.errors[0], r = t.line, i = t.column, n = e.substr(t.offset, t.length || 1), o = n ? `Unexpected character '${n}'` : t.message;
+			throw new M.Parse(o, {
+				line: r,
+				column: i,
+				offset: t.offset,
+				length: t.length
+			});
+		}
+		return s;
+	}
+	getVocabulary() {
+		return this._vocabulary;
+	}
+	getLocale() {
+		return this._locale;
+	}
+	getMaxColumn() {
+		return this._maxColumn;
+	}
+	getMaxRow() {
+		return this._maxRow;
+	}
+	getSeparators() {
+		return this._locale.separators;
+	}
+}, F = (() => {
+	const 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), B = (() => {
+	const e = [
+		...F,
+		95,
+		92
+	];
+	for (let t = 127; t <= 65535; t++) e.push(t);
+	return e;
+})(), $ = /* @__PURE__ */ new WeakMap(), D = 16384, G = 1048576;
+function Y(e, t, s) {
+	let r = 0;
+	for (let i = t; i < s; i++) {
+		const t = e.charCodeAt(i);
+		r = 26 * r + (t >= 97 ? t - 96 : t - 64);
+	}
+	return r;
+}
+function z(e) {
+	return (t, s) => {
+		let r = s;
+		36 === t.charCodeAt(r) && r++;
+		const i = r;
+		for (; r < t.length && r - i < 3;) {
+			const e = t.charCodeAt(r);
+			if (!(e >= 65 && e <= 90 || e >= 97 && e <= 122)) break;
+			r++;
+		}
+		if (r - i === 0) return null;
+		if (Y(t, i, r) > e) return null;
+		if (r < t.length) {
+			const e = t.charCodeAt(r);
+			if (e >= 48 && e <= 57) return null;
+		}
+		return [t.substring(s, r)];
+	};
+}
+function W(e, t) {
+	return (s, r) => {
+		let i = r;
+		36 === s.charCodeAt(i) && i++;
+		const n = i;
+		for (; i < s.length && i - n < 3;) {
+			const e = s.charCodeAt(i);
+			if (!(e >= 65 && e <= 90 || e >= 97 && e <= 122)) break;
+			i++;
+		}
+		if (i - n === 0) return null;
+		if (Y(s, n, i) > e) return null;
+		i < s.length && 36 === s.charCodeAt(i) && i++;
+		const o = i;
+		for (; i < s.length;) {
+			const e = s.charCodeAt(i);
+			if (!(e >= 48 && e <= 57)) break;
+			i++;
+		}
+		if (i === o) return null;
+		const a = parseInt(s.substring(o, i), 10);
+		return a < 1 || a > t ? null : [s.substring(r, i)];
+	};
+}
+function V(e) {
+	return new RegExp(e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+}
+var j = class {
+	constructor(e = R) {
+		const t = function(e) {
+			const t = [...g];
+			if (e) for (const s of Object.values(e)) {
+				const e = s?.trim();
+				e && !t.some((t) => t.toLowerCase() === e.toLowerCase()) && t.push(e);
+			}
+			return t.sort((e, t) => t.length - e.length), t.map((e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+		}(e.specifiers), s = k({
+			name: "WhiteSpace",
+			pattern: /\s+/,
+			group: v.SKIPPED
+		}), r = k({
+			name: "TableSpecifier",
+			pattern: new RegExp(`\\[#(?:${t})\\]`, "i")
+		}), i = [
+			s,
+			r,
+			k({
+				name: "BracketedColumn",
+				pattern: /\[(?:'['#[\]]|'(?!['#[\]])|[^'[\]])*\]/,
+				longer_alt: [r]
+			}),
+			k({
+				name: "BareSpecifier",
+				pattern: new RegExp(`#(?:${t})`, "i")
+			}),
+			k({
+				name: "ColumnSep",
+				pattern: /:/
+			}),
+			k({
+				name: "ListSep",
+				pattern: new RegExp(e.separators.separatorFunction.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+			})
+		];
+		this._lexer = new v(i, { ensureOptimizations: !0 });
+		const n = {};
+		i.forEach((e) => {
+			n[e.name] = e;
+		}), this._vocabulary = n;
+	}
+	getVocabulary() {
+		return this._vocabulary;
+	}
+	tokenize(e) {
+		return this._lexer.tokenize(e);
+	}
+}, Z = class extends b {
+	constructor(e = R) {
+		const t = new j(e), s = t.getVocabulary();
+		super(s, {
+			nodeLocationTracking: "none",
+			maxLookahead: 2,
+			skipValidations: !0,
+			recoveryEnabled: !1
+		}), this._lexer = t;
+		const { TableSpecifier: r, BracketedColumn: i, BareSpecifier: n, ColumnSep: o, ListSep: a } = s, h = this;
+		h.RULE("ruleContent", () => {
+			const e = [], t = h.SUBRULE(h.ruleItem);
+			return h.ACTION(() => {
+				t && e.push(t);
+			}), h.MANY(() => {
+				h.CONSUME(a), h.OPTION(() => {
+					const t = h.SUBRULE2(h.ruleItem);
+					h.ACTION(() => {
+						t && e.push(t);
+					});
+				});
+			}), e;
+		}), h.RULE("ruleItem", () => h.OR([{ ALT: () => h.SUBRULE(h.ruleSpecifier) }, { ALT: () => h.SUBRULE(h.ruleColumnOrRange) }])), h.RULE("ruleSpecifier", () => h.OR([{ ALT: () => {
+			const t = h.CONSUME(r);
+			return h.ACTION(() => {
+				const s = f(t.image, e);
+				return s.image = t.image, s;
+			});
+		} }, { ALT: () => {
+			const t = h.CONSUME(n);
+			return h.ACTION(() => {
+				const s = f(t.image, e);
+				return s.image = t.image, s;
+			});
+		} }])), h.RULE("ruleColumnOrRange", () => {
+			const e = h.CONSUME(i);
+			let t, s;
+			return h.OPTION(() => {
+				t = h.CONSUME(o), s = h.CONSUME2(i);
+			}), h.ACTION(() => {
+				const r = L(e.image);
+				if (r.image = e.image, !s) return r;
+				const i = L(s.image);
+				i.image = s.image;
+				const n = l(":", r, i, !0);
+				return n.image = t?.image ?? ":", n;
+			});
+		}), h.performSelfAnalysis();
+	}
+	_parseInner(e) {
+		const t = this._lexer.tokenize(e);
+		return t.errors.length > 0 || 0 === t.tokens.length ? [] : (this.input = t.tokens, this.reset(), this.ruleContent() ?? []);
+	}
+	_parseContent(e) {
+		if (!e) return [];
+		const t = e.trim();
+		if (!t) return [];
+		const s = t[0];
+		if ("@" === s) {
+			const e = t.slice(1).trim();
+			if (!e) {
+				const e = _("@", null, !0);
+				return e.image = "@", [e];
+			}
+			if ("[" === e.charAt(0)) {
+				const t = this._parseInner(e);
+				if (1 === t.length && "infix" === t[0].type) {
+					const e = _("@", t[0], !0);
+					return e.image = "@", [e];
+				}
+			}
+			const s = L(e);
+			s.image = e;
+			const r = _("@", s, !0);
+			return r.image = "@", [r];
+		}
+		if ("[" !== s && "#" !== s) {
+			const t = L(e);
+			return t.image = e, [t];
+		}
+		return this._parseInner(t);
+	}
+	parse(e, t, s) {
+		this.reset();
+		const r = () => ({
+			root: E("", []),
+			errors: []
+		});
+		if (!s) return r();
+		let i = 0;
+		if ("[" === s.charAt(0)) {
+			const e = s.indexOf("]");
+			-1 !== e && "!" === s.charAt(e + 1) && (i = e + 2);
+		}
+		const n = s.indexOf("[", i);
+		if (-1 === n) return r();
+		const o = s.slice(0, n), a = s.slice(n + 1, -1), h = this._parseContent(a);
+		return {
+			root: E(o, h),
+			errors: this.errors.length > 0 ? [...this.errors] : []
+		};
+	}
+}, Q = /* @__PURE__ */ new Set([
+	":",
+	".:.",
+	".:",
+	":."
+]), q = /* @__PURE__ */ new Set([
+	".:.",
+	".:",
+	":."
+]), K = (e) => {
+	if (!e) return null;
+	if (e.type === A.Cell) {
+		const t = e.value;
+		return t.rowIndex === Number.MIN_SAFE_INTEGER ? "col" : t.colIndex === Number.MIN_SAFE_INTEGER ? "row" : null;
+	}
+	return Number.isInteger(e.value) ? "row" : null;
+}, H = (e, t) => {
+	const s = parseInt(36 === e.charCodeAt(0) ? e.substring(1) : e, 10);
+	return s >= 1 && s <= t;
+}, J = "A formula must not be empty", X = (e, t) => `A formula must not be longer than ${t} characters (this one is ${e})`;
+function ee(e, t) {
+	const s = e?.[0]?.image;
+	if (!s) {
+		const e = t?.image;
+		return e ? `Expected a value after '${e}'` : "Expected a value";
+	}
+	return `Unexpected '${s}'`;
+}
+var te = {
+	...w,
+	buildNoViableAltMessage: (e) => ee(e.actual, e.previous),
+	buildEarlyExitMessage: (e) => ee(e.actual, e.previous),
+	buildNotAllInputParsedMessage: (e) => {
+		const t = e.firstRedundant?.image;
+		return t ? `Unexpected '${t}'` : w.buildNotAllInputParsedMessage(e);
+	},
+	buildMismatchTokenMessage: (e) => {
+		const t = e.actual?.image;
+		return e.expected === P && t ? `Unexpected '${t}'` : w.buildMismatchTokenMessage(e);
+	}
+}, se = class extends b {
+	constructor(g) {
+		const E = g?.lexer ?? y.shared(g?.lexerOptions), L = E.getVocabulary();
+		super(L, {
+			skipValidations: !0,
+			recoveryEnabled: !0,
+			...g,
+			nodeLocationTracking: "full",
+			errorMessageProvider: te,
+			maxLookahead: 1
+		}), this._ruleInfixOp = this.RULE("ruleInfixOp", () => {
+			const { PlusOp: e, MinOp: t, MulOp: r, DivOp: i, ExOp: n, ConcatOp: o, GtOp: a, EqOp: h, LtOp: u, NeqOp: c, GteOp: p, LteOp: g } = this._vocab, m = [];
+			return m.push({ node: this.SUBRULE(this._rulePostfixOp) }), this.MANY(() => {
+				const s = this.OR(this._c1 || (this._c1 = [
+					{ ALT: () => this.CONSUME(e).image },
+					{ ALT: () => this.CONSUME(t).image },
+					{ ALT: () => this.CONSUME(r).image },
+					{ ALT: () => this.CONSUME(i).image },
+					{ ALT: () => this.CONSUME(n).image },
+					{ ALT: () => this.CONSUME(o).image },
+					{ ALT: () => this.CONSUME(a).image },
+					{ ALT: () => this.CONSUME(h).image },
+					{ ALT: () => this.CONSUME(u).image },
+					{ ALT: () => this.CONSUME(c).image },
+					{ ALT: () => this.CONSUME(p).image },
+					{ ALT: () => this.CONSUME(g).image }
+				])), l = {
+					value: s,
+					index: this.getLexerPosition(),
+					isRange: C.includes(s)
+				}, O = this.SUBRULE2(this._rulePostfixOp);
+				m.push({
+					op: l,
+					node: O
+				});
+			}), this.ACTION(() => {
+				let e = m.length - 1;
+				const t = s.length;
+				for (let r = 0; e > 0 && r < t; r++) {
+					const t = s[r];
+					let i = 1;
+					for (; i < m.length;) {
+						const s = m[i].op;
+						if (t.includes(s.value)) {
+							const t = m[i - 1].node, r = m[i].node;
+							let n = l(s.value, t, r, s.isRange);
+							n = this._tag(n, s.index), m[i - 1].node = n, m.splice(i, 1), e--;
+						} else i++;
+					}
+				}
+			}), m[0].node;
+		}), this._rulePlusMinusOp = this.RULE("rulePlusMinusOp", () => {
+			const { PlusOp: e, MinOp: t } = this._vocab;
+			return this.OR([{ ALT: () => this.CONSUME(e) }, { ALT: () => this.CONSUME(t) }]);
+		}), this._rulePostfixOp = this.RULE("rulePostfixOp", () => {
+			const { PercentOp: e } = this._vocab;
+			let t = this.SUBRULE(this._rulePrefixOp);
+			const s = [];
+			return this.MANY(() => {
+				const t = this.CONSUME(e).image;
+				this.ACTION(() => {
+					s.push([t, this.getLexerPosition()]);
+				});
+			}), this.ACTION(() => {
+				const e = s.length;
+				if (0 !== e) for (let r = 0; r < e; r++) {
+					const e = s[r], i = e[0], n = e[1], o = C.includes(i);
+					t = m(i, t, o), t = this._tag(t, n);
+				}
+			}), t;
+		}), this._rulePrefixOp = this.RULE("rulePrefixOp", () => {
+			const { PlusOp: e, MinOp: t, ImplicitIntersectOp: s } = this._vocab, r = [];
+			this.MANY(() => {
+				const i = this.OR([
+					{ ALT: () => this.CONSUME(e).image },
+					{ ALT: () => this.CONSUME(t).image },
+					{ ALT: () => this.CONSUME(s).image }
+				]);
+				this.ACTION(() => {
+					r.push([i, this.getLexerPosition()]);
+				});
+			});
+			let i = this.SUBRULE(this._ruleRangeOp);
+			return this.ACTION(() => {
+				const e = r.length;
+				if (0 !== e) for (let t = e - 1; t >= 0; t--) {
+					const e = r[t], s = e[0], n = e[1], o = C.includes(s);
+					i = _(s, i, o), i = this._tag(i, n);
+				}
+			}), i;
+		}), this._ruleRangeOp = this.RULE("ruleRangeOp", () => {
+			const { RangeOp: e, RangeTrimFullOp: t, RangeTrimLeadingOp: s, RangeTrimTrailingOp: r, ArrayAnchorOp: i } = this._vocab, n = [];
+			return n.push({ node: this.SUBRULE(this._ruleCallOp) }), this.MANY2(() => {
+				this.CONSUME(i), n.push({ anchor: this.getLexerPosition() });
+			}), this.MANY(() => {
+				const o = {
+					value: this.OR(this._c2 || (this._c2 = [
+						{ ALT: () => this.CONSUME(e).image },
+						{ ALT: () => this.CONSUME(t).image },
+						{ ALT: () => this.CONSUME(s).image },
+						{ ALT: () => this.CONSUME(r).image }
+					])),
+					index: this.getLexerPosition()
+				}, a = this.SUBRULE2(this._ruleCallOp);
+				n.push({
+					op: o,
+					node: a
+				}), this.MANY3(() => {
+					this.CONSUME2(i), n.push({ anchor: this.getLexerPosition() });
+				});
+			}), this.ACTION(() => {
+				for (let e = 1; e < n.length; e++) {
+					const t = n[e];
+					if (void 0 !== t.anchor) {
+						n[0].node = this._tag(m("#", n[0].node, !0), t.anchor);
+						continue;
+					}
+					const s = t.op;
+					let r = l(s.value, n[0].node, t.node, !0);
+					r = this._tag(r, s.index), n[0].node = r;
+				}
+			}), n[0].node;
+		}), this._ruleCallOp = this.RULE("ruleCallOp", () => {
+			const { OpenParen: e, CloseParen: t } = this._vocab;
+			let s = this.SUBRULE(this._ruleFormula);
+			return this.MANY({
+				GATE: () => {
+					const t = this.LA(0), s = this.LA(1);
+					return !(!t || !s || s.tokenType !== e) && s.startOffset === t.endOffset + 1;
+				},
+				DEF: () => {
+					this.CONSUME(e);
+					const r = this.getLexerPosition(), i = this.SUBRULE(this._ruleFunctionArguments), n = s, o = this.ACTION(() => this._tag(T(n, i), r)), a = this.OPTION(() => this.CONSUME(t));
+					this.ACTION(() => {
+						a || this._reportError(o, "Missing closing parenthesis ')'", r), this._tagClose(o, this.getLexerPosition()), s = o;
+					});
+				}
+			}), s;
+		}), this._ruleIntersectOp = this.RULE("ruleIntersectOp", () => {
+			const e = [this.SUBRULE(this._ruleInfixOp)];
+			return this.MANY(() => {
+				this.OPTION({
+					GATE: () => {
+						const e = this.LA(0);
+						return this.LA(1).startOffset > e.endOffset + 1;
+					},
+					DEF: () => {
+						e.push(this.SUBRULE3(this._ruleInfixOp));
+					}
+				});
+			}), this.ACTION(() => {
+				for (; e.length > 1;) {
+					let t = e.length - 1;
+					for (let s = 0; s < t; s++) {
+						const r = e[s], i = e[s + 1], n = l(" ", r, i, !0), o = this._tokenMap.get(r);
+						o && delete o.tokenIndexClose;
+						const a = this._tokenMap.get(i), h = a?.tokenIndex;
+						if (void 0 !== h) {
+							const e = this.input[h], t = this.input[h - 1]?.endOffset ?? -1, s = this._inputText.slice(t + 1, e.startOffset).slice(0, -1);
+							s.length > 0 && (n.wsBefore = s);
+						}
+						a && delete a.tokenIndex, s + 1 < t && a && delete a.tokenIndexClose, e.splice(s, 2, n), s--, t--;
+					}
+				}
+			}), e[0];
+		}), this._ruleFormula = this.RULE("ruleFormula", () => this.OR9([
+			{ ALT: () => this.SUBRULE(this._ruleLiteral) },
+			{ ALT: () => this.SUBRULE(this._ruleReference) },
+			{ ALT: () => this.SUBRULE(this._ruleFunction) },
+			{ ALT: () => this.SUBRULE(this._ruleParen) },
+			{ ALT: () => this.SUBRULE(this._ruleTableReference) },
+			{ ALT: () => this.SUBRULE(this._ruleBracketedString) },
+			{ ALT: () => this.SUBRULE(this._ruleLiteralArray) }
+		])), this._ruleGroup = this.RULE("ruleGroup", () => {
+			const { ArgSeparator: e } = this._vocab, t = [];
+			return this.MANY(() => {
+				this.CONSUME(e);
+				const s = this.SUBRULE2(this._ruleIntersectOp);
+				this.ACTION(() => {
+					t.push(s);
+				});
+			}), t;
+		}), this._ruleParen = this.RULE("ruleParen", () => {
+			const { OpenParen: e, CloseParen: t } = this._vocab;
+			return this._processParen(A.Paren, e, t);
+		}), this._ruleLiteralArray = this.RULE("ruleLiteralArray", () => {
+			const { OpenCurlyParen: e, CloseCurlyParen: s, ColSeparator: r, RowSeparator: i } = this._vocab;
+			let n = t();
+			this.CONSUME(e);
+			const o = this.getLexerPosition();
+			let a = this.ACTION(() => this._tag(p(n), o));
+			const h = this.SUBRULE(this._ruleLiteralForArray);
+			this.ACTION(() => {
+				n.value.push(h);
+			}), this.MANY(() => {
+				let e = !1;
+				this.OR([{ ALT: () => {
+					this.CONSUME(r), e = !0;
+				} }, { ALT: () => this.CONSUME(i) }]);
+				const s = this.SUBRULE2(this._ruleLiteralForArray);
+				this.ACTION(() => {
+					e || (n = t(), a.value.push(n)), n.value.push(s);
+				});
+			});
+			const l = this.OPTION(() => this.CONSUME(s));
+			return a = this.ACTION(() => (l || this._reportError(a, "Missing closing parenthesis '}'", o), this._tagClose(a, this.getLexerPosition()))), a;
+		}), this._ruleLiteralForArray = this.RULE("ruleLiteralForArray", () => {
+			const { StringToken: t, BooleanToken: s, LiteralError: r, RefError: o } = this._vocab;
+			return this.OR([
+				{ ALT: () => {
+					const e = this.OPTION(() => this.SUBRULE(this._rulePlusMinusOp)), t = this.SUBRULE(this._ruleNumber), s = this.ACTION(() => this._tag(n(t.image, this._locale), this.getLexerPosition()));
+					return this.ACTION(() => e ? i(e.image, s) : s);
+				} },
+				{ ALT: () => {
+					const e = this.CONSUME(t);
+					return this.ACTION(() => this._tag(a(e.image), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const t = this.CONSUME(s);
+					return this.ACTION(() => this._tag(e(t.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const e = this.CONSUME(r);
+					return this.ACTION(() => this._tag(I(e.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const e = this.CONSUME(o);
+					return this.ACTION(() => this._tag(h(e.image, this._locale), this.getLexerPosition()));
+				} }
+			]);
+		}), this._ruleLiteral = this.RULE("ruleLiteral", () => {
+			const { StringToken: t, BooleanToken: s, LiteralError: r, RefError: i } = this._vocab;
+			return this.OR([
+				{ ALT: () => {
+					const e = this.SUBRULE(this._ruleNumber);
+					return this.ACTION(() => this._tag(n(e.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const e = this.CONSUME(t);
+					return this.ACTION(() => this._tag(a(e.image), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const t = this.CONSUME(s);
+					return this.ACTION(() => this._tag(e(t.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const e = this.CONSUME(r);
+					return this.ACTION(() => this._tag(I(e.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const e = this.CONSUME(i);
+					return this.ACTION(() => this._tag(h(e.image, this._locale), this.getLexerPosition()));
+				} }
+			]);
+		}), this._ruleFunction = this.RULE("ruleFunction", () => {
+			const { FunctionToken: e, OpenParen: t, CloseParen: s } = this._vocab, r = this.CONSUME(e).image, i = this.getLexerPosition();
+			this.CONSUME(t);
+			const n = this.SUBRULE(this._ruleFunctionArguments);
+			let a = this.ACTION(() => this._tag(o(r, n), i));
+			const h = this.OPTION(() => this.CONSUME(s));
+			return a = this.ACTION(() => (h || this._reportError(a, "Missing closing parenthesis ')'", i), this._tagClose(a, this.getLexerPosition()))), a;
+		}), this._ruleFunctionArguments = this.RULE("ruleFunctionArguments", () => {
+			const { ArgSeparator: e, CloseParen: t } = this._vocab, s = [];
+			return this.OPTION({
+				GATE: () => this.LA(1).tokenType !== t,
+				DEF: () => {
+					let t;
+					this.OPTION2(() => {
+						t = this.SUBRULE(this._ruleIntersectOp);
+					}), t = this.ACTION(() => t ?? this._tagClose(r(), this.getLexerPosition())), s.push(t), this.MANY(() => {
+						let t;
+						this.CONSUME(e), this.OPTION3(() => {
+							t = this.SUBRULE2(this._ruleIntersectOp);
+						}), t = this.ACTION(() => t ?? this._tagClose(r(), this.getLexerPosition())), s.push(t);
+					});
+				}
+			}), s;
+		}), this._ruleBracketedString = this.RULE("ruleBracketedString", () => {
+			const { BracketedString: e } = this._vocab, t = this.CONSUME(e), s = this.getLexerPosition();
+			return this.ACTION(() => {
+				const e = this._srParser.parse(this.rowIndex, this.colIndex, t.image);
+				for (const t of e.errors) this._astErrors.push(t);
+				return this._tag(e.root, s);
+			});
+		}), this._ruleTableReference = this.RULE("ruleTableReference", () => {
+			const { TableReference: e } = this._vocab, t = this.CONSUME(e), s = this.getLexerPosition();
+			return this.ACTION(() => {
+				const e = this._srParser.parse(this.rowIndex, this.colIndex, t.image);
+				for (const t of e.errors) this._astErrors.push(t);
+				return this._tag(e.root, s);
+			});
+		}), this._ruleReference = this.RULE("ruleReference", () => {
+			const { Sheet: e, SheetQuoted: t, DivOp: s, MulOp: r, PlusOp: i, MinOp: n, ArgSeparator: o, Cell: a, NamedToken: l, SingleQuotedString: p, Column: g, AbsRow: m, DigitToken: _, RefError: E } = this._vocab;
+			let L, f;
+			this.OPTION2({
+				GATE: () => {
+					for (let a = 1; a < 6; a++) {
+						const h = this.LA(a);
+						if (h.tokenType === e || h.tokenType === t) return !0;
+						if ("" === h.image || ")" === h.image || h.tokenType === s || h.tokenType === r || h.tokenType === i || h.tokenType === n || h.tokenType === o) break;
+					}
+					return !1;
+				},
+				DEF: () => {
+					f = this.getLexerPosition() + 1, L = this.SUBRULE(this._rulePrefixSheetName);
+				}
+			});
+			let C = this.OR([
+				{ ALT: () => {
+					const e = this.CONSUME(a), t = this.getLexerPosition();
+					return this.ACTION(() => this._tag(u(e.image, this.rowIndex, this.colIndex), t));
+				} },
+				{ ALT: () => {
+					const e = this.OR2([{ ALT: () => this.CONSUME(l) }, { ALT: () => this.CONSUME(p) }]);
+					return this.ACTION(() => this._tag(O(e.image), this.getLexerPosition()));
+				} },
+				{ ALT: () => this.SUBRULE(this._ruleBracketedString) },
+				{ ALT: () => this.SUBRULE(this._ruleFunction) },
+				{ ALT: () => {
+					const e = this.CONSUME(g);
+					return this.ACTION(() => this._tag(c(e.image, this.colIndex), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const e = this.CONSUME(m);
+					return this.ACTION(() => this._tag(d(e.image, this.rowIndex), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const e = this.CONSUME(_);
+					return this.ACTION(() => this._tag(d(e.image, this.rowIndex), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					const e = this.CONSUME(E);
+					return this.ACTION(() => this._tag(h(e.image, this._locale), this.getLexerPosition()));
+				} }
+			]);
+			return this.ACTION(() => {
+				if (L && C) {
+					if ("" === L.name) return void this._reportError(C, `'${L.image}' is not a valid sheet reference — a '!' needs a sheet name before it`);
+					let e = C;
+					if (C.type === A.Postfix && C.inputs?.[0] && (e = C.inputs[0]), e.type === A.Cell || e.type === A.Named || e.type === A.Row || e.type === A.TableColumn || e.type === A.Error) {
+						e.value.scope = L.name, e.value.scopeImage = L.image;
+						const t = this._tokenMap.get(e);
+						t && void 0 !== f && (t.tokenIndex = f);
+					}
+				}
+			}), C;
+		}), this._rulePrefixSheetName = this.RULE("rulePrefixSheetName", () => {
+			const { SheetQuoted: e, BracketedString: t, NamedToken: s, RangeOp: r, Sheet: i } = this._vocab;
+			return this.OR([{ ALT: () => {
+				const t = this.CONSUME(e).image;
+				return {
+					name: t.slice(1, -2).replace(/''/g, "'"),
+					image: t
+				};
+			} }, { ALT: () => {
+				let e = "";
+				this.OPTION(() => {
+					e += this.CONSUME(t).image;
+				}), this.OPTION2({
+					GATE: () => this.LA(2).tokenType === r,
+					DEF: () => {
+						e += this.CONSUME(s).image, this.CONSUME(r), e += ":";
+					}
+				});
+				const n = this.CONSUME(i).image;
+				return {
+					name: e + n.slice(0, -1),
+					image: e + n
+				};
+			} }]);
+		}), this._ruleNumber = this.RULE("ruleNumber", () => {
+			const { NumberToken: e, ScientificDigit: t, DigitToken: s } = this._vocab;
+			return this.OR([
+				{ ALT: () => this.CONSUME(e) },
+				{ ALT: () => this.CONSUME(t) },
+				{ ALT: () => this.CONSUME(s) }
+			]);
+		}), this._ruleRoot = this.RULE("ruleRoot", () => {
+			const { ArgSeparator: e } = this._vocab, t = this.SUBRULE(this._ruleIntersectOp), s = [];
+			return this.MANY(() => {
+				this.CONSUME(e), s.push(this.SUBRULE2(this._ruleIntersectOp));
+			}), this.ACTION(() => 0 === s.length ? t : {
+				type: A.List,
+				value: ",",
+				inputs: [t, ...s],
+				isReference: !0
+			});
+		}), this._lexer = E, this._locale = E.getLocale(), this._vocab = L, this._srParser = g?.srParser ?? new Z(this._locale), this.performSelfAnalysis();
+	}
+	getLexer() {
+		return this._lexer;
+	}
+	parse(e, t, s) {
+		const r = this._lexer.tokenize(s);
+		let i;
+		if (!r) return {
+			root: {
+				type: A.Unparsed,
+				value: s
+			},
+			errors: []
+		};
+		const n = r.tokens;
+		if (0 === n.length) throw new M.Parse(J);
+		return this.input = n, this._inputText = s, this._inputTextLength = s.length, this.rowIndex = e, this.colIndex = t, this._astErrors = [], this._tokenMap = /* @__PURE__ */ new Map(), this.reset(), i = this._ruleRoot(), i && this._bindAllWhitespace(i), i = S(i, (t, s) => {
+			const r = t.type, i = s?.isReference ? s.value : void 0, n = "string" == typeof i && Q.has(i), o = "string" == typeof i && q.has(i), a = n ? s.inputs : void 0, h = a ? a[0] === t ? a[1] : a[0] : void 0, l = this._lexer.getMaxRow();
+			if (n && r !== A.Cell && Number.isInteger(t.value)) {
+				const s = d(t.image, e);
+				return N(s, t), "row" !== K(h) ? this._reportError(s, `'${t.image}' is not a valid reference — a whole row can only pair with another row (as in ${t.image}:${t.image})`) : H(t.image, l) || this._reportError(s, `'${t.image}' is not a valid row — rows run from 1 to ${l}`), s;
+			}
+			if (o && r === A.Named) return this._reportError(t, `'${t.image ?? t.value?.nameId}' is a name — '${i}' needs a cell or range on both sides`), t;
+			if (r === A.Cell) {
+				const e = t.value, s = e.colIndex === Number.MIN_SAFE_INTEGER, r = e.rowIndex === Number.MIN_SAFE_INTEGER;
+				if ((s || r) && K(h) === (s ? "row" : "col")) return s && !H(t.image, l) && this._reportError(t, `'${t.image}' is not a valid row — rows run from 1 to ${l}`), t;
+				if (s || r || e.colIndex >= 16384) {
+					const n = O(t.image);
+					N(n, t);
+					const a = e.scope;
+					return a && (n.value.scope = a, n.value.scopeImage = e.scopeImage), s ? this._reportError(n, `'${t.image}' is not a valid reference — a row needs a column (use ${t.image}:${t.image} for the whole row)`) : r && t.image.includes("$") ? this._reportError(n, `'${t.image}' is not a valid reference — a whole column can only pair with another column (as in ${t.image}:${t.image})`) : o && this._reportError(n, `'${t.image}' is a name — '${i}' needs a cell or range on both sides`), n;
+				}
+			}
+			return t;
+		}), {
+			root: i,
+			errors: [...this.errors, ...this._astErrors]
+		};
+	}
+	_processParen(e, t, s) {
+		let r;
+		this.CONSUME(t);
+		const i = this.getLexerPosition();
+		r = this.ACTION(() => (r = {
+			type: e,
+			value: null,
+			inputs: null
+		}, this._tag(r, i)));
+		const n = [], o = this.SUBRULE(this._ruleIntersectOp);
+		o && n.push(o);
+		const a = this.SUBRULE(this._ruleGroup), h = this.OPTION(() => this.CONSUME(s));
+		return r = this.ACTION(() => {
+			if (a) for (let e = 0; e < a.length; e++) n.push(a[e]);
+			return r && (h || this._reportError(r, "Missing closing parenthesis", i), r.inputs = n), this._tagClose(r, this.getLexerPosition());
+		}), r;
+	}
+	_reportError(e, t, s = void 0, r = "SyntaxError") {
+		void 0 === s && (s = this.getLexerPosition()), e.error = !0, this._astErrors.push({
+			name: r,
+			message: t,
+			previousToken: this.input[s],
+			ast: e
+		});
+	}
+	_tag(e, t) {
+		return e ? (e.image ??= this.input[t].image, this._tokenMap.set(e, {
+			tokenIndex: t,
+			tokenIndexClose: t
+		}), e) : (console.warn("node is null"), e);
+	}
+	_tagClose(e, t) {
+		const s = this._tokenMap.get(e);
+		return s ? s.tokenIndexClose = t : this._tokenMap.set(e, { tokenIndexClose: t }), e;
+	}
+	_bindNodeWhitespace(e) {
+		const t = this._tokenMap.get(e);
+		if (!t) return;
+		const s = this.input, r = this._inputText, i = t.tokenIndex;
+		if (void 0 !== i) {
+			const t = s[i], n = s[i - 1]?.endOffset ?? -1;
+			n + 1 < t.startOffset && (e.wsBefore = r.slice(n + 1, t.startOffset));
+		}
+		const n = t.tokenIndexClose;
+		if (void 0 !== n) {
+			const t = s[n], i = s[n + 1]?.startOffset ?? this._inputTextLength;
+			t.endOffset + 1 < i && (e.wsAfter = r.slice(t.endOffset + 1, i));
+		}
+	}
+	_bindAllWhitespace(e) {
+		if (e) {
+			if (this._bindNodeWhitespace(e), e.inputs) for (const t of e.inputs) t && this._bindAllWhitespace(t);
+			if (e.type === A.Array && Array.isArray(e.value)) {
+				for (const t of e.value) if (t && Array.isArray(t.value)) for (const e of t.value) e && this._bindAllWhitespace(e);
+			}
+		}
+	}
+};
+export { y as i, X as n, se as r, J as t };