@sheetxl/sdk 0.8.0-beta.10 → 0.8.0-beta.12

package/node/esm/lGJ42sHqg5if2bba.mjs

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