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

package/node/esm/DefYISWfdZJFx57m.mjs

@@ -0,0 +1,255 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.8.0-beta.10
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var x = [], y = Object.freeze({
+	mathDivide: {
+		av: [
+			"adj1 val 23520",
+			"adj2 val 5880",
+			"adj3 val 11760"
+		],
+		gd: [
+			"a1 pin 1000 adj1 36745",
+			"ma1 +- 0 0 a1",
+			"ma3h +/ 73490 ma1 4",
+			"ma3w */ 36745 w h",
+			"maxAdj3 min ma3h ma3w",
+			"a3 pin 1000 adj3 maxAdj3",
+			"m4a3 */ -4 a3 1",
+			"maxAdj2 +- 73490 m4a3 a1",
+			"a2 pin 0 adj2 maxAdj2",
+			"dy1 */ h a1 200000",
+			"yg */ h a2 100000",
+			"rad */ h a3 100000",
+			"dx1 */ w 73490 200000",
+			"y3 +- vc 0 dy1",
+			"y4 +- vc dy1 0",
+			"a +- yg rad 0",
+			"y2 +- y3 0 a",
+			"y1 +- y2 0 rad",
+			"y5 +- b 0 y1",
+			"x1 +- hc 0 dx1",
+			"x3 +- hc dx1 0",
+			"x2 +- hc 0 rad"
+		],
+		ah: [
+			"xy _ adj1 l y3 _ _ 1000 36745",
+			"xy _ adj2 r y2 _ _ 0 maxAdj2",
+			"xy adj3 _ x2 t 1000 maxAdj3 _ _"
+		],
+		cxn: [
+			"0 x3 vc",
+			"cd4 hc y5",
+			"cd2 x1 vc",
+			"3cd4 hc y1"
+		],
+		rect: "x1 y3 x3 y4",
+		paths: [{ d: "M hc y1 A rad rad 3cd4 21600000 Z M hc y5 A rad rad cd4 21600000 Z M x1 y3 L x3 y3 L x3 y4 L x1 y4 Z" }]
+	},
+	mathEqual: {
+		av: ["adj1 val 23520", "adj2 val 11760"],
+		gd: [
+			"a1 pin 0 adj1 36745",
+			"2a1 */ a1 2 1",
+			"mAdj2 +- 100000 0 2a1",
+			"a2 pin 0 adj2 mAdj2",
+			"dy1 */ h a1 100000",
+			"dy2 */ h a2 200000",
+			"dx1 */ w 73490 200000",
+			"y2 +- vc 0 dy2",
+			"y3 +- vc dy2 0",
+			"y1 +- y2 0 dy1",
+			"y4 +- y3 dy1 0",
+			"x1 +- hc 0 dx1",
+			"x2 +- hc dx1 0",
+			"yC1 +/ y1 y2 2",
+			"yC2 +/ y3 y4 2"
+		],
+		ah: ["xy _ adj1 l y1 _ _ 0 36745", "xy _ adj2 r y2 _ _ 0 mAdj2"],
+		cxn: [
+			"0 x2 yC1",
+			"0 x2 yC2",
+			"cd4 hc y4",
+			"cd2 x1 yC1",
+			"cd2 x1 yC2",
+			"3cd4 hc y1"
+		],
+		rect: "x1 y1 x2 y4",
+		paths: [{ d: "M x1 y1 L x2 y1 L x2 y2 L x1 y2 Z M x1 y3 L x2 y3 L x2 y4 L x1 y4 Z" }]
+	},
+	mathMinus: {
+		av: ["adj1 val 23520"],
+		gd: [
+			"a1 pin 0 adj1 100000",
+			"dy1 */ h a1 200000",
+			"dx1 */ w 73490 200000",
+			"y1 +- vc 0 dy1",
+			"y2 +- vc dy1 0",
+			"x1 +- hc 0 dx1",
+			"x2 +- hc dx1 0"
+		],
+		ah: ["xy _ adj1 l y1 _ _ 0 100000"],
+		cxn: [
+			"0 x2 vc",
+			"cd4 hc y2",
+			"cd2 x1 vc",
+			"3cd4 hc y1"
+		],
+		rect: "x1 y1 x2 y2",
+		paths: [{ d: "M x1 y1 L x2 y1 L x2 y2 L x1 y2 Z" }]
+	},
+	mathMultiply: {
+		av: ["adj1 val 23520"],
+		gd: [
+			"a1 pin 0 adj1 51965",
+			"th */ ss a1 100000",
+			"a at2 w h",
+			"sa sin 1 a",
+			"ca cos 1 a",
+			"ta tan 1 a",
+			"dl mod w h 0",
+			"rw */ dl 51965 100000",
+			"lM +- dl 0 rw",
+			"xM */ ca lM 2",
+			"yM */ sa lM 2",
+			"dxAM */ sa th 2",
+			"dyAM */ ca th 2",
+			"xA +- xM 0 dxAM",
+			"yA +- yM dyAM 0",
+			"xB +- xM dxAM 0",
+			"yB +- yM 0 dyAM",
+			"xBC +- hc 0 xB",
+			"yBC */ xBC ta 1",
+			"yC +- yBC yB 0",
+			"xD +- r 0 xB",
+			"xE +- r 0 xA",
+			"yFE +- vc 0 yA",
+			"xFE */ yFE 1 ta",
+			"xF +- xE 0 xFE",
+			"xL +- xA xFE 0",
+			"yG +- b 0 yA",
+			"yH +- b 0 yB",
+			"yI +- b 0 yC",
+			"xC2 +- r 0 xM",
+			"yC3 +- b 0 yM"
+		],
+		ah: ["xy _ adj1 l th _ _ 0 51965"],
+		cxn: [
+			"cd2 xM yM",
+			"3cd4 xC2 yM",
+			"0 xC2 yC3",
+			"cd4 xM yC3"
+		],
+		rect: "xA yB xE yH",
+		paths: [{ d: "M xA yA L xB yB L hc yC L xD yB L xE yA L xF vc L xE yG L xD yH L hc yI L xB yH L xA yG L xL vc Z" }]
+	},
+	mathNotEqual: {
+		av: [
+			"adj1 val 23520",
+			"adj2 val 6600000",
+			"adj3 val 11760"
+		],
+		gd: [
+			"a1 pin 0 adj1 50000",
+			"crAng pin 4200000 adj2 6600000",
+			"2a1 */ a1 2 1",
+			"maxAdj3 +- 100000 0 2a1",
+			"a3 pin 0 adj3 maxAdj3",
+			"dy1 */ h a1 100000",
+			"dy2 */ h a3 200000",
+			"dx1 */ w 73490 200000",
+			"x1 +- hc 0 dx1",
+			"x8 +- hc dx1 0",
+			"y2 +- vc 0 dy2",
+			"y3 +- vc dy2 0",
+			"y1 +- y2 0 dy1",
+			"y4 +- y3 dy1 0",
+			"cadj2 +- crAng 0 cd4",
+			"xadj2 tan hd2 cadj2",
+			"len mod xadj2 hd2 0",
+			"bhw */ len dy1 hd2",
+			"bhw2 */ bhw 1 2",
+			"x7 +- hc xadj2 bhw2",
+			"dx67 */ xadj2 y1 hd2",
+			"x6 +- x7 0 dx67",
+			"dx57 */ xadj2 y2 hd2",
+			"x5 +- x7 0 dx57",
+			"dx47 */ xadj2 y3 hd2",
+			"x4 +- x7 0 dx47",
+			"dx37 */ xadj2 y4 hd2",
+			"x3 +- x7 0 dx37",
+			"dx27 */ xadj2 2 1",
+			"x2 +- x7 0 dx27",
+			"rx7 +- x7 bhw 0",
+			"rx6 +- x6 bhw 0",
+			"rx5 +- x5 bhw 0",
+			"rx4 +- x4 bhw 0",
+			"rx3 +- x3 bhw 0",
+			"rx2 +- x2 bhw 0",
+			"dx7 */ dy1 hd2 len",
+			"rxt +- x7 dx7 0",
+			"lxt +- rx7 0 dx7",
+			"rx ?: cadj2 rxt rx7",
+			"lx ?: cadj2 x7 lxt",
+			"dy3 */ dy1 xadj2 len",
+			"dy4 +- 0 0 dy3",
+			"ry ?: cadj2 dy3 t",
+			"ly ?: cadj2 t dy4",
+			"dlx +- w 0 rx",
+			"drx +- w 0 lx",
+			"dly +- h 0 ry",
+			"dry +- h 0 ly",
+			"xC1 +/ rx lx 2",
+			"xC2 +/ drx dlx 2",
+			"yC1 +/ ry ly 2",
+			"yC2 +/ y1 y2 2",
+			"yC3 +/ y3 y4 2",
+			"yC4 +/ dry dly 2"
+		],
+		ah: [
+			"xy _ adj1 l y1 _ _ 0 50000",
+			"polar _ adj2 lx t _ _ 4200000 6600000",
+			"xy _ adj3 r y2 _ _ 0 maxAdj3"
+		],
+		cxn: [
+			"0 x8 yC2",
+			"0 x8 yC3",
+			"cd4 xC2 yC4",
+			"cd2 x1 yC2",
+			"cd2 x1 yC3",
+			"3cd4 xC1 yC1"
+		],
+		rect: "x1 y1 x8 y4",
+		paths: [{ d: "M x1 y1 L x6 y1 L lx ly L rx ry L rx6 y1 L x8 y1 L x8 y2 L rx5 y2 L rx4 y3 L x8 y3 L x8 y4 L rx3 y4 L drx dry L dlx dly L x3 y4 L x1 y4 L x1 y3 L x4 y3 L x5 y2 L x1 y2 Z" }]
+	},
+	mathPlus: {
+		av: ["adj1 val 23520"],
+		gd: [
+			"a1 pin 0 adj1 73490",
+			"dx1 */ w 73490 200000",
+			"dy1 */ h 73490 200000",
+			"dx2 */ ss a1 200000",
+			"x1 +- hc 0 dx1",
+			"x2 +- hc 0 dx2",
+			"x3 +- hc dx2 0",
+			"x4 +- hc dx1 0",
+			"y1 +- vc 0 dy1",
+			"y2 +- vc 0 dx2",
+			"y3 +- vc dx2 0",
+			"y4 +- vc dy1 0"
+		],
+		ah: ["xy _ adj1 l y2 _ _ 0 73490"],
+		cxn: [
+			"0 x4 vc",
+			"cd4 hc y4",
+			"cd2 x1 vc",
+			"3cd4 hc y1"
+		],
+		rect: "x1 y2 x4 y3",
+		paths: [{ d: "M x1 y2 L x2 y2 L x2 y1 L x3 y1 L x3 y2 L x4 y2 L x4 y3 L x3 y3 L x3 y4 L x2 y4 L x2 y3 L x1 y3 Z" }]
+	}
+});
+export { y as BUILT_IN, x as CXN_SHARED };

package/node/esm/Ds0d8zXzmgOu3MGx.mjs

@@ -0,0 +1,403 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.8.0-beta.10
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { A as e, C as t, D as n, E as r, F as s, I as a, ICalculation as o, M as l, N as i, O as c, P as u, S as p, T as d, _ as f, b as h, g, j as x, k as m, v as y, w as v, x as I, y as _ } from "./index.mjs";
+import { FormulaError as b } from "@sheetxl/primitives";
+import { CommonUtils as T } from "@sheetxl/utils";
+var P = class {
+	constructor(e) {
+		e = { ...e }, this._editing = "editing" === e.profile, this._parser = new s(e);
+	}
+	compile(s, a, l, g, T, P, k, E, w) {
+		if (0 === g.length) {
+			const e = new b.Parse(i);
+			return this._compileUnparsed(s, T, g, {
+				input: g,
+				cause: e,
+				causes: [e]
+			});
+		}
+		if (g.length > o.MAX_EXPRESSION_LENGTH) {
+			const e = new b.Parse(u(g.length, o.MAX_EXPRESSION_LENGTH));
+			return this._compileUnparsed(s, T, g, {
+				input: g,
+				cause: e,
+				causes: [e]
+			});
+		}
+		let F, C, U = [];
+		try {
+			const e = this._parser.parse(a, l, g);
+			F = e.root, U = e.errors, E && F && 0 === U.length && (F.legacyIntersect = !0);
+		} catch (e) {
+			C = b.isError(e, b.Code.Parse) ? e : new b.Parse(e.message, e);
+		}
+		const z = [];
+		for (const e of U) z.push(n(e));
+		if (F) {
+			const e = m(F, P ?? null);
+			"string" == typeof e ? z.push(new b.Parse(e)) : F = e, v(F, P ?? null) && z.push(new b.Parse("The implicit intersection operator ' ' requires a cell or range on both sides")), t(F, P ?? null) && z.push(new b.Parse("The spill anchor operator '#' requires a cell or range")), r(F, P ?? null) && z.push(new b.Parse("Expected a reference; a value cannot be converted to one."));
+			const n = _(F, P ?? null);
+			n && z.push(new b.Parse(n));
+			const s = h(F, P ?? null);
+			s && z.push(new b.Parse(s));
+			const a = I(F, P ?? null);
+			a && z.push(new b.Parse(a));
+			const o = p(F);
+			o && z.push(new b.Parse(o));
+		}
+		z.length > 0 && !C && (C = z[0]);
+		let R = null;
+		if (C && (R = {
+			input: g,
+			cause: C,
+			causes: z.length > 0 ? z : [C]
+		}), !F) {
+			if (this._editing) {
+				const e = this._recoverCompiled(s, a, l, g, T, R, k);
+				if (e) return e;
+			}
+			return this._compileUnparsed(s, T, g, R, this._editing, () => A(T, k, a, l));
+		}
+		if (F = e(F, P ?? null), F = f(F, P ?? null), T) {
+			const e = this._editing ? w : {
+				mint: !w?.book,
+				...w
+			};
+			F = c(F, T, k, e, {
+				rowIndex: a,
+				colIndex: l
+			});
+			const t = d(F, T);
+			if (t) {
+				const e = new b.Parse(t);
+				z.push(e), R = {
+					input: g,
+					cause: R?.cause ?? e,
+					causes: R ? [...R.causes, e] : [e]
+				};
+			}
+		}
+		const S = y(s, T, F, this._editing, R, P ?? null);
+		if (this._editing && R && x(S.getTokens(), T) !== g) return this._recoverCompiled(s, a, l, g, T, R, k) || this._compileUnparsed(s, T, g, R, !0);
+		return S;
+	}
+	autoCorrect(e) {
+		const t = function(e) {
+			let t = 0, n = null;
+			for (let r = 0; r < e.length; r++) {
+				const s = e[r];
+				n ? s === n && (n = null) : t > 0 ? "'" === s ? r++ : "[" === s ? t++ : "]" === s && t-- : "\"" === s || "'" === s ? n = s : "[" === s && t++;
+			}
+			return n ? 0 : t;
+		}(e), n = e + "]".repeat(t);
+		let r;
+		try {
+			const e = this._parser.getLexer().tokenize(n, !1);
+			if (e.errors.length > 0) return null;
+			r = e.tokens;
+		} catch {
+			return null;
+		}
+		const s = [];
+		for (const e of r) {
+			const t = e.tokenType?.name;
+			if ("OpenParen" === t) s.push(")");
+			else if ("OpenCurlyParen" === t) s.push("}");
+			else if (("CloseParen" === t || "CloseCurlyParen" === t) && s.pop() !== ("CloseParen" === t ? ")" : "}")) return null;
+		}
+		return 0 === s.length && 0 === t ? null : n + s.reverse().join("");
+	}
+	_compileUnparsed(e, t, n, r, s = !1, o) {
+		const l = {
+			runtime: e,
+			symbols: t,
+			getFunction: null,
+			ast: null,
+			evaluations: T.EmptyArray,
+			executions: T.EmptyArray,
+			bindings: T.EmptyArray,
+			referencesAbsolute: T.EmptyArray,
+			referencesExecute: T.EmptyArray,
+			referencesRelative: T.EmptyArray,
+			referencesRoot: T.EmptyArray,
+			referenceIndices: T.EmptyArray,
+			formatReferenceIndices: T.EmptyArray,
+			getTokens: () => {
+				const e = [];
+				return s && F(e, n, void 0, o) ? e : [{
+					type: a.Unparsed,
+					value: n,
+					text: n
+				}];
+			},
+			namedIds: T.EmptyArray,
+			symbolIds: T.EmptyArray,
+			hasTotals: !1,
+			hasVolatile: !1,
+			isBlankCacheable: !1,
+			isBlankCacheableArray: !1,
+			isReferenceOnly: !1,
+			error: r,
+			transform: () => l
+		};
+		return l;
+	}
+	_recoverCompiled(e, t, n, r, s, o, l) {
+		let i, u = r.length;
+		try {
+			const e = this._parser.getLexer().tokenize(r, !1);
+			i = e.tokens, e.errors.length > 0 && (u = Math.min(u, e.errors[0].offset));
+		} catch {
+			return null;
+		}
+		const p = [];
+		for (let e = i.length - 1; e >= 0 && p.length < 24; e--) {
+			const t = (i[e].endOffset ?? -1) + 1;
+			t > 0 && t < r.length && t <= u && p.push(t);
+		}
+		for (const i of p) {
+			const u = r.slice(0, i);
+			let p, d;
+			try {
+				p = this._parser.parse(t, n, u).root;
+			} catch {
+				continue;
+			}
+			if (!p || p.type === a.Unparsed) continue;
+			try {
+				const r = f(p, null), a = s ? c(r, s, l, void 0, {
+					rowIndex: t,
+					colIndex: n
+				}) : r;
+				d = y(e, s, a, !0, o);
+			} catch {
+				continue;
+			}
+			if (x(d.getTokens(), s) !== u) continue;
+			const h = r.slice(i);
+			if (0 === h.length) return d;
+			let g;
+			const m = {
+				...d,
+				getTokens: () => (g || (g = [...d.getTokens()], this._appendUnparsedTail(g, h, () => A(s, l, t, n))), g),
+				transform: () => m
+			};
+			return m;
+		}
+		return null;
+	}
+	_appendUnparsedTail(e, t, n) {
+		const r = [];
+		for (const t of e) {
+			if (t.type === a.Whitespace) continue;
+			const e = t.type === a.Paren || t.type === a.Type ? t.text : void 0, n = r.length > 0 ? r[r.length - 1] : void 0;
+			if (t.type === a.Separator && n) {
+				const e = n.declared[n.declared.length - 1];
+				"let" === n.ctx?.type && -1 === n.ctx.argIndex && n.lambda?.argTokens === n.argTokens && e?.argIndex === n.argIndex - 1 && (e.params = n.lambda.params), n.argIndex++, n.argTokens = 0, n.lambda = void 0;
+				continue;
+			}
+			if (n && n.argTokens++, "(" === e || "[" === e || "{" === e) r.push({
+				ctx: t.context,
+				argIndex: 0,
+				declared: [],
+				argTokens: 0,
+				leadsArg: 2 === n?.argTokens
+			});
+			else if (")" === e || "]" === e || "}" === e) {
+				const e = r.pop(), t = r.length > 0 ? r[r.length - 1] : void 0;
+				t && e?.leadsArg && "lambda" === e.ctx?.type && -1 === e.ctx.argIndex && (t.lambda = {
+					params: e.declared.map(({ name: e, optional: t }) => t ? {
+						name: e,
+						optional: t
+					} : { name: e }),
+					argTokens: t.argTokens
+				});
+			} else if (t.type === a.Parameter && n && t.value?.declaration) {
+				const e = t.value;
+				n.declared.push(e.optional ? {
+					name: e.name,
+					argIndex: n.argIndex,
+					optional: !0
+				} : {
+					name: e.name,
+					argIndex: n.argIndex
+				});
+			}
+		}
+		const s = r.length > 0 ? r[r.length - 1] : void 0, o = s?.ctx ? {
+			...s.ctx,
+			argIndex: -1 === s.ctx.argIndex ? s.argIndex : s.ctx.argIndex
+		} : void 0;
+		if (o && -1 === s.ctx.argIndex && ("let" === o.type || "lambda" === o.type)) {
+			const e = "let" === o.type ? 2 : 1;
+			let t = o.bound;
+			for (const n of s.declared) {
+				if (o.argIndex < n.argIndex + e) continue;
+				const { name: r, params: s } = n;
+				t = g(t, s ? {
+					name: r,
+					params: s
+				} : { name: r });
+			}
+			t && (o.bound = t);
+		}
+		const l = (t, n) => {
+			const r = n ? {
+				type: a.Named,
+				value: { name: t },
+				text: t
+			} : {
+				type: a.Unparsed,
+				value: t,
+				text: t
+			};
+			o && (r.context = o), e.push(r);
+		};
+		if (F(e, t, o, n)) return;
+		const i = /[A-Za-z_][A-Za-z0-9_]*$/.exec(t), c = i ? i.index : -1;
+		let u = c > 0 ? t[c - 1] : "";
+		for (let t = e.length - 1; 0 === c && t >= 0 && !u; t--) u = e[t].text?.at(-1) ?? "";
+		c >= 0 && !/[A-Za-z0-9_.]/.test(u) ? (c > 0 && l(t.slice(0, c)), l(t.slice(c), !0)) : l(t);
+	}
+};
+function A(e, t, n, r) {
+	if (!e || !t) return;
+	const s = e.bind(l.Table, "", { at: {
+		scope: t,
+		rowIndex: n,
+		colIndex: r
+	} });
+	return s ? e.resolve(l.Table, s)?.toString() : void 0;
+}
+var k = /[A-Za-z_\\\u007F-\uFFFF][A-Za-z0-9_.\u007F-\uFFFF]*$/, E = /[A-Za-z0-9_.)\]}"'!#\u007F-\uFFFF]/;
+function w(e, t) {
+	for (let n = t + 1; n < e.length; n++) {
+		const t = e[n];
+		if ("'" !== t) {
+			if ("]" === t) return n + 1;
+			if ("[" === t) return null;
+		} else n++;
+	}
+	return -1;
+}
+function F(e, t, n, r) {
+	let s = 0, o = -1;
+	for (let e = 0; e < t.length; e++) {
+		const n = t[e];
+		s > 0 && "'" === n ? e++ : "[" === n ? (0 === s && (o = e), s++) : "]" === n && s > 0 && s--;
+	}
+	if (0 === s) return !1;
+	let l = t.slice(0, o);
+	if ((l.split("\"").length - 1) % 2 == 1) return !1;
+	const i = e.length > 0 ? e[e.length - 1] : void 0;
+	let c = "", u = !1;
+	const p = k.exec(l);
+	if (p) {
+		const e = p.index > 0 ? l[p.index - 1] : i?.text?.at(-1) ?? "";
+		if (/[A-Za-z0-9_.]/.test(e)) return !1;
+		c = p[0], l = l.slice(0, p.index);
+	} else 0 === l.length && i?.text && 0 === k.exec(i.text)?.index && (i.type === a.Named && !i.value?.scope || i.type === a.TableReference) && (c = i.text, u = !0);
+	if (!u) {
+		const e = l.length > 0 ? l[l.length - 1] : i?.text?.at(-1) ?? "";
+		if (e && E.test(e)) return !1;
+	}
+	const d = c || (r?.() ?? ""), f = [], h = (e, t, n) => {
+		f.push({
+			type: e,
+			value: t,
+			text: t,
+			context: {
+				name: d,
+				argIndex: n,
+				type: "table"
+			}
+		});
+	}, g = (e, t, n, r) => {
+		const s = e.startsWith("#"), o = n ? r ? "column" : s ? "specifier" : e ? "column" : "any" : void 0, l = o ? {
+			table: d,
+			name: e,
+			partial: o
+		} : {
+			table: d,
+			name: e
+		};
+		f.push({
+			type: s ? a.TableSpecifier : a.TableColumn,
+			value: l,
+			text: e,
+			context: {
+				name: d,
+				argIndex: t,
+				type: "table"
+			}
+		});
+	}, x = (e, t, n, r) => {
+		h(a.Paren, "[", n), g(e.slice(1, t ? -1 : void 0), n, !t, r), t && h(a.Paren, "]", n);
+	};
+	h(a.Paren, "[", -1);
+	const m = t.slice(o + 1);
+	if (m.startsWith("[")) {
+		let e = 0, t = !1, n = 0;
+		for (; n < m.length;) {
+			const r = m[n];
+			if ("[" === r) {
+				const r = w(m, n);
+				if (null === r) return !1;
+				const s = -1 !== r;
+				if (x(m.slice(n, s ? r : m.length), s, e, t), t = !1, !s) break;
+				n = r;
+			} else if ("," === r) h(a.Separator, ",", e++), n++;
+			else if (":" === r) h(a.Infix, ":", e), n++;
+			else if ("@" === r) h(a.Prefix, "@", e), t = !0, n++;
+			else {
+				if (" " !== r) return !1;
+				{
+					let t = n;
+					for (; " " === m[t];) t++;
+					h(a.Whitespace, m.slice(n, t), e), n = t;
+				}
+			}
+		}
+	} else {
+		let e = m;
+		const t = e.startsWith("@");
+		if (t && (h(a.Prefix, "@", 0), e = e.slice(1)), e.startsWith("[")) {
+			if (-1 !== w(e, 0)) return !1;
+			x(e, !1, 0, t);
+		} else {
+			if (/(^|[^'])[[\]]/.test(e) || e.startsWith("#") && e.includes(",")) return !1;
+			g(e, 0, !0, t);
+		}
+	}
+	if (l) {
+		const t = {
+			type: a.Unparsed,
+			value: l,
+			text: l
+		};
+		n && (t.context = n), e.push(t);
+	}
+	if (u) {
+		const t = {
+			...i,
+			type: a.TableReference,
+			value: c,
+			text: c
+		};
+		delete t.referenceIndex, e[e.length - 1] = t;
+	} else if (c) {
+		const t = {
+			type: a.TableReference,
+			value: c,
+			text: c
+		};
+		n && (t.context = n), e.push(t);
+	}
+	for (const t of f) e.push(t);
+	return !0;
+}
+export { P as FormulaCompiler, F as appendPartialStructuredReference };