@sheetxl/studio-vanilla 0.8.0-beta.10 → 0.8.0-beta.12

package/browser/esm/T-NlR9otpSbQQkLg.mjs

@@ -0,0 +1,1702 @@
+/**
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.12
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { G as e } from "./Cif0315haNLmyMj-.mjs";
+import { Jt as t } from "./Dac2pa3EUXg26xcV.mjs";
+import { a as n, c as r, i, n as a, r as o } from "./B8-nLKLPjZ7pIJdE.mjs";
+import { Bn as s, Dt as c, Fn as l, Gi as u, Hn as d, Ht as f, Jt as p, Kr as m, O as h, Q as g, Ri as _, Sn as v, Tt as y, Un as ee, Xn as b, Zt as x, _t as S, d as C, en as w, fi as T, ft as te, g as E, mi as D, nt as O, oi as k, pt as A, s as j, u as M, ur as ne, v as N, yr as re } from "./DmdChrGkm5oufbRE.mjs";
+var ie = (e, t) => e + t, ae = (e, t) => e - t, oe = (e, t) => O(e + t, e), se = (e, t) => O(e - t, e), ce = (e, t) => N(e * t), le = (e, t) => t === 0 ? n.BuiltIn.Div0 : N(e / t), ue = (e, t) => {
+	if (e === 0) {
+		if (t < 0) return n.BuiltIn.Div0;
+		if (t === 0) return NaN;
+	}
+	if (e < 0) {
+		if (Number.isInteger(t) && Math.abs(t) <= 4294967294) return N(e ** t);
+		let n = Number((1 / t).toPrecision(15));
+		return Number.isInteger(n) && Math.abs(n % 2) === 1 ? N(-((-e) ** t)) : NaN;
+	}
+	return N(e ** t);
+}, de = (e = "", t = "") => {
+	e === null && (e = ""), t === null && (t = "");
+	let n = typeof t;
+	typeof e == "boolean" && (e = g(e)), n === "boolean" && (t = g(t));
+	let r = "" + e + t;
+	return r.length > i.MAX_TEXT_LENGTH ? r.slice(0, i.MAX_TEXT_LENGTH) : r;
+}, fe = (e, t = null, n = null) => e.compare(t, n) === 0, pe = (e, t = null, n = null) => e.compare(t, n) !== 0, me = (e, t = null, n = null) => e.compare(t, n) > 0, he = (e, t = null, n = null) => e.compare(t, n) >= 0, ge = (e, t = null, n = null) => e.compare(t, n) < 0, _e = (e, t = null, n = null) => e.compare(t, n) <= 0, ve = {
+	type: a.Number,
+	coerce: [a.Boolean, a.String],
+	onError: "value",
+	misalignValue: n.BuiltIn.NA
+}, ye = {
+	type: a.String,
+	coerce: [a.Boolean, a.Number],
+	onError: "value",
+	misalignValue: n.BuiltIn.NA
+}, be = {
+	onError: "value",
+	misalignValue: n.BuiltIn.NA
+}, P = (e) => typeof e == "object" && e && !0 === e.isIReferenceRange && e.size === 1 ? e.getValueAt(0, 0) ?? null : e, F = (e, t, r, i) => {
+	if (t !== null && t.colStart !== void 0 && (t = e.getValueAt(t.rowStart, t.colStart, t.scope)) && n.isError(t)) return t;
+	if (r !== null && r.colStart !== void 0 && (r = e.getValueAt(r.rowStart, r.colStart, r.scope)) && n.isError(r)) return r;
+	if (t = P(t), r = P(r), typeof t == "number" && typeof r == "number") return i(t, r);
+	let o, s;
+	if (t?.isIRange ? o = t : r?.isIRange && (s = r), !o && !s) {
+		let o = e.getRuntime();
+		return t = _(o, t, k(t, !0), a.Number, !0), r = _(o, r, k(r, !0), a.Number, !0), t && n.isError(t) ? t : r && n.isError(r) ? r : i(t, r);
+	}
+	let c = !o, l = c ? t : r;
+	return (o ?? s).broadcast(l, (t, r) => t && n.isError(t) ? t : r && n.isError(r) ? r : A(c ? i(r, t) : i(t, r), e), ve).fillEmpty(0);
+}, I = (e, t, r, i) => {
+	if (E(t) || E(r) || o(t) || o(r)) return n.BuiltIn.Value;
+	if (t !== null && t.colStart !== void 0 && (t = e.getValueAt(t.rowStart, t.colStart, t.scope)) && n.isError(t)) return t;
+	if (r !== null && r.colStart !== void 0 && (r = e.getValueAt(r.rowStart, r.colStart, r.scope)) && n.isError(r)) return r;
+	let a, s;
+	t = P(t), r = P(r);
+	let c = !1;
+	return t?.isIRange ? (a = t, s = r) : r?.isIRange && (a = r, s = t, c = !0), a ? a.broadcast(s, (t, r) => t && n.isError(t) ? t : r && n.isError(r) ? r : (t = L(t), r = L(r), c ? i(e, r, t) : i(e, t, r)), be) : n.isError(t) ? t : n.isError(r) ? r : i(e, L(t), L(r));
+}, L = (e) => !0 === e?.isIRichData ? e.toPrimitive?.() ?? e : e, xe = (e, t, r) => {
+	if (r ??= 0, r !== null && r.colStart !== void 0 && (r = e.getValueAt(r.rowStart, r.colStart, r.scope)) && n.isError(r)) return r;
+	r = P(r);
+	let i, o = 1;
+	if (t === "+") return r;
+	if (t !== "-") throw new n.Value(`Unrecognized prefix: ${t}`);
+	if (o = -o, r?.isIRange && (i = r), !i) {
+		let t = e.getRuntime();
+		return typeof (r = _(t, r, k(r, !0), a.Number, !0)) == "number" ? r * o : n.BuiltIn.Value;
+	}
+	return i.broadcast(o, (e, t) => e && n.isError(e) ? e : t && n.isError(t) ? t : ce(e, t), ve);
+}, R = (e) => e.getCode() <= n.Code.NA ? e : n.BuiltIn.Value, z = (e, t, r, i, a) => {
+	if (n.isError(t)) return R(t);
+	if (r && n.isError(r)) return R(r);
+	if (!t) return n.BuiltIn.Ref;
+	if (t.isIReferenceRange && r && !r.isIReferenceRange ? r = e.getReference(r) : r && r.isIReferenceRange && t && !t.isIReferenceRange && (t = e.getReference(t)), t.isIReferenceRange && (t = t.getCoords()), t.colStart === void 0 || (r.isIReferenceRange && (r = r.getCoords()), r.colStart === void 0)) return n.BuiltIn.Value;
+	let o = t.scope ? a !== "either" || r.scope ? null : t : r;
+	if (o?.scope) {
+		let t = e.getReference(o);
+		if (n.isError(t)) return t;
+		if (e.getSheetIndex() !== e.getSheetIndex(t)) return n.BuiltIn.Value;
+	}
+	let s = i(t, r);
+	return n.isError(s) ? s : s ? e.getReference(s) : n.BuiltIn.Null;
+}, Se = {
+	"+": (e, t, n) => F(e, t, n, ie),
+	"-": (e, t, n) => F(e, t, n, ae),
+	"*": (e, t, n) => F(e, t, n, ce),
+	"/": (e, t, n) => F(e, t, n, le),
+	"^": (e, t, n) => F(e, t, n, ue),
+	" ": (e, t, n, r) => z(e, t, n, d, "either"),
+	":": (e, t, n, r) => z(e, t, n, D, "start"),
+	".:.": (e, t, n, r) => {
+		let i = z(e, t, n, D, "start");
+		return e.getFunction("TRIMRANGE").execute(i, 3, 3);
+	},
+	".:": (e, t, n, r) => {
+		let i = z(e, t, n, D, "start");
+		return e.getFunction("TRIMRANGE").execute(i, 1, 1);
+	},
+	":.": (e, t, n, r) => {
+		let i = z(e, t, n, D, "start");
+		return e.getFunction("TRIMRANGE").execute(i, 2, 2);
+	},
+	"&": (e, t, r) => ((e, t, r, i) => {
+		if (t !== null && t.colStart !== void 0 && (t = e.getValueAt(t.rowStart, t.colStart, t.scope)) && n.isError(t)) return t;
+		if (r !== null && r.colStart !== void 0 && (r = e.getValueAt(r.rowStart, r.colStart, r.scope)) && n.isError(r)) return r;
+		if (t = P(t), r = P(r), typeof t == "string" && typeof r == "string") return i(t, r);
+		let o, s;
+		if (t?.isIRange ? o = t : r?.isIRange && (s = r), !o && !s) {
+			let o = e.getRuntime();
+			return t = _(o, t, k(t, !0), a.String, !1), r = _(o, r, k(r, !0), a.String, !1), n.isError(t) ? t : n.isError(r) ? r : i(t, r);
+		}
+		let c = !o, l = c ? t : r;
+		return (o ?? s).broadcast(l, (e, t) => e && n.isError(e) ? e : t && n.isError(t) ? t : c ? i(t, e) : i(e, t), ye);
+	})(e, t, r, de),
+	"=": (e, t, n) => I(e, t, n, fe),
+	"<>": (e, t, n) => I(e, t, n, pe),
+	">": (e, t, n) => I(e, t, n, me),
+	"<": (e, t, n) => I(e, t, n, ge),
+	">=": (e, t, n) => I(e, t, n, he),
+	"<=": (e, t, n) => I(e, t, n, _e)
+}, Ce = {
+	"+": (e, t, n) => F(e, t, n, oe),
+	"-": (e, t, n) => F(e, t, n, se)
+}, we = {
+	"-": (e, t) => xe(e, "-", t),
+	"+": (e, t) => xe(e, "+", t),
+	"@": (e, t) => {
+		if (!t || !t.isIRange) return t;
+		let r = t;
+		if (!t.isIReferenceRange) return r.getValueAt(0, 0);
+		let i = t.getCoords(), a = r.getRowCount(), o = r.getColumnCount(), s = e.getRow() - i.rowStart, c = e.getColumn() - i.colStart, l = s >= 0 && s < a, u = c >= 0 && c < o;
+		return l && u ? r.getValueAt(s, c) : l && o === 1 ? r.getValueAt(s, 0) : u && a === 1 ? r.getValueAt(0, c) : a === 1 && o === 1 ? r.getValueAt(0, 0) : n.BuiltIn.Value;
+	}
+}, Te = {
+	"%": (e, t) => F(e, t, 100, le),
+	"#": (e, t) => n.isError(t) ? R(t) : t ? (t.isIReferenceRange && (t = t.getCoords()), t.colStart === void 0 ? n.BuiltIn.Value : t.rowStart !== t.rowEnd || t.colStart !== t.colEnd ? n.BuiltIn.Ref : e.getSpillAt(t.rowStart, t.colStart, t.scope) || n.BuiltIn.Ref) : n.BuiltIn.Ref
+};
+function B(e, t) {
+	for (let n = e.length - 1; n >= 0; n--) if (e[n].type === t) return e[n];
+}
+var Ee = class {
+	constructor() {
+		this.referenceIndices = [], this.rootReferences = /* @__PURE__ */ new Set(), this.cells = /* @__PURE__ */ new Map(), this.references = /* @__PURE__ */ new Map(), this.names = /* @__PURE__ */ new Map();
+	}
+	processNode(e, t) {
+		let n = e.type;
+		if (e.isReference) {
+			let t = {
+				node: e,
+				index: this.references.size,
+				op: null,
+				value: null,
+				inputs: null
+			};
+			if (this.references.set(e, t), n === y.Cell) {
+				let n = e.value;
+				n.$colIndex && (t.hasHorizontalAbs = !0), n.$rowIndex && (t.hasVerticalAbs = !0), t.value = this.cells.size, this.cells.set(e, this.cells.size), this.rootReferences.add(t), e.referenceIndex = this.referenceIndices.length, this.referenceIndices.push(t.index);
+				return;
+			}
+			if (n === y.Infix || n === y.Prefix || n === y.Postfix || n === y.List) {
+				let n = e.inputs || [], r = n.length, i = e.value;
+				t.op = i;
+				let a = M(r);
+				t.inputs = a;
+				for (let e = 0; e < r; e++) {
+					let r = n[e], i = this.references.get(r);
+					i ? (i.hasHorizontalAbs && (t.hasHorizontalAbs = !0), i.hasVerticalAbs && (t.hasVerticalAbs = !0), a[e] = i.index) : a[e] = -1, i && this.rootReferences.delete(i);
+				}
+				if (this.rootReferences.add(t), rt.includes(i)) {
+					let r = n[0], i = !!r && r.type === y.Cell, a = n[1], o = !!a && a.type === y.Cell;
+					i && o && a.referenceIndex !== void 0 && r.referenceIndex !== void 0 && (this.referenceIndices.splice(a.referenceIndex, 1), a.referenceIndex = r.referenceIndex, e.referenceIndex = r.referenceIndex, this.referenceIndices[r.referenceIndex] = t.index);
+				} else i === "#" && n[0] && (e.referenceIndex = n[0].referenceIndex);
+				return;
+			}
+			if (n === y.Error || n === y.Named) {
+				let r = n === y.Named ? e.value.nameId : c(e.value), i = this.names.get(r);
+				t.op = n, i === void 0 && (i = this.names.size, this.names.set(r, i)), t.value = i, this.rootReferences.add(t), e.referenceIndex = this.referenceIndices.length, this.referenceIndices.push(t.index);
+				return;
+			}
+			if (n === y.TableReference) return t.op = n, this.rootReferences.add(t), e.referenceIndex = this.referenceIndices.length, void this.referenceIndices.push(t.index);
+		} else if (t && t.isReference) {
+			let t = {
+				node: e,
+				index: this.references.size,
+				op: y.Function,
+				value: e.value,
+				inputs: null
+			};
+			this.references.set(e, t);
+		}
+	}
+};
+function V(e, t = !1, n = j) {
+	let r = [], i = /* @__PURE__ */ new Set(), a = (e, n, a) => {
+		let o = {
+			type: e.type,
+			value: e.type === y.Error ? u(e.value) : e.value
+		};
+		e.image !== void 0 && (o.text = ((e) => {
+			let n = t ? e.value?.scopeImage : void 0;
+			return typeof n == "string" ? n : "";
+		})(e) + e.image);
+		let s = e.evalIndex ?? a;
+		return s !== void 0 && (o.evalIndex = s), n && (o.context = n), e.referenceIndex !== void 0 && (o.referenceIndex = e.referenceIndex), e.isReference && i.add(o), r.push(o), o;
+	}, o = (e, t, n, i, a) => {
+		if (t == null || r.length > 1 && e === y.Whitespace && r[r.length - 1].type === y.Whitespace) return;
+		let o = {
+			type: e,
+			value: t,
+			text: a ?? t
+		};
+		i !== void 0 && (o.evalIndex = i), n && (o.context = n), r.push(o);
+	};
+	(function e(s, c, l) {
+		let u = s.evalIndex ?? l ?? 0, d = s.type, f = (t, r, i) => {
+			if (!t) return;
+			let a = t.length;
+			for (let s = 0; s < a; s++) e(t[s], r, i), s < a - 1 && o(y.Separator, ",", r, i, n.separatorFunction);
+		};
+		if (s.isLiteral) {
+			if (o(y.Whitespace, s.wsBefore, c, u), d === y.Array) {
+				o(y.Type, "{", c, u);
+				let t = s.value, r = t.length;
+				for (let i = 0; i < r; i++) {
+					let a = t[i], s = a.value, l = s.length;
+					for (let t = 0; t < l; t++) {
+						let r = s[t];
+						o(y.Whitespace, r.wsBefore, c, u), e(r, c, u), o(y.Whitespace, r.wsAfter, c, u), t < l - 1 && o(y.Separator, ",", c, u, n.separatorColumn);
+					}
+					i < r - 1 && (o(y.Whitespace, a.wsBefore, c, u), o(y.Separator, ";", c, u, n.separatorRow), o(y.Whitespace, a.wsAfter, c, u));
+				}
+				s.error || o(y.Type, "}", c, u);
+			} else d === y.String && (s = {
+				type: d,
+				value: "\"" + `${s.value}`.replace(/"/g, "\"\"") + "\"",
+				image: s.image
+			}), a(s, c, u);
+			o(y.Whitespace, s.wsAfter, c, u);
+		} else if (d === y.Infix) e(s.inputs[0], c, u), o(y.Whitespace, s.wsBefore, c, u), a(s, c, u), o(y.Whitespace, s.wsAfter, c, u), e(s.inputs[1], c, u);
+		else if (d === y.Prefix) o(y.Whitespace, s.wsBefore, c, u), a(s, c, u), o(y.Whitespace, s.wsAfter, c, u), s.inputs && e(s.inputs[0], c, u);
+		else if (d === y.Postfix) {
+			s.inputs?.[0] && e(s.inputs[0], c, u), o(y.Whitespace, s.wsBefore, c, u);
+			let t = a(s, c, u), n = r[r.length - 2];
+			s.value === "#" && t.text !== void 0 && !s.wsBefore && i.has(n) && (n.text = (n.text ?? "") + t.text, t.text = ""), o(y.Whitespace, s.wsAfter, c, u);
+		} else {
+			o(y.Whitespace, s.wsBefore, c, u);
+			let l = s.inputs;
+			switch (d) {
+				case y.Function: {
+					let t = String(s.value), i = {
+						type: y.Function,
+						value: t,
+						text: s.image ?? t,
+						evalIndex: s.evalIndex
+					};
+					c && (i.context = c), r.push(i);
+					let a = {
+						name: t,
+						argIndex: -1,
+						type: s.binder?.kind ?? "function"
+					};
+					if (c?.bound && (a.bound = c.bound), o(y.Paren, "(", a, s.evalIndex), l) {
+						let t = l.length, r = s.binder?.kind, i = r === "lambda" ? 1 : r === "let" ? 2 : 0, c = a.bound;
+						for (let s = 0; s < t; s++) {
+							let d = i && s >= i ? l[s - i] : void 0;
+							if (d?.binding?.declaration) {
+								let e = d.value.nameId, t = r === "let" ? St(l[s - 1]) : void 0;
+								c = Z(c, t ? {
+									name: e,
+									params: t
+								} : { name: e });
+							}
+							let f = {
+								...a,
+								argIndex: s
+							};
+							c && (f.bound = c), e(l[s], f, u), s < t - 1 && o(y.Separator, ",", f, u, n.separatorFunction);
+						}
+					}
+					s.error || o(y.Paren, ")", a, s.evalIndex);
+					break;
+				}
+				case y.Call: {
+					let t = b(s), i = r.length;
+					if (t && e(t, c, u), t?.type === y.Named) for (let e = i; e < r.length; e++) {
+						let t = r[e];
+						t.type !== y.Whitespace && (t.evalIndex = s.evalIndex, t.type === y.Named && (t.type = y.Function, t.value = t.value.name));
+					}
+					let a = {
+						name: t?.type === y.Named ? t.value.nameId : "",
+						argIndex: -1,
+						type: "function"
+					};
+					c?.bound && (a.bound = c.bound), o(y.Paren, "(", a, s.evalIndex);
+					let l = m(s), d = l.length;
+					for (let t = 0; t < d; t++) {
+						let r = {
+							...a,
+							argIndex: t
+						};
+						e(l[t], r, u), t < d - 1 && o(y.Separator, ",", r, u, n.separatorFunction);
+					}
+					s.error || o(y.Paren, ")", a, s.evalIndex);
+					break;
+				}
+				case y.Cell:
+					a(s, c, u);
+					break;
+				case y.Paren:
+					o(d, "(", c, u), f(l, c, u), s.error || o(d, ")", c, u);
+					break;
+				case y.TableReference: {
+					let n, a = s.value?.tableId ?? "", d = {
+						name: a,
+						argIndex: -1,
+						type: "table"
+					}, f = r.length, p = s.image, m = !1;
+					if (a && p) {
+						let e = 0;
+						if (p.charCodeAt(0) === 91) {
+							let t = p.indexOf("]");
+							t !== -1 && p.charCodeAt(t + 1) === 33 && (e = t + 2);
+						}
+						let r = p.indexOf("[", e);
+						if (m = r === 0 && l != null, r > 0) n = p.slice(0, r);
+						else if (!l) {
+							let e = p.lastIndexOf("!");
+							n = t || e === -1 ? p : p.slice(e + 1);
+						}
+					}
+					if (!a || m && t || o(y.TableReference, a, c, u, n), l && o(y.Paren, "[", d, u), l) {
+						let t = l.length;
+						for (let n = 0; n < t; n++) {
+							let r = {
+								...d,
+								argIndex: n
+							};
+							e(l[n], r, u), n < t - 1 && o(y.Separator, ",", r, u);
+						}
+					}
+					l && !s.error && o(y.Paren, "]", d, u);
+					let h = s.referenceIndex;
+					for (let e = f; e < r.length; e++) h !== void 0 && (r[e].referenceIndex = h), i.add(r[e]);
+					break;
+				}
+				case y.TableSpecifier:
+				case y.TableColumn: {
+					let e = s.image, t = e != null && e.startsWith("[") && e.endsWith("]");
+					t && o(y.Paren, "[", c, u);
+					let n = {
+						table: c?.type === "table" ? c.name : "",
+						name: s.value
+					}, i = {
+						type: d,
+						value: n,
+						text: t ? e.slice(1, -1) : e ?? n.name
+					};
+					u !== void 0 && (i.evalIndex = u), c && (i.context = c), r.push(i), t && o(y.Paren, "]", c, u);
+					break;
+				}
+				case y.List:
+					f(l, c, u);
+					break;
+				case y.Named: {
+					let e = a(s, c, u), t = s.value;
+					e.value = t.scope ? {
+						name: t.nameId,
+						scope: t.scope
+					} : { name: t.nameId }, s.binding?.declaration && s.binding.optional && (e.value.optional = !0), s.binding && (e.type = y.Parameter, s.binding.declaration && (e.value.declaration = !0)), delete e.referenceIndex;
+					break;
+				}
+				default: s.value !== void 0 && a(s, c, u), l && l.forEach((t) => e(t, c, u));
+			}
+			o(y.Whitespace, s.wsAfter, c, u);
+		}
+	})(e);
+	let s = /* @__PURE__ */ new Map();
+	for (let e of r) if (e.type === y.Cell && e.referenceIndex !== void 0) {
+		let t = s.get(e.referenceIndex);
+		t ? t.push(e) : s.set(e.referenceIndex, [e]);
+	}
+	for (let e of s.values()) e.length === 1 ? e[0].refSide = "self" : (e[0].refSide = "left", e[e.length - 1].refSide = "right");
+	let c = /* @__PURE__ */ new Map();
+	for (let e of r) if (e.referenceIndex !== void 0 && e.evalIndex !== void 0) {
+		let t = c.get(e.referenceIndex);
+		(t === void 0 || e.evalIndex < t) && c.set(e.referenceIndex, e.evalIndex);
+	}
+	if (c.size > 0) {
+		for (let e of r) if (e.referenceIndex !== void 0) {
+			let t = c.get(e.referenceIndex);
+			t !== void 0 && (e.evalIndex = t);
+		}
+	}
+	return r;
+}
+function De(e, t) {
+	let n = "";
+	for (let r = 0; r < e.length; r++) {
+		let i = e[r], a = i.type;
+		if (a === y.Cell || a === y.Named || a === y.Error) {
+			let e = a === y.Cell ? i.value?.scope : (y.Named, i.value?.scope ?? void 0), r = a === y.Error ? i.text !== void 0 && p(i.text) : i.text?.includes("!") ?? !1;
+			if (e && i.text !== void 0 && !r) {
+				let r = t?.resolve(x.Sheet, e)?.toString() ?? e;
+				n += ne(r) + "!" + i.text;
+				continue;
+			}
+			if (a === y.Named) {
+				n += i.text ?? i.value?.name ?? "";
+				continue;
+			}
+		}
+		if (a === y.Parameter) {
+			n += i.text ?? i.value?.name ?? "";
+			continue;
+		}
+		let o = i.text ?? i.value;
+		typeof o == "string" && (n += o);
+	}
+	return n;
+}
+function Oe(e, t) {
+	let n;
+	if (f(e, (e) => {
+		e.evalIndex === t && (n = e);
+	}), !n) return [];
+	let r = V(n);
+	return r.length > 1 && r[0].type === y.Whitespace && r.shift(), r.length > 1 && r[r.length - 1].type === y.Whitespace && r.pop(), r;
+}
+function ke(e) {
+	return f(e, (e) => {
+		if (e.type !== y.TableReference) return;
+		let t = function(e) {
+			if (e.value !== null && typeof e.value == "object") return e.value;
+			let t = e.value, n = e.inputs, r = !1, i = !1, a = !1, o = !1, s = null, c = null, l = !1, u = (e) => {
+				e?.type === y.TableColumn && (s = e.value, c = e.value);
+			};
+			if (n) for (let e of n) {
+				let t = e.type;
+				if (t === y.TableSpecifier) {
+					let t = e.value.toUpperCase().trim();
+					t === "#ALL" ? i = !0 : t === "#HEADERS" ? a = !0 : t === "#TOTALS" ? o = !0 : t === "#DATA" ? r = !0 : t !== "@" && t !== "#THIS ROW" || (l = !0);
+				} else if (t === y.TableColumn) u(e);
+				else if (t === y.Infix && e.value === ":") {
+					let t = e.inputs?.[0], n = e.inputs?.[1];
+					t?.type === y.TableColumn && (s = t.value), n?.type === y.TableColumn && (c = n.value);
+				} else if (t === y.Prefix && e.value === "@") {
+					l = !0;
+					let t = e.inputs?.[0];
+					t?.type === y.Infix && t.value === ":" ? (t.inputs?.[0]?.type === y.TableColumn && (s = t.inputs[0].value), t.inputs?.[1]?.type === y.TableColumn && (c = t.inputs[1].value)) : u(t);
+				}
+			}
+			return {
+				tableId: t,
+				spec: v(i, a, r, o),
+				columnFromId: s,
+				columnToId: c,
+				isThisRow: l
+			};
+		}(e);
+		return {
+			...e,
+			value: t
+		};
+	});
+}
+function Ae(e) {
+	return f(e, (e) => {
+		if (e.type !== y.TableReference) return;
+		let t = e.inputs;
+		if (!t || t.findIndex((e) => e.type === y.TableSpecifier && e.value.toUpperCase().trim() === "#THIS ROW") === -1) return;
+		let n, r = [];
+		for (let e of t) (e.type !== y.TableSpecifier || e.value.toUpperCase().trim() !== "#THIS ROW") && (e.type !== y.TableColumn && (e.type !== y.Infix || e.value !== ":") || n ? r.push(e) : n = e);
+		if (!n) return r.push({
+			type: y.Prefix,
+			value: "@",
+			inputs: null,
+			isReference: !0
+		}), {
+			...e,
+			inputs: r
+		};
+		let i = n.image ?? n.value, a = i.startsWith("[") && i.endsWith("]") ? {
+			...n,
+			image: i.slice(1, -1)
+		} : n;
+		return r.push(S("@", a, !0)), {
+			...e,
+			inputs: r
+		};
+	});
+}
+function je(e) {
+	return f(e, (e) => {
+		if (e.type !== y.TableReference || e.inputs?.length !== 0 || e.error) return;
+		let t = e.value;
+		return (typeof t == "string" ? t : t?.tableId) ? {
+			...e,
+			inputs: null
+		} : void 0;
+	});
+}
+function Me(e) {
+	return f(e, (e) => {
+		if (e.type !== y.TableReference || !e.inputs) return;
+		let t = e.value, n = typeof t == "string" ? t : t?.tableId, r = e.image;
+		if (!n || r?.charCodeAt(0) !== 91) return;
+		let i = r.indexOf("]");
+		if (i !== -1 && r.charCodeAt(i + 1) === 33) return;
+		let a = { ...e };
+		return delete a.image, a;
+	});
+}
+var Ne = (e) => {
+	if (e?.type !== y.TableSpecifier) return 4;
+	switch (e.value.toUpperCase().trim()) {
+		case "#ALL": return 0;
+		case "#HEADERS": return 1;
+		case "#DATA": return 2;
+		case "#TOTALS": return 3;
+		default: return 4;
+	}
+};
+function Pe(e) {
+	return f(e, (e) => {
+		if (e.type !== y.TableReference) return;
+		let t = e.inputs;
+		if (!t || t.length < 2) return;
+		let n = t.map((e, t) => ({
+			input: e,
+			index: t,
+			rank: Ne(e)
+		})).sort((e, t) => e.rank - t.rank || e.index - t.index).map((e) => e.input);
+		return n.every((e, n) => e === t[n]) ? void 0 : {
+			...e,
+			inputs: n
+		};
+	});
+}
+function Fe(t) {
+	if (!t) return e.EmptyArray;
+	let n = e.EmptyArray;
+	return f(t, (t) => {
+		if (t.type !== y.Named || t.binding) return;
+		let r = t.value.nameId;
+		r && (n === e.EmptyArray && (n = []), n.includes(r) || n.push(r));
+	}), n;
+}
+function Ie(t, n) {
+	if (!t) return e.EmptyArray;
+	let r = e.EmptyArray;
+	return f(t, (t, i, a) => {
+		if (!t.isReference || i?.isReference) return;
+		let o = t.type;
+		if (o === y.Named || o === y.Error || o === y.TableReference || B(a, y.TableReference)) return;
+		let s = function(e) {
+			let t = e;
+			for (; t;) {
+				if (t.referenceIndex !== void 0) return t.referenceIndex;
+				if (!t.isReference) return;
+				t = t.inputs?.[0];
+			}
+		}(t);
+		s !== void 0 && function(e, t, n) {
+			let r = e;
+			for (let e = t.length - 1; e >= 0; e--) {
+				let i = t[e];
+				if (i.type === y.Paren || i.isReference) {
+					r = i;
+					continue;
+				}
+				if (i.type !== y.Function) return !0;
+				let a = n?.(String(i.value));
+				if (!a) return !0;
+				let o = i.inputs ? i.inputs.indexOf(r) : -1;
+				return (o >= 0 ? H(a.getDeclaration().getParameters(), o) : null)?.getRangeType() !== "p";
+			}
+			return !0;
+		}(t, a, n) && (r === e.EmptyArray && (r = []), r.includes(s) || r.push(s));
+	}), r.length > 1 && r.sort((e, t) => e - t), r;
+}
+var Le = /* @__PURE__ */ new Set(["SUBTOTAL", "AGGREGATE"]);
+function Re(e, t) {
+	if (!e || !t) return !1;
+	let n = !1;
+	return f(e, (e) => {
+		if (n || e.type !== y.Function) return;
+		let r = t(e.value)?.getName();
+		r && Le.has(r.toUpperCase()) && (n = !0);
+	}), n;
+}
+function ze(e, t) {
+	if (!e || !t) return !1;
+	let n = !1;
+	return f(e, (e) => {
+		n || e.type !== y.Function || t(e.value)?.getName().toUpperCase() === "TABLE" && (n = !0);
+	}), n;
+}
+function Be(e, t) {
+	if (!e || !t) return !1;
+	let n = !1;
+	return f(e, (e) => {
+		n || e.type !== y.Function || !0 === t(e.value)?.getDeclaration().getReturnType()?.isVolatile() && (n = !0);
+	}), n;
+}
+var Ve = Object.freeze({
+	value: !1,
+	array: !1
+}), He = (e, t) => {
+	let n = function(e, t) {
+		if (!e || !t) return Ve;
+		let n = !1, r = !1;
+		return f(e, (e) => {
+			if (n) return;
+			let i = e.type;
+			if (i === y.Named) return void (e.binding === void 0 && (n = !0));
+			if (i === y.Prefix) return void (e.value === "@" && (n = !0));
+			if (i === y.Call) return void (n = !0);
+			if (i !== y.Function || e.binder !== void 0) return;
+			let a = t(e.value);
+			if (!a) return void (n = !0);
+			if (r || !0 !== e.implicitIntersect) return;
+			let o = a.getDeclaration().getParameters(), s = e.inputs;
+			if (s) for (let e = 0; e < s.length; e++) {
+				let n = H(o, e);
+				if (n !== null && n.isValueOrRange() && W(s[e], t)) return void (r = !0);
+			}
+		}), {
+			value: !n && !r,
+			array: !n
+		};
+	}(e, t);
+	return {
+		isBlankCacheable: n.value,
+		isBlankCacheableArray: n.array
+	};
+}, Ue = (e, t) => {
+	let n = e.length;
+	if (n === 0) return null;
+	if (t < n - 1) return e[t];
+	let r = e[n - 1], i = r.getRepeatingTypes();
+	return i && i.length !== 0 ? i[(t - (n - 1)) % i.length] : t < n ? e[t] : r.isRest() ? r : null;
+};
+function We(t) {
+	if (!t) return e.EmptyArray;
+	let n = e.EmptyArray, r = (t) => {
+		t && (n === e.EmptyArray && (n = []), n.includes(t) || n.push(t));
+	}, i = (e) => {
+		typeof e == "string" && r(T(e)?.bookId);
+	};
+	return f(t, (e) => {
+		if (e.type === y.Named) {
+			if (e.binding) return;
+			let t = e.value;
+			r(t.nameId), i(t.scope);
+		} else if (e.type === y.TableReference) {
+			let t = e.value;
+			r(typeof t == "string" ? t : t?.tableId);
+		} else if (e.type === y.Cell) {
+			let t = e.value?.scope;
+			i(t), l(t) && r(t);
+		} else e.type === y.Error && i(e.value?.scope);
+	}), n;
+}
+var Ge = (e, t) => {
+	if (!0 === e.lazyArg) return !0;
+	if (t?.binder?.kind !== "lambda") return !1;
+	let n = t.inputs;
+	return n[n.length - 1] === e;
+}, Ke = /* @__PURE__ */ new Set([
+	"IF",
+	"IFS",
+	"SWITCH",
+	"CHOOSE",
+	"IFERROR",
+	"IFNA"
+]), H = (e, t) => {
+	let n = e.length;
+	if (n === 0) return null;
+	if (t < n) return e[t];
+	let r = e[n - 1];
+	if (!r.isRest()) return null;
+	let i = r.getRepeatingTypes();
+	return i && i.length !== 0 ? i[(t - (n - 1)) % i.length] : r;
+}, qe = (e) => e.getScalarType() !== null && e.getRangeType() === null && e.getLambda() === null && !e.isValueOrRange(), Je = (e, t, n) => !(e.isRest() || !qe(e) || !W(t, n) || e.isNoLift() && U(t, n)), U = (e, t) => {
+	if (!e) return !1;
+	let n = e.inputs;
+	switch (e.type) {
+		case y.Cell:
+		case y.Named:
+		case y.TableReference: return !0;
+		case y.Infix:
+		case y.Prefix:
+		case y.Postfix: return !0 === e.isReference && e.value !== "@";
+		case y.Paren:
+		case y.List: return !!n && n.length === 1 && U(n[0], t);
+		case y.Function: {
+			if (e.binder !== void 0) return !1;
+			let i = String(e.value).toUpperCase();
+			if (Ke.has(i)) {
+				if (!n) return !1;
+				for (let e = 0; e < n.length; e++) if (U(n[e], t)) return !0;
+				return !1;
+			}
+			let a = t?.(e.value);
+			return !!a && a.getDeclaration().getReturnType().getKind() === r.Reference;
+		}
+		default: return !1;
+	}
+}, Ye = (e, t) => {
+	if (!e) return !1;
+	for (let n = 0; n < e.length; n++) if (W(e[n], t)) return !0;
+	return !1;
+};
+function W(e, t) {
+	if (!e) return !1;
+	if (e.arrayValued !== void 0) return e.arrayValued;
+	let n, i = e.type, a = e.inputs;
+	switch (i) {
+		case y.Array:
+			n = !0;
+			break;
+		case y.Cell: {
+			let t = e.value;
+			n = t.rowIndex === -(2 ** 53 - 1) || t.colIndex === -(2 ** 53 - 1);
+			break;
+		}
+		case y.Named:
+		case y.Call:
+		case y.TableReference:
+			n = !0;
+			break;
+		case y.Infix:
+		case y.Prefix:
+		case y.Postfix:
+			n = e.isReference ? e.value !== "@" : Ye(a, t);
+			break;
+		case y.Paren:
+		case y.List:
+			n = !a || a.length !== 1 || W(a[0], t);
+			break;
+		case y.Function: {
+			let i = e.binder;
+			if (i !== void 0) {
+				n = i.kind === "lambda" || !!a && W(a[a.length - 1], t);
+				break;
+			}
+			let o = String(e.value).toUpperCase();
+			if (Ke.has(o)) {
+				n = Ye(a, t);
+				break;
+			}
+			if (o === "INDEX") {
+				if (n = !1, a) for (let e = 1; e < a.length; e++) {
+					let r = a[e];
+					if (!r || r.type === y.Empty || r.isLiteral && r.value === 0 || W(r, t)) {
+						n = !0;
+						break;
+					}
+				}
+				break;
+			}
+			let s = t?.(e.value);
+			if (!s) {
+				n = !0;
+				break;
+			}
+			let c = s.getDeclaration().getReturnType(), l = c.getKind();
+			n = l === r.Array || l === r.Reference || l === null && c.getRangeType() !== null;
+			break;
+		}
+		default: n = !1;
+	}
+	return e.arrayValued = n, n;
+}
+function Xe(e, t) {
+	if (e.firstCell !== void 0) return;
+	let n = (e, r) => {
+		if (!e) return;
+		e.firstCell = r;
+		let i = e.inputs;
+		if (!i) return;
+		let a = e.type;
+		if (a === y.Infix || a === y.Prefix || a === y.Postfix) {
+			let t = r && !e.isReference;
+			for (let e = 0; e < i.length; e++) n(i[e], t);
+		} else if (a === y.Paren || a === y.List) {
+			let e = r && i.length === 1;
+			for (let t = 0; t < i.length; t++) n(i[t], e);
+		} else if (a === y.Function) {
+			let a = e.binder;
+			if (a !== void 0) {
+				let e = i.length - 1;
+				for (let t = 0; t < i.length; t++) n(i[t], r && a.kind === "let" && t === e);
+				return;
+			}
+			let o = r ? t?.(e.value)?.getDeclaration().getParameters() : null;
+			for (let e = 0; e < i.length; e++) {
+				let t = o ? H(o, e) : null;
+				n(i[e], t !== null && (qe(t) || et(t)));
+			}
+		} else for (let e = 0; e < i.length; e++) n(i[e], !1);
+	};
+	n(e, !0);
+}
+var Ze = /* @__PURE__ */ new Set([
+	"=",
+	"<>",
+	"<",
+	">",
+	"<=",
+	">="
+]), Qe = /* @__PURE__ */ new Set(["ROW", "COLUMN"]);
+function $e(e, t) {
+	if (!e || !t) return null;
+	let n = (e) => t(e.value)?.getName().toUpperCase() ?? null, r = !1;
+	if (f(e, (e) => {
+		(e.hasLazyArgs || e.type === y.Call || e.binder !== void 0) && (r = !0);
+	}), r) return null;
+	let i = (e) => e.type === y.Number, a = (e) => e.type === y.Number || e.type === y.String || e.type === y.Boolean, o = (e) => {
+		if (!e) return !1;
+		let t = e.inputs;
+		switch (e.type) {
+			case y.Paren: return t?.length === 1 && o(t[0]);
+			case y.Prefix: return (e.value === "-" || e.value === "+") && o(t?.[0]);
+			case y.Infix: {
+				if (e.value !== "+" && e.value !== "-" && e.value !== "*") return !1;
+				let [n, r] = t ?? [];
+				return !(!n || !r) && (o(n) && (o(r) || i(r)) || i(n) && o(r));
+			}
+			case y.Function: {
+				let r = n(e);
+				if (r !== null && Qe.has(r)) return !t || t.length === 0 || t.length === 1 && t[0]?.type === y.Cell;
+				if (r === "MOD" && t?.length === 2) {
+					let e = t[1];
+					return o(t[0]) && i(e) && e.value !== 0;
+				}
+				return !1;
+			}
+		}
+		return !1;
+	}, s = (e) => {
+		if (!e) return !1;
+		let t = e.inputs;
+		switch (e.type) {
+			case y.Paren: return t?.length === 1 && s(t[0]);
+			case y.Infix: {
+				if (!Ze.has(e.value)) return !1;
+				let [n, r] = t ?? [];
+				return !(!n || !r) && (o(n) && (o(r) || a(r)) || a(n) && o(r));
+			}
+			case y.Function: {
+				let r = n(e);
+				if (!t || t.length === 0) return !1;
+				if (r === "ISODD" || r === "ISEVEN") return t.length === 1 && o(t[0]);
+				if (r === "NOT") return t.length === 1 && s(t[0]);
+				if (r === "AND" || r === "OR" || r === "XOR") {
+					let e = !1;
+					for (let n = 0; n < t.length; n++) {
+						let r = t[n];
+						if (!r) return !1;
+						if (r.type !== y.Boolean) {
+							if (!s(r)) return !1;
+							e = !0;
+						}
+					}
+					return e;
+				}
+				return !1;
+			}
+		}
+		return !1;
+	}, c = [], l = (e) => {
+		if (!e) return;
+		if (s(e)) return void c.push(e);
+		let t = e.inputs;
+		if (t) for (let e = 0; e < t.length; e++) l(t[e]);
+	};
+	l(e);
+	let u = c.length;
+	if (u === 0 || u > 4) return null;
+	let d = [];
+	for (let t = 0; t < 1 << u; t++) {
+		let n = (e) => {
+			let r = c.indexOf(e);
+			if (r !== -1) return h(t & 1 << r ? "TRUE" : "FALSE");
+			let i = { ...e };
+			return delete i.evalIndex, delete i.firstCell, delete i.inLazy, delete i.lazyArg, delete i.hasLazyArgs, delete i.deferred, e.inputs && (i.inputs = e.inputs.map((e) => e && n(e))), i;
+		};
+		d.push(n(e));
+	}
+	return d;
+}
+var et = (e) => e.getRangeType() === "*" && e.getLambda() === null && e.getArrayDepth() <= +!!e.isRest();
+function tt(e, n, r, i = !1, a = null, o = null) {
+	let s, l, u = r;
+	u = ke(u), i || (u = Ae(u), u = Pe(u), u = je(u), u = Me(u)), [s, l] = function(e) {
+		let t = /* @__PURE__ */ new Map(), n = 0, r = [e];
+		for (; r.length > 0;) {
+			let e = r.shift();
+			if (t.set(e, {
+				...e,
+				evalIndex: n++
+			}), e && e.inputs) for (let t of e.inputs) r.push(t);
+		}
+		return t.forEach((e, n) => {
+			n && n.inputs && (e.inputs = n.inputs.map((e) => t.get(e) ?? e));
+		}), [t.get(e), n];
+	}(u);
+	let d, p = M(l), m = [], h = [], g = new Ee(), _ = !1;
+	(function(e, t) {
+		if (!e || !t) return;
+		let n = (e) => {
+			if (!e) return;
+			e.inLazy = !0, e.type === y.Named && (e.deferredResolve = !0);
+			let t = e.inputs;
+			if (t) for (let e = 0; e < t.length; e++) n(t[e]);
+		};
+		f(e, (e) => {
+			if (e.type !== y.Function || e.binder !== void 0) return;
+			let r = e.inputs;
+			if (!r || r.length === 0) return;
+			let i = t(e.value)?.getDeclaration().getParameters();
+			if (i) for (let t = 0; t < r.length; t++) {
+				let a = r[t];
+				a && a.type !== y.Empty && Ue(i, t)?.isLazy() && (a.lazyArg = !0, e.hasLazyArgs = !0, n(a));
+			}
+		});
+	})(s, o);
+	let v = (e) => {
+		d === void 0 && (d = /* @__PURE__ */ new Map());
+		let t = d.get(e);
+		return t === void 0 && d.set(e, t = []), t;
+	}, b = (e, t) => {
+		e === void 0 ? m.push(t) : v(e).push(t);
+	}, x = (e) => {
+		e?.type !== y.Infix || e.value !== "+" && e.value !== "-" || (e.snapsCancellation = !0);
+	};
+	s = f(s, (t, n, r) => {
+		let i = t.type, a = t.evalIndex;
+		if (p[a] = null, i === y.TableColumn || i === y.TableSpecifier || t.isReference && B(r, y.TableReference)) return;
+		if (_ ||= !q(t), t.binding?.declaration) return h[t.binding.slot] = -1, void (p[a] = void 0);
+		let o = ((e, t, n) => {
+			if (Ge(e, t)) return e;
+			for (let e = n.length - 1; e >= 0; e--) if (Ge(n[e], n[e - 1])) return n[e];
+		})(t, n, r);
+		o === t && v(t), o !== void 0 && i === y.Named && (t.deferredResolve = !0);
+		let s = t.binder;
+		if (s && s.kind === "let") {
+			let e = t.inputs, n = e?.length ?? 0, r = 0;
+			for (let t = 0; t + 1 < n && r < s.slots.length; t += 2) e[t]?.binding?.declaration && (h[s.slots[r++]] = e[t + 1]?.evalIndex ?? -1);
+		}
+		if ((t.isReference || n && n.isReference) && (g.processNode(t, n), t.isReference)) {
+			if (i === y.Named) return void (o !== void 0 && b(o, t));
+			if (i === y.Cell || i === y.TableReference || i === y.Error) return;
+			if (i === y.Infix || i === y.Prefix || i === y.Postfix || i === y.List) return void b(o, t);
+		}
+		if (t.isLiteral) {
+			if (i !== y.Array) p[a] = t.value;
+			else {
+				let n = t.value, r = n.length, i = M(r);
+				for (let e = 0; e < r; e++) {
+					let t = n[e].value, r = t.length, a = M(r);
+					for (let e = 0; e < r; e++) {
+						let n = t[e], r = null;
+						if (n && (r = n.type === y.Error ? c(n.value) : n.value, n.type === y.Prefix)) {
+							let e = n.value;
+							r = n.inputs[0].value, e === "-" && (r = -r);
+						}
+						a[e] = r;
+					}
+					i[e] = a;
+				}
+				let o = re(i);
+				p[a] = new te(e, o.values, o.coords, void 0, o.isLiteral);
+			}
+		} else {
+			if (i !== y.Empty) return t.binder?.kind === "lambda" && x(t.inputs[t.inputs.length - 1]), b(o, t), t;
+			p[a] = void 0;
+		}
+	}), x(s), d?.forEach((e, t) => {
+		t.deferred = e;
+	});
+	let S = M(g.cells.size);
+	g.cells.forEach((e, t) => {
+		let n = t.value, r = n.colIndex, i = n.rowIndex, a = n.$colIndex, o = n.$rowIndex, s = {
+			colStart: r,
+			rowStart: i,
+			colEnd: r,
+			rowEnd: i,
+			$colStart: a,
+			$rowStart: o,
+			$colEnd: a,
+			$rowEnd: o
+		};
+		r === -(2 ** 53 - 1) && (s.colEnd = 2 ** 53 - 1), i === -(2 ** 53 - 1) && (s.rowEnd = 2 ** 53 - 1), n.scope && (s.scope = n.scope), S[e] = s;
+	});
+	let C = S.length, w = M(C);
+	for (let e = 0; e < C; e++) w[e] = {
+		colStart: 0,
+		rowStart: 0,
+		colEnd: 0,
+		rowEnd: 0,
+		scope: null
+	};
+	let T = M(g.references.size);
+	g.references.forEach((e) => {
+		T[e.index] = e;
+	});
+	let E = [];
+	g.rootReferences.forEach((e) => {
+		E.push(e.index);
+	}), function(e, t, n = !1) {
+		if (n) {
+			let t = (e) => {
+				if (!e) return;
+				let n = e.type;
+				n !== y.Function && n !== y.Call || (e.implicitIntersect = !0);
+				let r = e.inputs;
+				if (r) for (let e = 0; e < r.length; e++) t(r[e]);
+			};
+			t(e);
+			return;
+		}
+		let r = (e) => W(e, t), i = (e, n) => {
+			if (!e) return;
+			let a = e.type;
+			a !== y.Function && a !== y.Call || (e.implicitIntersect = n);
+			let o = e.inputs;
+			if (o) {
+				if (a === y.Infix || a === y.Prefix || a === y.Postfix) {
+					let t = !e.isReference;
+					for (let e = 0; e < o.length; e++) i(o[e], (!t || !r(o[e])) && n);
+					return;
+				}
+				if (a === y.Function) {
+					let r = e.binder;
+					if (r !== void 0) {
+						let e = r.kind !== "lambda" && n;
+						for (let t = 0; t < o.length; t++) i(o[t], e);
+						return;
+					}
+					let a = t?.(e.value)?.getDeclaration().getParameters(), s = !1;
+					if (a) for (let e = 0; e < o.length && !s; e++) {
+						let n = o[e];
+						if (!n) continue;
+						let r = H(a, e);
+						r && Je(r, n, t) && (s = !0);
+					}
+					s && (e.implicitIntersect = !1);
+					for (let e = 0; e < o.length; e++) i(o[e], !s && n);
+					return;
+				}
+				for (let e = 0; e < o.length; e++) i(o[e], n);
+			}
+		};
+		i(e, !r(e));
+	}(s, o, !0 === r.legacyIntersect);
+	let D, O = (e) => {
+		let t = e.length;
+		for (let n = 0; n < t; n++) {
+			let t = e[n], r = t.type;
+			if (r === y.Infix) {
+				if (!0 === t.snapsCancellation) {
+					t.fn = Ce[t.value];
+					continue;
+				}
+				t.fn = Se[t.value];
+			} else r === y.Prefix ? t.fn = we[t.value] : r === y.Postfix && (t.fn = Te[t.value]);
+		}
+	};
+	O(m), d?.forEach(O);
+	let k = i ? ee(t(e.getLocale()).decimal) : j, A = {
+		runtime: e,
+		symbols: n,
+		getFunction: o,
+		ast: s,
+		evaluations: p,
+		executions: m,
+		bindings: h,
+		referencesAbsolute: w,
+		referencesExecute: T,
+		referencesRelative: S,
+		referencesRoot: E,
+		referenceIndices: g.referenceIndices,
+		formatReferenceIndices: Ie(s, o),
+		getTokens: () => D ??= V(s, i, k),
+		namedIds: Fe(s),
+		symbolIds: We(s),
+		hasTotals: Re(s, o),
+		hasDataTable: ze(s, o),
+		hasVolatile: Be(s, o),
+		...He(s, o),
+		isReferenceOnly: !_,
+		error: a,
+		transform: (t) => {
+			let r = f(s, t);
+			return r === s ? A : tt(e, n, r, i, a, o);
+		}
+	};
+	return A;
+}
+function nt(e) {
+	let t = -1, r = -1;
+	return Number.isSafeInteger(e.previousToken?.startLine) ? (t = e.previousToken.startLine, r = e.previousToken.endColumn + 1) : Number.isSafeInteger(e.token?.startLine) && (t = e.token.startLine, r = e.token.startColumn), t === -1 ? new n.Parse(e.message, { cause: e }) : (e.errorLocation = {
+		line: t,
+		column: r
+	}, new n.Parse(e.message, {
+		line: t,
+		column: r,
+		cause: e
+	}));
+}
+Object.freeze([
+	[
+		":",
+		".:.",
+		".:",
+		":."
+	],
+	["^"],
+	["*", "/"],
+	["+", "-"],
+	["&"],
+	[
+		"<",
+		">",
+		"=",
+		"<>",
+		"<=",
+		">="
+	]
+]);
+var rt = Object.freeze([
+	":",
+	".:.",
+	".:",
+	":."
+]), G = Object.freeze([
+	":",
+	" ",
+	".:.",
+	".:",
+	":."
+]), it = Object.freeze(["@"]), K = Object.freeze(["#"]), at = Object.freeze(G.concat(K)), q = (Object.freeze(G.concat(it).concat(K)), (e) => {
+	if (!e) return !1;
+	let t = e.type;
+	if (t === y.Cell || t === y.TableReference) return !0;
+	if (t === y.Infix) {
+		if (!G.includes(e.value)) return !1;
+		let t = e.inputs, n = t[0], r = t[1];
+		return q(n) && q(r);
+	}
+	return t === y.List && (e.inputs?.every(q) ?? !1);
+}), ot = (e) => !!(e && (e.type === y.Infix && at.includes(e.value) || e.type === y.Postfix && K.includes(e.value) || e.type === y.Array || e.type === y.TableReference)), st = Object.freeze([
+	"+",
+	"-",
+	"*",
+	"/",
+	"^",
+	"&",
+	"=",
+	"<>",
+	">",
+	"<",
+	">=",
+	"<="
+]), ct = Object.freeze(["-", "+"]), J = (e, t) => {
+	if (!e) return !1;
+	let n = e.type;
+	if (e.isLiteral) return n !== y.Error;
+	if (n === y.Paren || n === y.List) {
+		let n = e.inputs;
+		return !(!n || n.length === 0) && n.every((e) => J(e, t));
+	}
+	if (n === y.Infix) return st.includes(e.value);
+	if (n === y.Prefix) return ct.includes(e.value);
+	if (n === y.Postfix) return e.value === "%";
+	if (n === y.Function) {
+		if (!t) return !1;
+		let n = t(e.value);
+		if (!n) return !1;
+		let r = n.getDeclaration().getReturnType(), i = r.getRangeType();
+		return i !== "p" && (i !== null || r.getLambda() === null && r.getScalarType() != null);
+	}
+	return !1;
+}, lt = (e, t) => {
+	if (!e) return null;
+	let n = null, r = (e) => {
+		if (n || !e) return;
+		if (e.type === y.Infix && e.value === " ") {
+			let r = e.inputs, i = r?.[0], a = r?.[1];
+			if (J(i, t)) return void (n = i);
+			if (J(a, t)) return void (n = a);
+		}
+		let i = e.inputs;
+		if (i) for (let e = 0; e < i.length && !n; e++) r(i[e]);
+	};
+	return r(e), n;
+}, ut = (e, t) => {
+	if (!e) return null;
+	let n = null, r = (e) => {
+		if (n || !e) return;
+		if (e.type === y.Postfix && e.value === "#") {
+			let r = e.inputs?.[0];
+			if (r && J(r, t)) return void (n = r);
+		}
+		let i = e.inputs;
+		if (i) for (let e = 0; e < i.length && !n; e++) r(i[e]);
+	};
+	return r(e), n;
+}, dt = (e) => {
+	for (let t = 0; t < e.length; t++) if (e[t].getRepeatingTypes()) return t;
+	return -1;
+}, ft = (e, t, n) => {
+	let r = e[t].getRepeatingTypes(), i = r.length, a = t, o = e.length - t - 1, s = o;
+	for (; s > 0 && e[t + s].isOptional();) s--;
+	let c = +!e[t].isOptional(), l = r[i - 1].isOptional();
+	for (let e = s; e <= o; e++) {
+		let t = n - a - e;
+		if (t >= 0 && t % i === 0 && t / i >= c) return {
+			n: t / i,
+			short: !1,
+			variable: t,
+			period: i,
+			prefix: a,
+			suffix: e
+		};
+		if (l && t === i - 1) return {
+			n: 1,
+			short: !0,
+			variable: t,
+			period: i,
+			prefix: a,
+			suffix: e
+		};
+	}
+	return null;
+}, pt = (e) => {
+	if (!e) return null;
+	let t = null, n = (e) => {
+		if (t || !e) return;
+		if (e.type === y.Array && Array.isArray(e.value)) {
+			let n = e.value, r = n[0]?.value?.length ?? 0;
+			for (let e = 1; e < n.length && !t; e++) {
+				let i = n[e]?.value?.length ?? 0;
+				i !== r && (t = `Array rows must all be the same length — row ${e + 1} has ${i} value${i === 1 ? "" : "s"}, but row 1 has ${r}.`);
+			}
+		}
+		let r = e.inputs;
+		if (r) for (let e = 0; e < r.length && !t; e++) n(r[e]);
+	};
+	return n(e), t;
+}, mt = (e, t) => {
+	if (!e || !t) return null;
+	let n = null, r = (e) => {
+		if (n || !e) return;
+		if (e.type === y.Function) {
+			let r = e.value, i = t(r);
+			if (i) {
+				let t = i.getDeclaration(), a = t.getParameters(), o = e.inputs?.length ?? 0, s = t.getMaxArguments();
+				if (o > s) return void (n = `Too many arguments for ${r}. The most it accepts is ${s}, but got ${o}.`);
+				let c = a.length > 0 ? dt(a) : -1, l = a.length > 0 && a[a.length - 1].isRest();
+				if (c >= 0) {
+					if (!ft(a, c, o)) {
+						let e = a[c].getRepeatingTypes().length, t = a.length - 1;
+						n = e === 1 ? `Too few arguments for ${r}. Expected at least ${t + 1}, but got ${o}.` : `Wrong number of arguments for ${r}. Expected ${t} plus a multiple of ${e}, but got ${o}.`;
+					}
+				} else if (!l && o > a.length) n = `Too many arguments for ${r}. Expected ${a.length}, but got ${o}.`;
+				else for (let e = o; e < a.length && !n; e++) {
+					let t = a[e];
+					t.isOptional() || t.isRest() || (n = `Parameter ${t.getName()} is missing for ${r}.`);
+				}
+			}
+		}
+		let i = e.inputs;
+		if (i) for (let e = 0; e < i.length && !n; e++) r(i[e]);
+	};
+	return r(e), n;
+}, ht = (e, t) => {
+	if (!e || !t) return null;
+	let n = null, r = (e) => {
+		if (n || !e) return;
+		if (e.type === y.Function) {
+			let r = t(e.value);
+			if (r) {
+				let i = r.getDeclaration().getParameters(), a = e.inputs;
+				if (i.length > 0 && a) {
+					let e = ((e, t) => {
+						let n = Array(t), r = e.length, i = r > 0 ? dt(e) : -1;
+						if (i < 0) {
+							let i = r > 0 ? e[r - 1] : null, a = !!i && i.isRest();
+							for (let o = 0; o < t; o++) n[o] = o < r ? e[o] : a ? i : null;
+							return n;
+						}
+						let a = e[i].getRepeatingTypes(), o = a.length, s = i, c = ft(e, i, t), l = c ? c.suffix : r - i - 1, u = Math.max(0, t - s - l);
+						for (let c = 0; c < t; c++) if (c < s) n[c] = e[c];
+						else if (c < s + u) n[c] = a[(c - s) % o];
+						else {
+							let t = i + 1 + (c - s - u);
+							n[c] = t < r ? e[t] : null;
+						}
+						return n;
+					})(i, a.length);
+					for (let r = 0; r < a.length && !n; r++) {
+						let i = e[r];
+						i && i.getRangeType() === "p" && J(a[r], t) && (n = a[r]);
+					}
+				}
+			}
+		}
+		let i = e.inputs;
+		if (i) for (let e = 0; e < i.length && !n; e++) r(i[e]);
+	};
+	return r(e), n;
+}, gt = (e, t) => {
+	if (!e) return null;
+	let n = null, r = (e) => {
+		if (n || !e) return;
+		if (e.type === y.Call) {
+			let r = e.inputs?.[0];
+			if (r && J(r, t)) return void (n = "This expression always produces a value, so it cannot be called as a function.");
+		}
+		let i = e.inputs;
+		if (i) for (let e = 0; e < i.length && !n; e++) r(i[e]);
+	};
+	return r(e), n;
+}, Y = (e, t) => {
+	if (e.type !== y.Function) return;
+	let n = e.value;
+	if (typeof n != "string") return;
+	let r = (t?.(n)?.getName() ?? n).toUpperCase();
+	return r === "LET" ? "let" : r === "LAMBDA" ? "lambda" : void 0;
+}, X = (e) => {
+	if (e?.type !== y.Named) return;
+	let t = e.value;
+	return t?.nameId && !t.scope && !0 !== t.optional ? t.nameId : void 0;
+}, _t = /^[A-Za-z_\\][A-Za-z0-9_\\]*$/, vt = /* @__PURE__ */ new Set(["TRUE", "FALSE"]), yt = (e) => {
+	if (e?.type === y.Named) {
+		let t = e.value;
+		return !0 !== t?.optional || !t.nameId || t.scope ? void 0 : t.nameId;
+	}
+	if (e?.type !== y.TableReference) return;
+	let t, n = e.value;
+	if (n === null || typeof n == "string") {
+		if (n) return;
+		let r = e.inputs;
+		if (!r || r.length !== 1 || r[0]?.type !== y.TableColumn) return;
+		let i = r[0].value;
+		if (typeof i != "string") return;
+		t = i;
+	} else {
+		let e = n;
+		if (!e || e.tableId !== "" || e.spec !== 0 || !0 === e.isThisRow || !e.columnFromId || e.columnFromId !== e.columnToId) return;
+		t = e.columnFromId;
+	}
+	return _t.test(t) && !vt.has(t.toUpperCase()) && e.image === `[${t}]` ? t : void 0;
+}, bt = (e) => {
+	let t = C(e.image ?? e.value);
+	t.image = e.image ?? e.value, t.wsBefore = e.wsBefore;
+	let n = {
+		type: y.Call,
+		value: null,
+		inputs: [t, ...e.inputs ?? []],
+		wsAfter: e.wsAfter
+	};
+	return e.error && (n.error = e.error), n;
+};
+function xt(e, t) {
+	return e && t ? f(e, (e) => {
+		if (e.type === y.Function && typeof e.value == "string" && !t(e.value)) return bt(e);
+	}) : e;
+}
+function Z(e, t) {
+	let n = t.name.toUpperCase(), r = e ? e.filter((e) => e.name.toUpperCase() !== n) : [];
+	return r.push(t), r;
+}
+function St(e) {
+	if (e?.type !== y.Function || e.binder?.kind !== "lambda") return;
+	let t = e.inputs ?? [], n = [];
+	for (let e = 0; e < t.length - 1; e++) {
+		let r = t[e];
+		if (!r?.binding?.declaration) return;
+		let i = r.value.nameId;
+		n.push(r.binding.optional ? {
+			name: i,
+			optional: !0
+		} : { name: i });
+	}
+	return n;
+}
+var Ct = /* @__PURE__ */ new Set([
+	"IF",
+	"IFERROR",
+	"IFNA"
+]);
+function Q(e, t) {
+	if (!e || e.type !== y.Function || typeof e.value != "string") return e;
+	let n = (t?.(e.value)?.getName() ?? e.value).toUpperCase();
+	if (!Ct.has(n)) return e;
+	let r, i = e.inputs;
+	if (i) for (let e = 0; e < i.length; e++) {
+		let n = Q(i[e], t);
+		n !== i[e] && ((r ??= [...i])[e] = n);
+	}
+	return {
+		...e,
+		inputs: r ?? i,
+		passOmitted: !0
+	};
+}
+function wt(e, t = null) {
+	if (!e) return e;
+	let n = [], r = 0, i = (e) => {
+		let t, n = e.inputs;
+		if (!n) return e;
+		for (let e = 0; e < n.length; e++) {
+			let r = n[e];
+			if (!r) continue;
+			let i = a(r);
+			i !== r && (t ||= [...n], t[e] = i);
+		}
+		return t ? {
+			...e,
+			inputs: t
+		} : e;
+	}, a = (e) => {
+		if (!e) return e;
+		let o = Y(e, t);
+		if (o) return ((e, o) => {
+			let s = e.inputs, c = s?.length ?? 0;
+			if (!s || c < 1) return i(e);
+			let l = n.length, u = [], d = [...s], f = (e, t = !1) => {
+				let i = d[e], a = X(i), o = !1;
+				if (a === void 0 && t) {
+					if (a = yt(i), a === void 0) return;
+					o = !0;
+				} else if (a === void 0) return;
+				let s = r++;
+				n.push({
+					key: a.toUpperCase(),
+					slot: s,
+					name: a
+				}), u.push(s), d[e] = o ? {
+					...i,
+					type: y.Named,
+					value: {
+						nameId: a,
+						scope: null
+					},
+					inputs: null,
+					binding: {
+						slot: s,
+						declaration: !0,
+						optional: !0
+					},
+					isReference: !1
+				} : {
+					...i,
+					binding: {
+						slot: s,
+						declaration: !0
+					},
+					isReference: !1
+				};
+			};
+			if (o === "lambda") {
+				for (let e = 0; e < c - 1; e++) f(e, !0);
+				d[c - 1] && (d[c - 1] = a(d[c - 1]));
+			} else {
+				for (let e = 0; e + 1 < c; e += 2) d[e + 1] && (d[e + 1] = Q(a(d[e + 1]), t)), f(e);
+				c % 2 == 1 && d[c - 1] && (d[c - 1] = a(d[c - 1]));
+			}
+			for (; n.length > l;) n.pop();
+			return {
+				...e,
+				inputs: d,
+				binder: {
+					kind: o,
+					slots: u
+				}
+			};
+		})(e, o);
+		if (e.type === y.Function && typeof e.value == "string") {
+			let r = e.value.toUpperCase();
+			if (n.some((e) => e.key === r) && !t?.(e.value)) return i(bt(e));
+		}
+		if (n.length > 0 && e.isReference && e.value === ":" && e.inputs?.length === 2) {
+			let [t, r] = e.inputs;
+			if (Tt(t) && Tt(r)) {
+				let a = t.image.toUpperCase(), o = r.image.toUpperCase();
+				if (n.some((e) => e.key === a || e.key === o)) return i({
+					...e,
+					inputs: [Et(t), Et(r)]
+				});
+			}
+		}
+		if (e.type === y.Named) {
+			let t = X(e);
+			if (t !== void 0) {
+				let r = t.toUpperCase();
+				for (let i = n.length - 1; i >= 0; i--) {
+					if (n[i].key !== r) continue;
+					let a = {
+						...e,
+						binding: { slot: n[i].slot },
+						isReference: !1
+					};
+					return t !== n[i].name && (a.value = {
+						...e.value,
+						nameId: n[i].name
+					}), a;
+				}
+			}
+			return e;
+		}
+		let s = i(e);
+		if (s.type === y.Function && typeof s.value == "string" && (t?.(s.value)?.getName() ?? s.value).toUpperCase() === "ISOMITTED") {
+			let e = s.inputs;
+			if (e) {
+				let n;
+				for (let r = 0; r < e.length; r++) {
+					let i = e[r];
+					if (i?.binding && !i.binding.declaration && !0 !== i.rawFrameRead) {
+						(n ??= [...e])[r] = {
+							...i,
+							rawFrameRead: !0
+						};
+						continue;
+					}
+					let a = Q(i, t);
+					a !== i && ((n ??= [...e])[r] = a);
+				}
+				if (n) return {
+					...s,
+					inputs: n
+				};
+			}
+		}
+		return s;
+	};
+	return a(e);
+}
+var Tt = (e) => {
+	if (e?.type !== y.Cell || e.image === void 0) return !1;
+	let t = e.value;
+	return t.rowIndex === -(2 ** 53 - 1) && !0 !== t.$colIndex && !t.scope;
+}, Et = (e) => {
+	let t = C(e.image);
+	return w(t, e), t;
+}, Dt = (e) => e?.type === y.Cell, Ot = (e, t = null) => {
+	if (!e) return e;
+	let n = !1, r = (e) => {
+		if (n || !e) return;
+		let i = Y(e, t), a = e.inputs;
+		if (i && a) {
+			let e = i === "let" ? 2 : 1;
+			for (let t = 0; t < a.length - 1; t += e) if (Dt(a[t])) return void (n = !0);
+		}
+		if (a) for (let e = 0; e < a.length && !n; e++) r(a[e]);
+	};
+	if (r(e), !n) return e;
+	let i = null, a = f(e, (e) => {
+		if (e?.type !== y.Cell) return;
+		let t = e.value, n = e.image;
+		if (!0 === t?.$colIndex || !0 === t?.$rowIndex) return void (i ??= `'${n ?? "a reference"}' cannot be absolute here. A LET/LAMBDA name that is a cell reference makes every reference in the formula a name, and a name cannot contain '$'.`);
+		if (n === void 0) return;
+		let r = C(n);
+		w(r, e);
+		let a = t?.scope;
+		return a && (r.value.scope = a, r.value.scopeImage = t.scopeImage), r;
+	});
+	return i ?? a;
+}, kt = (e, t) => {
+	if (!e) return null;
+	let n = null, r = (e) => {
+		if (n || !e) return;
+		let i = Y(e, t);
+		i && ((e, t) => {
+			let r = t === "let" ? "LET" : "LAMBDA", i = e.inputs, a = i?.length ?? 0;
+			if (!i || a < 2) return;
+			if (t === "let" && a % 2 == 0) return void (n = `Wrong number of arguments for LET. Expected name/value pairs followed by a calculation, but got ${a}.`);
+			if (t === "lambda" && i[a - 1]?.type === y.Empty) return void (n = "LAMBDA has no calculation: the last argument is empty.");
+			let o = /* @__PURE__ */ new Set(), s = t === "let" ? 2 : 1, c = !1;
+			for (let e = 0; e < a - 1; e += s) {
+				let a = X(i[e]);
+				if (a === void 0 && t === "lambda") a = yt(i[e]), a !== void 0 && (c = !0);
+				else if (a !== void 0 && c) return void (n = `Required name '${a}' cannot follow an optional name in ${r}.`);
+				if (a === void 0) return void (n = `Expected a name in ${r} argument ${e + 1}; a name cannot be the output of a formula.`);
+				if (a.includes(".")) return void (n = `Expected a name in ${r} argument ${e + 1}; a name cannot contain '.'.`);
+				let s = a.toUpperCase();
+				if (o.has(s)) return void (n = `Duplicate name '${a}' in ${r}.`);
+				o.add(s);
+			}
+		})(e, i);
+		let a = e.inputs;
+		if (a) for (let e = 0; e < a.length && !n; e++) r(a[e]);
+	};
+	return r(e), n;
+};
+function At(e, t, n, r, i) {
+	let a, o = r, c = () => (a === void 0 && (a = i && n ? t.bind(x.Table, "", { at: {
+		scope: n,
+		rowIndex: i.rowIndex,
+		colIndex: i.colIndex
+	} }) : null), a);
+	return f(e, (e, r, i = []) => {
+		let a, l = e.type;
+		if (l === y.Cell) {
+			let n = e.value;
+			if (n?.scope) {
+				let r = t.bind(x.Sheet, n.scope, o);
+				r !== null && (a ||= { ...e }, a.value = {
+					...n,
+					scope: r
+				});
+			}
+		} else if (l === y.Named) {
+			let r = e.value;
+			if (r && !e.binding) {
+				let i = function(e, t, n, r) {
+					if (t.scope) {
+						let e = n.bind(x.Sheet, t.scope, r);
+						if (e === null || s(e)) return;
+					}
+					let i = n.bind(x.Table, t.nameId, { existing: !0 });
+					if (i === null) return;
+					let a = {
+						type: y.TableReference,
+						value: i,
+						inputs: null,
+						isReference: !0
+					};
+					w(a, e);
+					let o = t.scopeImage;
+					return typeof o == "string" && e.image !== void 0 && (a.image = o + e.image), a;
+				}(e, r, t, o);
+				if (i) return i;
+				let c = r.scope ? t.bind(x.Sheet, r.scope, o) : null, l = (c === null ? r.scope : s(c) ? c : t.resolve(x.Sheet, c)?.toString() ?? r.scope) ?? n, u = t.bind(x.NamedFormula, r.nameId, l ? { scope: l } : void 0);
+				u === null && c === null || (a ||= { ...e }, a.value = {
+					...r,
+					nameId: u ?? r.nameId,
+					...c === null ? void 0 : { scope: c }
+				});
+			}
+		} else if (l === y.Error) {
+			let n = e.value;
+			if (n?.scope) {
+				let r = t.bind(x.Sheet, n.scope, o);
+				r !== null && (a ||= { ...e }, a.value = {
+					...n,
+					scope: r
+				});
+			}
+		} else if (l === y.TableReference) {
+			let n = e.value;
+			if (n) {
+				let r = t.bind(x.Table, n);
+				a ||= { ...e }, r !== null && (a.value = r);
+			} else if (typeof n == "string") {
+				let n = c();
+				if (n !== null && $(e, t)) return {
+					...e,
+					value: n
+				};
+			}
+		} else if (l === y.TableColumn) {
+			let n = e.value;
+			if (n) {
+				let r = B(i, y.TableReference), o = r?.value || (r ? c() ?? void 0 : void 0), s = t.bind(x.TableColumn, n, o ? { tableName: o } : void 0);
+				a ||= { ...e }, s !== null && (a.value = s);
+			}
+		} else if (l === y.Function) {
+			let n = e.value;
+			if (n) {
+				let r = t.bind(x.Function, n);
+				a ||= { ...e }, r !== null && (a.value = r);
+			}
+		}
+		return a;
+	});
+}
+function $(e, t) {
+	let n = !0, r = e.inputs;
+	if (!r) return !0;
+	for (let e = 0; e < r.length && n; e++) f(r[e], (e) => {
+		e.type === y.TableColumn && t.resolve(x.TableColumn, e.value) === null && (n = !1);
+	});
+	return n;
+}
+function jt(e, t) {
+	let n = null;
+	return f(e, (e) => {
+		if (n || e.type !== y.TableReference) return;
+		if (e.value === "") return void (n = "A structured reference without a table name must be in a table that has its columns.");
+		let r = e.value;
+		if (!t || typeof r != "string") return;
+		let i = t.resolve(x.Table, r)?.toString() ?? r;
+		t.bind(x.Table, i, { existing: !0 }) === null ? n = `There is no table named '${i}'.` : $(e, t) || (n = "The table has no such column.");
+	}), n;
+}
+export { wt as A, nt as C, tt as D, rt as E, ut as O, mt as S, pt as T, je as _, De as a, kt as b, Ot as c, Te as d, V as f, ht as g, gt as h, Ce as i, xt as j, we as k, Pe as l, Z as m, Ae as n, Me as o, Xe as p, At as r, Oe as s, $e as t, Se as u, jt as v, ot as w, lt as x, ke as y };