@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

package/browser/esm/Ba8ViNCurmu-pQzB.mjs

@@ -0,0 +1,818 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.7.23-beta.2
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { $ as e, A as t, B as n, C as r, D as i, E as a, F as o, G as s, H as c, I as l, J as u, K as d, L as f, M as p, N as m, O as h, P as g, Q as _, R as v, S as y, T as b, U as x, V as S, W as C, X as w, Y as T, Z as E, _ as D, b as O, et as k, g as ee, j as A, k as j, nt as M, q as N, tt as P, v as F, w as te, x as ne, y as I, z as L } from "./Cnay4yeRx2XxT4Yp.mjs";
+import { a as R, i as re, n as z, o as B, r as V, t as H } from "./DIqScru4YD2CC9q7.mjs";
+import { FormulaError as U } from "@sheetxl/primitives";
+import { CommonUtils as W } from "@sheetxl/utils";
+var G = [
+	"All",
+	"Data",
+	"Headers",
+	"Totals",
+	"This Row"
+], K = class {
+	constructor(e = P) {
+		let t = function(e) {
+			let t = [...G];
+			if (e) for (let n of Object.values(e)) {
+				let e = n?.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), n = R({
+			name: "WhiteSpace",
+			pattern: /\s+/,
+			group: B.SKIPPED
+		}), r = R({
+			name: "TableSpecifier",
+			pattern: RegExp(`\\[#(?:${t})\\]`, "i")
+		}), i = [
+			n,
+			r,
+			R({
+				name: "BracketedColumn",
+				pattern: /\[([^[\]]*)\]/,
+				longer_alt: [r]
+			}),
+			R({
+				name: "BareSpecifier",
+				pattern: RegExp(`#(?:${t})`, "i")
+			}),
+			R({
+				name: "ColumnSep",
+				pattern: /:/
+			}),
+			R({
+				name: "ListSep",
+				pattern: new RegExp(e.separators.separatorFunction.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+			})
+		];
+		this._lexer = new B(i, { ensureOptimizations: !0 });
+		let a = {};
+		i.forEach((e) => {
+			a[e.name] = e;
+		}), this._vocabulary = a;
+	}
+	getVocabulary() {
+		return this._vocabulary;
+	}
+	tokenize(e) {
+		return this._lexer.tokenize(e);
+	}
+}, q = class extends z {
+	constructor(e = P) {
+		let t = new K(e), n = t.getVocabulary();
+		super(n, {
+			nodeLocationTracking: "none",
+			maxLookahead: 2,
+			skipValidations: !0,
+			recoveryEnabled: !1
+		}), this._lexer = t;
+		let { TableSpecifier: r, BracketedColumn: i, BareSpecifier: a, ColumnSep: o, ListSep: s } = n, c = this;
+		c.RULE("ruleContent", () => {
+			let e = [], t = c.SUBRULE(c.ruleItem);
+			return c.ACTION(() => {
+				t && e.push(t);
+			}), c.MANY(() => {
+				c.CONSUME(s), c.OPTION(() => {
+					let t = c.SUBRULE2(c.ruleItem);
+					c.ACTION(() => {
+						t && e.push(t);
+					});
+				});
+			}), e;
+		}), c.RULE("ruleItem", () => c.OR([{ ALT: () => c.SUBRULE(c.ruleSpecifier) }, { ALT: () => c.SUBRULE(c.ruleColumnOrRange) }])), c.RULE("ruleSpecifier", () => c.OR([{ ALT: () => {
+			let t = c.CONSUME(r);
+			return c.ACTION(() => {
+				let n = E(t.image, e);
+				return n.image = t.image, n;
+			});
+		} }, { ALT: () => {
+			let t = c.CONSUME(a);
+			return c.ACTION(() => {
+				let n = E(t.image, e);
+				return n.image = t.image, n;
+			});
+		} }])), c.RULE("ruleColumnOrRange", () => {
+			let e = c.CONSUME(i), t, n;
+			return c.OPTION(() => {
+				t = c.CONSUME(o), n = c.CONSUME2(i);
+			}), c.ACTION(() => {
+				let r = T(e.image);
+				if (r.image = e.image, !n) return r;
+				let i = T(n.image);
+				i.image = n.image;
+				let a = f(":", r, i, !0);
+				return a.image = t?.image ?? ":", a;
+			});
+		}), c.performSelfAnalysis();
+	}
+	_parseInner(e) {
+		let t = this._lexer.tokenize(e);
+		return t.errors.length > 0 || t.tokens.length === 0 ? [] : (this.input = t.tokens, this.reset(), this.ruleContent() ?? []);
+	}
+	_parseContent(e) {
+		if (!e) return [];
+		let t = e.trim();
+		if (!t) return [];
+		let n = t[0];
+		if (n === "@") {
+			let e = t.slice(1).trim();
+			if (!e) {
+				let e = C("@", null, !0);
+				return e.image = "@", [e];
+			}
+			let n = T(e);
+			n.image = e;
+			let r = C("@", n, !0);
+			return r.image = "@", [r];
+		}
+		if (n !== "[" && n !== "#") {
+			let t = T(e);
+			return t.image = e, [t];
+		}
+		return this._parseInner(t);
+	}
+	parse(e, t, n) {
+		let r = () => ({
+			root: w("", []),
+			errors: []
+		});
+		if (!n) return r();
+		let i = n.indexOf("[");
+		if (i === -1) return r();
+		let a = n.slice(0, i), o = n.slice(i + 1, -1);
+		return {
+			root: w(a, this._parseContent(o)),
+			errors: this.errors.length > 0 ? [...this.errors] : []
+		};
+	}
+}, J = /* @__PURE__ */ new Set([
+	":",
+	".:.",
+	".:",
+	":."
+]), Y = /* @__PURE__ */ new Set([
+	".:.",
+	".:",
+	":."
+]), X = (e) => {
+	if (!e) return null;
+	if (e.type === k.Cell) {
+		let t = e.value;
+		return t.rowIndex === -(2 ** 53 - 1) ? "col" : t.colIndex === -(2 ** 53 - 1) ? "row" : null;
+	}
+	return Number.isInteger(e.value) ? "row" : null;
+}, Z = (e, t) => {
+	let n = parseInt(e.charCodeAt(0) === 36 ? e.substring(1) : e, 10);
+	return n >= 1 && n <= t;
+}, Q = "A formula must not be empty";
+function $(e, t) {
+	let n = e?.[0]?.image;
+	if (!n) {
+		let e = t?.image;
+		return e ? `Expected a value after '${e}'` : "Expected a value";
+	}
+	return `Unexpected '${n}'`;
+}
+var ie = {
+	...V,
+	buildNoViableAltMessage: (e) => $(e.actual, e.previous),
+	buildEarlyExitMessage: (e) => $(e.actual, e.previous),
+	buildNotAllInputParsedMessage: (e) => {
+		let t = e.firstRedundant?.image;
+		return t ? `Unexpected '${t}'` : V.buildNotAllInputParsedMessage(e);
+	},
+	buildMismatchTokenMessage: (e) => {
+		let t = e.actual?.image;
+		return e.expected === re && t ? `Unexpected '${t}'` : V.buildMismatchTokenMessage(e);
+	}
+}, ae = class extends z {
+	constructor(e) {
+		let t = e?.lexer ?? H.shared(e?.lexerOptions), r = t.getVocabulary();
+		super(r, {
+			skipValidations: !0,
+			recoveryEnabled: !0,
+			...e,
+			nodeLocationTracking: "full",
+			errorMessageProvider: ie,
+			maxLookahead: 1
+		}), this._ruleInfixOp = this.RULE("ruleInfixOp", () => {
+			let { PlusOp: e, MinOp: t, MulOp: n, DivOp: r, ExOp: i, ConcatOp: a, GtOp: o, EqOp: s, LtOp: c, NeqOp: l, GteOp: u, LteOp: d } = this._vocab, p = [];
+			return p.push({ node: this.SUBRULE(this._rulePostfixOp) }), this.MANY(() => {
+				let f = this.OR(this._c1 ||= [
+					{ ALT: () => this.CONSUME(e).image },
+					{ ALT: () => this.CONSUME(t).image },
+					{ ALT: () => this.CONSUME(n).image },
+					{ ALT: () => this.CONSUME(r).image },
+					{ ALT: () => this.CONSUME(i).image },
+					{ ALT: () => this.CONSUME(a).image },
+					{ ALT: () => this.CONSUME(o).image },
+					{ ALT: () => this.CONSUME(s).image },
+					{ ALT: () => this.CONSUME(c).image },
+					{ ALT: () => this.CONSUME(l).image },
+					{ ALT: () => this.CONSUME(u).image },
+					{ ALT: () => this.CONSUME(d).image }
+				]), m = {
+					value: f,
+					index: this.getLexerPosition(),
+					isRange: _.includes(f)
+				}, h = this.SUBRULE2(this._rulePostfixOp);
+				p.push({
+					op: m,
+					node: h
+				});
+			}), this.ACTION(() => {
+				let e = p.length - 1, t = j.length;
+				for (let n = 0; e > 0 && n < t; n++) {
+					let t = j[n], r = 1;
+					for (; r < p.length;) {
+						let n = p[r].op;
+						if (t.includes(n.value)) {
+							let t = p[r - 1].node, i = p[r].node, a = f(n.value, t, i, n.isRange);
+							a = this._tag(a, n.index), p[r - 1].node = a, p.splice(r, 1), e--;
+						} else r++;
+					}
+				}
+			}), p[0].node;
+		}), this._rulePlusMinusOp = this.RULE("rulePlusMinusOp", () => {
+			let { PlusOp: e, MinOp: t } = this._vocab;
+			return this.OR([{ ALT: () => this.CONSUME(e) }, { ALT: () => this.CONSUME(t) }]);
+		}), this._rulePostfixOp = this.RULE("rulePostfixOp", () => {
+			let { PercentOp: e, ArrayAnchorOp: t } = this._vocab, n = this.SUBRULE(this._rulePrefixOp), r = [];
+			return this.MANY(() => {
+				let n = this.OR([{ ALT: () => this.CONSUME(e).image }, { ALT: () => this.CONSUME(t).image }]);
+				this.ACTION(() => {
+					r.push([n, this.getLexerPosition()]);
+				});
+			}), this.ACTION(() => {
+				let e = r.length;
+				if (e !== 0) for (let t = 0; t < e; t++) {
+					let e = r[t], i = e[0], a = e[1], o = _.includes(i);
+					n = x(i, n, o), n = this._tag(n, a);
+				}
+			}), n;
+		}), this._rulePrefixOp = this.RULE("rulePrefixOp", () => {
+			let { PlusOp: e, MinOp: t, ImplicitIntersectOp: n } = this._vocab, r = [];
+			this.MANY(() => {
+				let i = this.OR([
+					{ ALT: () => this.CONSUME(e).image },
+					{ ALT: () => this.CONSUME(t).image },
+					{ ALT: () => this.CONSUME(n).image }
+				]);
+				this.ACTION(() => {
+					r.push([i, this.getLexerPosition()]);
+				});
+			});
+			let i = this.SUBRULE(this._ruleRangeOp);
+			return this.ACTION(() => {
+				let e = r.length;
+				if (e !== 0) for (let t = e - 1; t >= 0; t--) {
+					let e = r[t], n = e[0], a = e[1], o = _.includes(n);
+					i = C(n, i, o), i = this._tag(i, a);
+				}
+			}), i;
+		}), this._ruleRangeOp = this.RULE("ruleRangeOp", () => {
+			let { RangeOp: e, RangeTrimFullOp: t, RangeTrimLeadingOp: n, RangeTrimTrailingOp: r } = this._vocab, i = [];
+			return i.push({ node: this.SUBRULE(this._ruleCallOp) }), this.MANY(() => {
+				let a = {
+					value: this.OR(this._c2 ||= [
+						{ ALT: () => this.CONSUME(e).image },
+						{ ALT: () => this.CONSUME(t).image },
+						{ ALT: () => this.CONSUME(n).image },
+						{ ALT: () => this.CONSUME(r).image }
+					]),
+					index: this.getLexerPosition()
+				}, o = this.SUBRULE2(this._ruleCallOp);
+				i.push({
+					op: a,
+					node: o
+				});
+			}), this.ACTION(() => {
+				for (let e = 1; e < i.length; e++) {
+					let t = i[e].op, n = f(t.value, i[0].node, i[e].node, !0);
+					n = this._tag(n, t.index), i[0].node = n;
+				}
+			}), i[0].node;
+		}), this._ruleCallOp = this.RULE("ruleCallOp", () => {
+			let { OpenParen: e, CloseParen: t } = this._vocab, n = this.SUBRULE(this._ruleFormula);
+			return this.MANY({
+				GATE: () => {
+					let t = this.LA(0), n = this.LA(1);
+					return !(!t || !n || n.tokenType !== e) && n.startOffset === t.endOffset + 1;
+				},
+				DEF: () => {
+					this.CONSUME(e);
+					let r = this.getLexerPosition(), i = this.SUBRULE(this._ruleFunctionArguments), a = n, o = this.ACTION(() => this._tag(p(a, i), r)), s = this.OPTION(() => this.CONSUME(t));
+					this.ACTION(() => {
+						s || this._reportError(o, "Missing closing parenthesis ')'", r), this._tagClose(o, this.getLexerPosition()), n = o;
+					});
+				}
+			}), n;
+		}), this._ruleIntersectOp = this.RULE("ruleIntersectOp", () => {
+			let e = [this.SUBRULE(this._ruleInfixOp)];
+			return this.MANY(() => {
+				this.OPTION({
+					GATE: () => {
+						let 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 n = 0; n < t; n++) {
+						let r = e[n], i = e[n + 1], a = f(" ", r, i, !0), o = this._tokenMap.get(r);
+						o && delete o.tokenIndexClose;
+						let s = this._tokenMap.get(i), c = s?.tokenIndex;
+						if (c !== void 0) {
+							let e = this.input[c], t = this.input[c - 1]?.endOffset ?? -1, n = this._inputText.slice(t + 1, e.startOffset).slice(0, -1);
+							n.length > 0 && (a.wsBefore = n);
+						}
+						s && delete s.tokenIndex, n + 1 < t && s && delete s.tokenIndexClose, e.splice(n, 2, a), n--, 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", () => {
+			let { ArgSeparator: e } = this._vocab, t = [];
+			return this.MANY(() => {
+				this.CONSUME(e);
+				let n = this.SUBRULE2(this._ruleIntersectOp);
+				this.ACTION(() => {
+					t.push(n);
+				});
+			}), t;
+		}), this._ruleParen = this.RULE("ruleParen", () => {
+			let { OpenParen: e, CloseParen: t } = this._vocab;
+			return this._processParen(k.Paren, e, t);
+		}), this._ruleLiteralArray = this.RULE("ruleLiteralArray", () => {
+			let { OpenCurlyParen: e, CloseCurlyParen: t, ColSeparator: r, RowSeparator: i } = this._vocab, a = n();
+			this.CONSUME(e);
+			let o = this.getLexerPosition(), s = this.ACTION(() => this._tag(v(a), o)), c = this.SUBRULE(this._ruleLiteralForArray);
+			this.ACTION(() => {
+				a.value.push(c);
+			}), this.MANY(() => {
+				let e = !1;
+				this.OR([{ ALT: () => {
+					this.CONSUME(r), e = !0;
+				} }, { ALT: () => this.CONSUME(i) }]);
+				let t = this.SUBRULE2(this._ruleLiteralForArray);
+				this.ACTION(() => {
+					e || (a = n(), s.value.push(a)), a.value.push(t);
+				});
+			});
+			let l = this.OPTION(() => this.CONSUME(t));
+			return s = this.ACTION(() => (l || this._reportError(s, "Missing closing parenthesis '}'", o), this._tagClose(s, this.getLexerPosition()))), s;
+		}), this._ruleLiteralForArray = this.RULE("ruleLiteralForArray", () => {
+			let { StringToken: e, BooleanToken: t, LiteralError: n, RefError: r } = this._vocab;
+			return this.OR([
+				{ ALT: () => {
+					let e = this.OPTION(() => this.SUBRULE(this._rulePlusMinusOp)), t = this.SUBRULE(this._ruleNumber), n = this.ACTION(() => this._tag(c(t.image, this._locale), this.getLexerPosition()));
+					return this.ACTION(() => e ? s(e.image, n) : n);
+				} },
+				{ ALT: () => {
+					let t = this.CONSUME(e);
+					return this.ACTION(() => this._tag(u(t.image), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let e = this.CONSUME(t);
+					return this.ACTION(() => this._tag(A(e.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let e = this.CONSUME(n);
+					return this.ACTION(() => this._tag(L(e.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let e = this.CONSUME(r);
+					return this.ACTION(() => this._tag(d(e.image, this._locale), this.getLexerPosition()));
+				} }
+			]);
+		}), this._ruleLiteral = this.RULE("ruleLiteral", () => {
+			let { StringToken: e, BooleanToken: t, LiteralError: n, RefError: r } = this._vocab;
+			return this.OR([
+				{ ALT: () => {
+					let e = this.SUBRULE(this._ruleNumber);
+					return this.ACTION(() => this._tag(c(e.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let t = this.CONSUME(e);
+					return this.ACTION(() => this._tag(u(t.image), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let e = this.CONSUME(t);
+					return this.ACTION(() => this._tag(A(e.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let e = this.CONSUME(n);
+					return this.ACTION(() => this._tag(L(e.image, this._locale), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let e = this.CONSUME(r);
+					return this.ACTION(() => this._tag(d(e.image, this._locale), this.getLexerPosition()));
+				} }
+			]);
+		}), this._ruleFunction = this.RULE("ruleFunction", () => {
+			let { FunctionToken: e, OpenParen: t, CloseParen: n } = this._vocab, r = this.CONSUME(e).image, i = this.getLexerPosition();
+			this.CONSUME(t);
+			let a = this.SUBRULE(this._ruleFunctionArguments), o = this.ACTION(() => this._tag(l(r, a), i)), s = this.OPTION(() => this.CONSUME(n));
+			return o = this.ACTION(() => (s || this._reportError(o, "Missing closing parenthesis ')'", i), this._tagClose(o, this.getLexerPosition()))), o;
+		}), this._ruleFunctionArguments = this.RULE("ruleFunctionArguments", () => {
+			let { ArgSeparator: e, CloseParen: t } = this._vocab, n = [];
+			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(o(), this.getLexerPosition())), n.push(t), this.MANY(() => {
+						let t;
+						this.CONSUME(e), this.OPTION3(() => {
+							t = this.SUBRULE2(this._ruleIntersectOp);
+						}), t = this.ACTION(() => t ?? this._tagClose(o(), this.getLexerPosition())), n.push(t);
+					});
+				}
+			}), n;
+		}), this._ruleBracketedString = this.RULE("ruleBracketedString", () => {
+			let { BracketedString: e } = this._vocab, t = this.CONSUME(e), n = this.getLexerPosition();
+			return this.ACTION(() => {
+				let e = this._srParser.parse(this.rowIndex, this.colIndex, t.image);
+				for (let t of e.errors) this._astErrors.push(t);
+				return this._tag(e.root, n);
+			});
+		}), this._ruleTableReference = this.RULE("ruleTableReference", () => {
+			let { TableReference: e } = this._vocab, t = this.CONSUME(e), n = this.getLexerPosition();
+			return this.ACTION(() => {
+				let e = this._srParser.parse(this.rowIndex, this.colIndex, t.image);
+				for (let t of e.errors) this._astErrors.push(t);
+				return this._tag(e.root, n);
+			});
+		}), this._ruleReference = this.RULE("ruleReference", () => {
+			let { Sheet: e, SheetQuoted: t, DivOp: n, MulOp: r, PlusOp: i, MinOp: a, ArgSeparator: o, Cell: s, ArrayAnchorOp: c, NamedToken: l, SingleQuotedString: u, Column: f, AbsRow: p, DigitToken: h, RefError: _ } = this._vocab, v;
+			this.OPTION2({
+				GATE: () => {
+					for (let s = 1; s < 6; s++) {
+						let c = this.LA(s);
+						if (c.tokenType === e || c.tokenType === t) return !0;
+						if (c.image === "" || c.image === ")" || c.tokenType === n || c.tokenType === r || c.tokenType === i || c.tokenType === a || c.tokenType === o) break;
+					}
+					return !1;
+				},
+				DEF: () => {
+					v = this.SUBRULE(this._rulePrefixSheetName);
+				}
+			});
+			let y = this.OR([
+				{ ALT: () => {
+					let e = this.CONSUME(s), t = this.getLexerPosition(), n = this.OPTION(() => this.CONSUME(c));
+					return this.ACTION(() => {
+						let r = this._tag(m(e.image, this.rowIndex, this.colIndex), t);
+						return n ? this._tag(x("#", r, !0), t) : r;
+					});
+				} },
+				{ ALT: () => {
+					let e = this.OR2([{ ALT: () => this.CONSUME(l) }, { ALT: () => this.CONSUME(u) }]);
+					return this.ACTION(() => this._tag(S(e.image), this.getLexerPosition()));
+				} },
+				{ ALT: () => this.SUBRULE(this._ruleBracketedString) },
+				{ ALT: () => this.SUBRULE(this._ruleFunction) },
+				{ ALT: () => {
+					let e = this.CONSUME(f);
+					return this.ACTION(() => this._tag(g(e.image, this.colIndex), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let e = this.CONSUME(p);
+					return this.ACTION(() => this._tag(N(e.image, this.rowIndex), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let e = this.CONSUME(h);
+					return this.ACTION(() => this._tag(N(e.image, this.rowIndex), this.getLexerPosition()));
+				} },
+				{ ALT: () => {
+					let e = this.CONSUME(_);
+					return this.ACTION(() => this._tag(d(e.image, this._locale), this.getLexerPosition()));
+				} }
+			]);
+			return this.ACTION(() => {
+				if (v && y) {
+					if (v.name === "") return void this._reportError(y, `'${v.image}' is not a valid sheet reference — a '!' needs a sheet name before it`);
+					let e = y;
+					y.type === k.Postfix && y.inputs?.[0] && (e = y.inputs[0]), e.type !== k.Cell && e.type !== k.Named && e.type !== k.Row && e.type !== k.TableColumn && e.type !== k.Error || (e.value.scope = v.name, e.value.scopeImage = v.image);
+				}
+			}), y;
+		}), this._rulePrefixSheetName = this.RULE("rulePrefixSheetName", () => {
+			let { SheetQuoted: e, BracketedString: t, NamedToken: n, RangeOp: r, Sheet: i } = this._vocab;
+			return this.OR([{ ALT: () => {
+				let 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(n).image, this.CONSUME(r), e += ":";
+					}
+				});
+				let a = this.CONSUME(i).image;
+				return {
+					name: e + a.slice(0, -1),
+					image: e + a
+				};
+			} }]);
+		}), this._ruleNumber = this.RULE("ruleNumber", () => {
+			let { NumberToken: e, ScientificDigit: t, DigitToken: n } = this._vocab;
+			return this.OR([
+				{ ALT: () => this.CONSUME(e) },
+				{ ALT: () => this.CONSUME(t) },
+				{ ALT: () => this.CONSUME(n) }
+			]);
+		}), this._ruleRoot = this.RULE("ruleRoot", () => {
+			let { ArgSeparator: e } = this._vocab, t = this.SUBRULE(this._ruleIntersectOp), n = [];
+			return this.MANY(() => {
+				this.CONSUME(e), n.push(this.SUBRULE2(this._ruleIntersectOp));
+			}), this.ACTION(() => n.length === 0 ? t : {
+				type: k.List,
+				value: ",",
+				inputs: [t, ...n],
+				isReference: !0
+			});
+		}), this._lexer = t, this._locale = t.getLocale(), this._vocab = r, this._srParser = e?.srParser ?? new q(this._locale), this.performSelfAnalysis();
+	}
+	getLexer() {
+		return this._lexer;
+	}
+	parse(n, r, i, a) {
+		let o = this._lexer.tokenize(i), s;
+		if (!o) return {
+			root: {
+				type: k.Unparsed,
+				value: i
+			},
+			errors: []
+		};
+		let c = o.tokens;
+		if (c.length === 0) throw new U.Parse(Q);
+		return this.input = c, this._inputText = i, this._inputTextLength = i.length, this.rowIndex = n, this.colIndex = r, this._astErrors = [], this._tokenMap = /* @__PURE__ */ new Map(), this.reset(), s = this._ruleRoot(), s && this._bindAllWhitespace(s), s = e(s, (e, r) => {
+			let i = e.type, a = r?.isReference ? r.value : void 0, o = typeof a == "string" && J.has(a), s = typeof a == "string" && Y.has(a), c = o ? r.inputs : void 0, l = c ? c[0] === e ? c[1] : c[0] : void 0, u = this._lexer.getMaxRow();
+			if (o && i !== k.Cell && Number.isInteger(e.value)) {
+				let r = N(e.image, n);
+				return t(r, e), X(l) === "row" ? Z(e.image, u) || this._reportError(r, `'${e.image}' is not a valid row — rows run from 1 to ${u}`) : this._reportError(r, `'${e.image}' is not a valid reference — a whole row can only pair with another row (as in ${e.image}:${e.image})`), r;
+			}
+			if (s && i === k.Named) return this._reportError(e, `'${e.image ?? e.value?.nameId}' is a name — '${a}' needs a cell or range on both sides`), e;
+			if (i === k.Cell) {
+				let n = e.value, r = n.colIndex === -(2 ** 53 - 1), i = n.rowIndex === -(2 ** 53 - 1);
+				if ((r || i) && X(l) === (r ? "row" : "col")) return r && !Z(e.image, u) && this._reportError(e, `'${e.image}' is not a valid row — rows run from 1 to ${u}`), e;
+				if (r || i || n.colIndex >= 16384) {
+					let o = S(e.image);
+					t(o, e);
+					let c = n.scope;
+					return c && (o.value.scope = c, o.value.scopeImage = n.scopeImage), r ? this._reportError(o, `'${e.image}' is not a valid reference — a row needs a column (use ${e.image}:${e.image} for the whole row)`) : i && e.image.includes("$") ? this._reportError(o, `'${e.image}' is not a valid reference — a whole column can only pair with another column (as in ${e.image}:${e.image})`) : s && this._reportError(o, `'${e.image}' is a name — '${a}' needs a cell or range on both sides`), o;
+				}
+			}
+			return e;
+		}), a && s && (s = ee(s, a, null)), {
+			root: s,
+			errors: [...this.errors, ...this._astErrors]
+		};
+	}
+	_processParen(e, t, n) {
+		let r;
+		this.CONSUME(t);
+		let i = this.getLexerPosition();
+		r = this.ACTION(() => (r = {
+			type: e,
+			value: null,
+			inputs: null
+		}, this._tag(r, i)));
+		let a = [], o = this.SUBRULE(this._ruleIntersectOp);
+		o && a.push(o);
+		let s = this.SUBRULE(this._ruleGroup), c = this.OPTION(() => this.CONSUME(n));
+		return r = this.ACTION(() => {
+			if (s) for (let e = 0; e < s.length; e++) a.push(s[e]);
+			return r && (c || this._reportError(r, "Missing closing parenthesis", i), r.inputs = a), this._tagClose(r, this.getLexerPosition());
+		}), r;
+	}
+	_reportError(e, t, n = void 0, r = "SyntaxError") {
+		n === void 0 && (n = this.getLexerPosition()), e.error = !0, this._astErrors.push({
+			name: r,
+			message: t,
+			previousToken: this.input[n],
+			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) {
+		let n = this._tokenMap.get(e);
+		return n ? n.tokenIndexClose = t : this._tokenMap.set(e, { tokenIndexClose: t }), e;
+	}
+	_bindNodeWhitespace(e) {
+		let t = this._tokenMap.get(e);
+		if (!t) return;
+		let n = this.input, r = this._inputText, i = t.tokenIndex;
+		if (i !== void 0) {
+			let t = n[i], a = n[i - 1]?.endOffset ?? -1;
+			a + 1 < t.startOffset && (e.wsBefore = r.slice(a + 1, t.startOffset));
+		}
+		let a = t.tokenIndexClose;
+		if (a !== void 0) {
+			let t = n[a], i = n[a + 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 (let t of e.inputs) t && this._bindAllWhitespace(t);
+			if (e.type === k.Array && Array.isArray(e.value)) {
+				for (let t of e.value) if (t && Array.isArray(t.value)) for (let e of t.value) e && this._bindAllWhitespace(e);
+			}
+		}
+	}
+}, oe = class {
+	constructor(e) {
+		e = { ...e }, this._editing = e.profile === "editing", this._parser = new ae(e);
+	}
+	compile(e, t, n, o, s, c, l, u) {
+		if (o.length === 0) {
+			let t = new U.Parse(Q);
+			return this._compileUnparsed(e, s, o, {
+				input: o,
+				cause: t,
+				causes: [t]
+			});
+		}
+		if (o.length > M.MAX_EXPRESSION_LENGTH) {
+			let t = new U.Parse((d = o.length, `A formula must not be longer than ${M.MAX_EXPRESSION_LENGTH} characters (this one is ${d})`));
+			return this._compileUnparsed(e, s, o, {
+				input: o,
+				cause: t,
+				causes: [t]
+			});
+		}
+		var d;
+		let f, p, m = [];
+		try {
+			let e = this._parser.parse(t, n, o, u);
+			f = e.root, m = e.errors;
+		} catch (e) {
+			p = U.isError(e, U.Code.Parse) ? e : new U.Parse(e.message, e);
+		}
+		let g = [];
+		for (let e of m) g.push(b(e));
+		if (f) {
+			r(f, c ?? null) && g.push(new U.Parse("The implicit intersection operator ' ' requires a cell or range on both sides")), te(f, c ?? null) && g.push(new U.Parse("Expected a reference; a value cannot be converted to one."));
+			let e = I(f, c ?? null);
+			e && g.push(new U.Parse(e));
+			let t = O(f, c ?? null);
+			t && g.push(new U.Parse(t));
+			let n = ne(f, c ?? null);
+			n && g.push(new U.Parse(n));
+			let i = y(f);
+			i && g.push(new U.Parse(i));
+		}
+		g.length > 0 && !p && (p = g[0]);
+		let _ = null;
+		if (p && (_ = {
+			input: o,
+			cause: p,
+			causes: g.length > 0 ? g : [p]
+		}), !f) {
+			if (this._editing) {
+				let r = this._recoverCompiled(e, t, n, o, s, _, l);
+				if (r) return r;
+			}
+			return this._compileUnparsed(e, s, o, _);
+		}
+		f = i(f, c ?? null), f = D(f, c ?? null), s && (f = a(f, s, l));
+		let v = F(e, s, f, this._editing, _, c ?? null);
+		return this._editing && _ && h(v.getTokens(), s) !== o ? this._recoverCompiled(e, t, n, o, s, _, l) || this._compileUnparsed(e, s, o, _) : v;
+	}
+	autoCorrect(e) {
+		let t;
+		try {
+			let n = this._parser.getLexer().tokenize(e, !1);
+			if (n.errors.length > 0) return null;
+			t = n.tokens;
+		} catch {
+			return null;
+		}
+		let n = [];
+		for (let e of t) {
+			let t = e.tokenType?.name;
+			if (t === "OpenParen") n.push(")");
+			else if (t === "OpenCurlyParen") n.push("}");
+			else if ((t === "CloseParen" || t === "CloseCurlyParen") && n.pop() !== (t === "CloseParen" ? ")" : "}")) return null;
+		}
+		return n.length === 0 ? null : e + n.reverse().join("");
+	}
+	_compileUnparsed(e, t, n, r) {
+		let i = {
+			runtime: e,
+			symbols: t,
+			getFunction: null,
+			ast: null,
+			evaluations: W.EmptyArray,
+			executions: W.EmptyArray,
+			bindings: W.EmptyArray,
+			referencesAbsolute: W.EmptyArray,
+			referencesExecute: W.EmptyArray,
+			referencesRelative: W.EmptyArray,
+			referencesRoot: W.EmptyArray,
+			referenceIndices: W.EmptyArray,
+			getTokens: () => [{
+				type: k.Unparsed,
+				value: n,
+				text: n
+			}],
+			namedIds: W.EmptyArray,
+			symbolIds: W.EmptyArray,
+			hasTotals: !1,
+			isReferenceOnly: !1,
+			error: r,
+			transform: () => i
+		};
+		return i;
+	}
+	_recoverCompiled(e, t, n, r, i, o, s) {
+		let c, l = r.length;
+		try {
+			let e = this._parser.getLexer().tokenize(r, !1);
+			c = e.tokens, e.errors.length > 0 && (l = Math.min(l, e.errors[0].offset));
+		} catch {
+			return null;
+		}
+		let u = [];
+		for (let e = c.length - 1; e >= 0 && u.length < 24; e--) {
+			let t = (c[e].endOffset ?? -1) + 1;
+			t > 0 && t < r.length && t <= l && u.push(t);
+		}
+		for (let c of u) {
+			let l = r.slice(0, c), u, d;
+			try {
+				u = this._parser.parse(t, n, l).root;
+			} catch {
+				continue;
+			}
+			if (!u || u.type === k.Unparsed) continue;
+			try {
+				let t = D(u, null);
+				d = F(e, i, i ? a(t, i, s) : t, !0, o);
+			} catch {
+				continue;
+			}
+			if (h(d.getTokens(), i) !== l) continue;
+			let f = r.slice(c);
+			if (f.length === 0) return d;
+			let p, m = {
+				...d,
+				getTokens: () => (p || (p = [...d.getTokens()], this._appendUnparsedTail(p, f)), p),
+				transform: () => m
+			};
+			return m;
+		}
+		return null;
+	}
+	_appendUnparsedTail(e, t) {
+		let n = [];
+		for (let t of e) t.type === k.Paren && t.text === "(" ? n.push({
+			ctx: t.context,
+			argIndex: 0
+		}) : t.type === k.Paren && t.text === ")" ? n.pop() : t.type === k.Separator && n.length > 0 && n[n.length - 1].argIndex++;
+		let r = n.length > 0 ? n[n.length - 1] : void 0, i = r?.ctx ? {
+			...r.ctx,
+			argIndex: r.ctx.argIndex === -1 ? r.argIndex : r.ctx.argIndex
+		} : void 0, a = (t, n) => {
+			let r = {
+				type: k.Unparsed,
+				value: t,
+				text: t
+			};
+			i && (r.context = i), n && (r.isLookup = !0), e.push(r);
+		}, o = /[A-Za-z_][A-Za-z0-9_]*$/.exec(t), s = o ? o.index : -1;
+		s >= 0 && (s === 0 || !/[A-Za-z0-9_.]/.test(t[s - 1])) ? (s > 0 && a(t.slice(0, s)), a(t.slice(s), !0)) : a(t);
+	}
+};
+export { oe as FormulaCompiler };