@sheetxl/sdk
Version:
SDK - A high-performance, embeddable spreadsheet engine.
1,073 lines • 53.5 kB
JavaScript
/**
* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.6.4
*
* (C) 2025-present SheetXL Inc. & Michael T. Ford
* License: The license can be found at https://www.sheetxl.com/license.
*/
import { c as e, t, g as n, a as r, b as s, d as i, e as o, r as a, m as l, f as u } from "./index.mjs";
import { FormulaError as c, ScalarType as p } from "@sheetxl/primitives";
import { CoordUtils as f, CommonUtils as h } from "@sheetxl/utils";
import { Lexer as g, createToken as d, EmbeddedActionsParser as m } from "chevrotain";
const E = d({ name: "WhiteSpace", pattern: /\s+/, group: g.SKIPPED }), A = d({ name: "String", pattern: /"(""|[^"])*"/ }), N = d({ name: "SingleQuotedString", pattern: /'(''|[^'])*'/ }), I = d({ name: "SheetQuoted", pattern: /'((?![\\/[\]*?:]).)+?'!/ }), O = d({ name: "FunctionToken", pattern: /[A-Za-z_]+[A-Za-z_0-9.]*\(/ }), x = d({ name: "NamedTableReference", pattern: /[A-Za-z_]+[A-Za-z_0-9.]*\[/ }), S = d({ name: "BracketedString", pattern: /\[([^[\]]*)\]/, longer_alt: [x, A] }), L = d({ name: "LiteralError", pattern: /#PARSE!|#NULL!|#DIV\/0!|#VALUE!|#NUM!|#FIELD!|#N\/A|#GETTING_DATA|#SPILL!|#CONNECT!|#BLOCKED!|#UNKNOWN!|#FIELD!|#CALC!|#BUSY!|#PYTHON!|#TIMEOUT!/ }), T = d({ name: "RefError", pattern: /#REF!|#NAME\?/ }), R = d({ name: "Sheet", pattern: /[A-Za-z_.\d\u007F-\uFFFF]+!/ }), v = /^[a-zA-Z_][a-zA-Z0-9_.?]*:?/, U = d({ name: "Name", pattern: { exec: (e2, t2) => {
try {
const n2 = v.exec(e2.substring(t2));
if (n2) {
const e3 = n2[0];
if (e3.endsWith(":")) {
const t3 = e3.length;
return "." === e3[t3 - 2] ? [e3.substring(0, t3 - 2)] : [e3.substring(0, t3 - 1)];
}
return [e3];
}
} catch (e3) {
console.warn("Error parsing name", e3);
}
return null;
} }, line_breaks: false, start_chars_hint: (() => {
const e2 = [];
for (let t2 = 65; t2 <= 90; t2++) e2.push(t2);
for (let t2 = 97; t2 <= 122; t2++) e2.push(t2);
for (let t2 = 48; t2 <= 57; t2++) e2.push(t2);
return e2;
})() }), y = d({ name: "Cell", pattern: /[$]?[A-Za-z]{1,3}[$]?[1-9][0-9]*/, longer_alt: U }), w = d({ name: "Column", pattern: /[$]?[A-Za-z]{1,3}/, longer_alt: U }), C = d({ name: "AbsRow", pattern: /[$][0-9]+/, longer_alt: U }), _ = d({ name: "NumberToken", pattern: /[0-9]+[.]?[0-9]*([eE][+-][0-9]+)?/ }), M = d({ name: "Boolean", pattern: /TRUE|FALSE/i }), b = d({ name: "Comma", pattern: /,/ }), P = d({ name: "RangeUnion", pattern: /:/ }), B = d({ name: "RangeTrimFull", pattern: /\.:\./ }), F = d({ name: "RangeTrimLeading", pattern: /\.:/ }), $ = d({ name: "RangeTrimTrailing", pattern: /:\./ }), W = d({ name: "Semicolon", pattern: /;/ }), z = d({ name: "OpenParen", pattern: /\(/ }), k = d({ name: "CloseParen", pattern: /\)/ }), V = d({ name: "OpenSquareParen", pattern: /\[/ }), G = d({ name: "CloseSquareParen", pattern: /]/ });
d({ name: "exclamationMark", pattern: /!/ });
const q = d({ name: "OpenCurlyParen", pattern: /{/ }), j = d({ name: "CloseCurlyParen", pattern: /}/ }), Y = d({ name: "QuoteS", pattern: /'/ }), D = d({ name: "MulOp", pattern: /\*/ }), Z = d({ name: "PlusOp", pattern: /\+/ }), H = d({ name: "DivOp", pattern: /\// }), K = d({ name: "MinOp", pattern: /-/ }), Q = d({ name: "ImplicitIntersectOp", pattern: /@/ }), X = d({ name: "ConcatOp", pattern: /&/ }), J = d({ name: "ExOp", pattern: /\^/ }), ee = d({ name: "PercentOp", pattern: /%/ }), te = d({ name: "TableSpecifier", pattern: /#(All|Data|Headers|Totals|This Row)/i }), ne = d({ name: "ArrayAnchorOp", pattern: /#/, longer_alt: [te, L, T] }), re = d({ name: "GtOp", pattern: />/ }), se = d({ name: "EqOp", pattern: /=/ }), ie = d({ name: "LtOp", pattern: /</ }), oe = [E, A, I, N, O, x, S, L, T, R, y, M, w, C, te, ne, Q, U, _, b, B, F, $, P, W, z, k, V, G, q, j, Y, D, Z, H, K, X, J, D, ee, d({ name: "NeqOp", pattern: /<>/ }), d({ name: "GteOp", pattern: />=/ }), d({ name: "LteOp", pattern: /<=/ }), re, se, ie], ae = new g(oe, { ensureOptimizations: true }), le = {};
oe.forEach((e2) => {
le[e2.name] = e2;
});
const ue = { boolean: 3, string: 2, number: 1 }, ce = (e2, t2) => {
let n2 = e2 + t2;
return n2 = Math.abs(n2) < 99e-14 ? 0 : n2, isFinite(n2) ? n2 : Number.NaN;
}, pe = (e2, t2) => {
let n2 = e2 - t2;
return n2 = Math.abs(n2) < 99e-14 ? 0 : n2, isFinite(n2) ? n2 : Number.NaN;
}, fe = (e2, t2) => {
let n2 = e2 * t2;
return n2 = Math.abs(n2) < 99e-14 ? 0 : n2, isFinite(n2) ? n2 : Number.NaN;
}, he = (e2, t2) => {
if (0 === t2) return 1 / 0;
let n2 = e2 / t2;
return n2 = Math.abs(n2) < 99e-14 ? 0 : n2, isFinite(n2) ? n2 : Number.NaN;
}, ge = (e2, t2) => {
const n2 = e2 ** t2;
return isFinite(n2) ? n2 : Number.NaN;
}, de = (e2 = "", t2 = "") => {
null === e2 && (e2 = ""), null === t2 && (t2 = "");
return "boolean" === typeof e2 && (e2 = e2 ? "TRUE" : "FALSE"), "boolean" === typeof t2 && (t2 = t2 ? "TRUE" : "FALSE"), "" + e2 + t2;
}, me = (e2 = null, t2 = null) => typeof e2 === typeof t2 && e2 === t2, Ee = (e2 = null, t2 = null) => typeof e2 !== typeof t2 || e2 !== t2, Ae = (e2 = null, t2 = null) => {
const n2 = typeof e2, r2 = typeof t2;
return n2 === r2 ? e2 > t2 : ue[n2] > ue[r2];
}, Ne = (e2 = null, t2 = null) => {
const n2 = typeof e2, r2 = typeof t2;
return n2 === r2 ? e2 >= t2 : ue[n2] >= ue[r2];
}, Ie = (e2 = null, t2 = null) => {
const n2 = typeof e2, r2 = typeof t2;
return n2 === r2 ? e2 < t2 : ue[n2] < ue[r2];
}, Oe = (e2 = null, t2 = null) => {
const n2 = typeof e2, r2 = typeof t2;
return n2 === r2 ? e2 <= t2 : ue[n2] <= ue[r2];
}, xe = { type: p.Number, coerce: true, includeBoolean: true, includeMistyped: true, mismatchFill: c.BuiltIn.NA }, Se = { type: p.String, coerce: true, includeMistyped: true, mismatchFill: c.BuiltIn.NA }, Le = { type: null, coerce: true, includeMistyped: true, mismatchFill: c.BuiltIn.NA }, Te = (n2, r2, s2, i2) => {
if (null !== r2 && void 0 !== r2.colStart && (r2 = n2.getValueAt(r2.rowStart, r2.colStart)), null !== s2 && void 0 !== s2.colStart && (s2 = n2.getValueAt(s2.rowStart, s2.colStart)), "number" == typeof r2 && "number" == typeof s2) return i2(r2, s2);
let o2, a2;
if (r2?.isIRange ? o2 = r2 : s2?.isIRange && (a2 = s2), !o2 && !a2) {
const n3 = false;
return r2 = e(r2, t(r2, true), p.Number, true, n3), s2 = e(s2, t(s2, true), p.Number, true, n3), r2 instanceof c.Value ? r2 : s2 instanceof c.Value ? s2 : i2(r2, s2);
}
return o2 || (o2 = n2.getRange(r2)), o2.broadcast(s2, i2, xe).fillEmpty(0);
}, Re = (e2, t2, n2, r2) => {
let s2, i2;
return null !== t2 && void 0 !== t2.colStart && (t2 = e2.getValueAt(t2.rowStart, t2.colStart)), null !== n2 && void 0 !== n2.colStart && (n2 = e2.getValueAt(n2.rowStart, n2.colStart)), t2?.isIRange ? (s2 = t2, i2 = n2) : n2?.isIRange && (s2 = n2, i2 = t2), s2 ? s2.broadcast(i2, r2, Le) : r2(t2, n2);
}, ve = (n2, r2) => {
null == r2 && (r2 = 0);
let s2, i2 = 1;
if ("+" === n2) return r2;
if ("-" !== n2) throw new c.Value(`Unrecognized prefix: ${n2}`);
return i2 = -i2, r2?.isIRange && (s2 = r2), s2 ? s2.broadcast(i2, fe, Le) : "number" != typeof (r2 = e(r2, t(r2, true), p.Number)) || isNaN(r2) ? c.BuiltIn.Value : r2 * i2;
}, Ue = (e2, t2, n2, r2) => {
if (!t2) return c.BuiltIn.Ref;
if (t2.isIReferenceRange && (t2 = t2.getCoords()), void 0 === t2.colStart) return c.BuiltIn.Ref;
if (n2.isIReferenceRange && (n2 = n2.getCoords()), void 0 === n2.colStart) return c.BuiltIn.Ref;
const s2 = r2(t2, n2);
return s2 ? e2.getReference(s2) : c.BuiltIn.Null;
}, ye = { "+": (e2, t2, n2) => Te(e2, t2, n2, ce), "-": (e2, t2, n2) => Te(e2, t2, n2, pe), "*": (e2, t2, n2) => Te(e2, t2, n2, fe), "/": (e2, t2, n2) => Te(e2, t2, n2, he), "^": (e2, t2, n2) => Te(e2, t2, n2, ge), " ": (e2, t2, n2, r2) => Ue(e2, t2, n2, f.intersectRanges), ":": (e2, t2, n2, r2) => Ue(e2, t2, n2, f.unionRanges), ".:.": (e2, t2, n2, r2) => {
const s2 = Ue(e2, t2, n2, f.unionRanges);
return e2.getFunction("TRIMRANGE").execute(s2, 3, 3);
}, ".:": (e2, t2, n2, r2) => {
const s2 = Ue(e2, t2, n2, f.unionRanges);
return e2.getFunction("TRIMRANGE").execute(s2, 1, 1);
}, ":.": (e2, t2, n2, r2) => {
const s2 = Ue(e2, t2, n2, f.unionRanges);
return e2.getFunction("TRIMRANGE").execute(s2, 2, 2);
}, "&": (n2, r2, s2) => ((n3, r3, s3, i2) => {
if (null !== r3 && void 0 !== r3.colStart && (r3 = n3.getValueAt(r3.rowStart, r3.colStart)), null !== s3 && void 0 !== s3.colStart && (s3 = n3.getValueAt(s3.rowStart, s3.colStart)), "string" == typeof r3 && "string" == typeof s3) return i2(r3, s3);
let o2, a2;
return r3?.isIRange ? o2 = r3 : s3?.isIRange && (a2 = s3), o2 || a2 ? (o2 || (o2 = n3.getRange(r3)), o2.broadcast(s3, i2, Se)) : i2(r3 = e(r3, t(r3, true), p.String), s3 = e(s3, t(s3, true), p.String));
})(n2, r2, s2, de), "=": (e2, t2, n2) => Re(e2, t2, n2, me), "<>": (e2, t2, n2) => Re(e2, t2, n2, Ee), ">": (e2, t2, n2) => Re(e2, t2, n2, Ae), "<": (e2, t2, n2) => Re(e2, t2, n2, Ie), ">=": (e2, t2, n2) => Re(e2, t2, n2, Ne), "<=": (e2, t2, n2) => Re(e2, t2, n2, Oe) }, we = { "-": (e2, t2) => ve("-", t2), "+": (e2, t2) => ve("+", t2), "@": (e2, t2) => {
if (!t2 || !t2.isIReferenceRange) return t2;
const n2 = t2.getCoords(), r2 = t2, s2 = e2.getPosition(), i2 = r2.getHeight(), o2 = r2.getWidth();
if (o2 > 1 && i2 > 1) return c.BuiltIn.Value;
if (i2 > 1) {
const e3 = s2.rowIndex - n2.rowStart;
if (e3 >= 0 && e3 < i2) return r2.getValueAt(e3, 0);
} else {
if (!(o2 > 1)) return r2.getValueAt(0, 0);
{
const e3 = s2.colIndex - n2.colStart;
if (e3 >= 0 && e3 < o2) return r2.getValueAt(0, e3);
}
}
return c.BuiltIn.Value;
} }, Ce = { "%": (e2, t2) => Te(e2, t2, 100, he), "#": (e2, t2) => {
const n2 = e2.getSpillAt(t2.rowStart, t2.colStart);
return n2 || c.BuiltIn.Ref;
} };
function _e(e2) {
const t2 = (e2 = e2.toUpperCase()).length;
let n2 = 0;
for (let r2 = 0; r2 < t2; r2++) {
const s2 = e2.charCodeAt(r2);
isNaN(s2) || (n2 += (s2 - 64) * 26 ** (t2 - r2 - 1));
}
return n2;
}
function Me(e2) {
return { type: "cell", value: Object.freeze({ colIndex: e2.colIndex, rowIndex: e2.rowIndex, $colIndex: e2.$colIndex || false, $rowIndex: e2.$rowIndex || false }), inputs: null, isReference: true };
}
function be(e2, t2) {
const n2 = e2.startsWith("$");
n2 && (e2 = e2.substring(1));
let r2 = parseInt(e2) - 1;
return n2 || r2 === Number.MIN_SAFE_INTEGER || (r2 -= t2.colIndex), { type: "cell", value: Object.freeze({ colIndex: Number.MIN_SAFE_INTEGER, $colIndex: false, rowIndex: r2, $rowIndex: n2 }), inputs: null, isReference: true };
}
function Pe(e2, t2) {
return { type: "function", value: e2 = e2.toUpperCase(), inputs: t2 };
}
function Be(e2, t2) {
return { type: "tableReference", value: e2, inputs: t2 };
}
function Fe(e2) {
return { type: "tableSpecifier", value: e2, inputs: null, isReference: true };
}
function $e(e2, t2, n2, r2 = false) {
const s2 = { type: "infix", value: e2, inputs: [t2, n2] };
return r2 && (s2.isReference = true), s2;
}
function We(e2, t2, n2 = false) {
const r2 = { type: "postfix", value: e2, inputs: [t2] };
return n2 && (r2.isReference = true), r2;
}
function ze(e2, t2, n2 = false) {
const r2 = { type: "prefix", value: e2, inputs: [t2] };
return n2 && (r2.isReference = true), r2;
}
function ke(e2) {
return { type: "named", value: e2, inputs: null, isReference: true };
}
function Ve(e2) {
return { type: "number", value: Number(e2), isLiteral: true };
}
function Ge(e2) {
let t2 = e2;
const n2 = e2 && e2.length > 1 && '"' === e2[0] && '"' === e2[e2.length - 1];
return n2 && (t2 = e2.substring(1, e2.length - 1)), { type: n2 ? "quotedString" : "string", value: t2, isLiteral: true };
}
function qe(e2) {
return { type: "boolean", value: "TRUE" === e2 || "TRUE" === e2.toUpperCase(), isLiteral: true };
}
function je(e2) {
return { type: "error", value: c.getBuiltInByLabel(e2.toUpperCase()), isLiteral: true };
}
function Ye(e2) {
return { type: "error", value: e2 ? c.getBuiltInByLabel(e2.toUpperCase()) : c.BuiltIn.Ref, inputs: null, isReference: true };
}
function De(e2, t2) {
const n2 = function e3(n3, r2) {
const s2 = n3.inputs;
let i2;
if (s2) {
const t3 = s2.length;
for (let r3 = 0; r3 < t3; r3++) {
const t4 = s2[r3], o3 = e3(t4, n3);
o3 !== t4 && (i2 || (i2 = [...s2]), i2[r3] = o3);
}
}
const o2 = i2 ? { ...n3, inputs: i2 } : n3, a2 = t2(o2, r2);
return void 0 === a2 ? o2 : a2;
}(e2, void 0);
return n2 || this;
}
function Ze(e2, t2) {
let r2 = 0, s2 = De(e2, (e3) => {
const t3 = { ...e3 };
return t3.evalIndex = r2++, t3;
});
const i2 = new Array(r2), o2 = /* @__PURE__ */ new Set(), a2 = /* @__PURE__ */ new Map();
let l2;
const u2 = /* @__PURE__ */ new Map(), c2 = [], p2 = [];
s2 = De(s2, (e3, t3) => {
const r3 = e3.type, s3 = e3.evalIndex;
if (i2[s3] = null, e3.isReference) {
const t4 = e3, n2 = { node: e3, index: u2.size, op: null, value: null, inputs: null };
if (u2.set(t4, n2), "cell" === r3) {
const r4 = t4.value;
return r4.$colIndex && (n2.hasHorizontalAbs = true), r4.$rowIndex && (n2.hasVerticalAbs = true), n2.value = a2.size, a2.set(t4, a2.size), o2.add(n2), e3.refIndex = p2.length, void p2.push(n2.index);
}
if ("infix" === r3 || "prefix" === r3 || "postfix" === r3 || "spill" === r3) {
const r4 = t4.inputs, s4 = r4.length, i3 = e3.value;
n2.op = i3;
const a3 = new Array(s4);
n2.inputs = a3;
for (let e4 = 0; e4 < s4; e4++) {
const t5 = r4[e4], s5 = u2.get(t5);
s5 && (s5.hasHorizontalAbs && (n2.hasHorizontalAbs = true), s5.hasVerticalAbs && (n2.hasVerticalAbs = true)), a3[e4] = s5 ? s5.index : -1, o2.delete(s5);
}
if (o2.add(n2), Je.includes(i3)) {
const t5 = r4[0], s5 = !!t5 && "cell" === t5.type, i4 = r4[1], o3 = !!i4 && "cell" === i4.type;
s5 && o3 && (p2.splice(i4.refIndex, 1), i4.refIndex = t5.refIndex, e3.refIndex = t5.refIndex, p2[t5.refIndex] = n2.index);
} else "#" === i3 && (e3.refIndex = r4[0].refIndex);
return void c2.push(e3);
}
if ("error" === r3 || "named" === r3) {
l2 || (l2 = /* @__PURE__ */ new Map());
const s4 = t4.value;
let i3 = l2.get(s4);
return n2.op = r3, void 0 === i3 && (i3 = l2.size, l2.set(s4, i3)), n2.value = i3, o2.add(n2), e3.refIndex = p2.length, void p2.push(n2.index);
}
"tableReference" === r3 && (n2.op = r3), "tableSpecifier" === r3 && (n2.op = r3), "structuredArg" === r3 && (n2.op = r3);
} else if (t3 && t3.isReference) {
const t4 = e3, n2 = { node: e3, index: u2.size, op: "function", value: e3.value, inputs: null };
u2.set(t4, n2);
}
if (e3.isLiteral) if ("array" !== r3) i2[s3] = e3.value;
else {
const t4 = e3.value, r4 = t4.length, o3 = new Array(r4);
for (let e4 = 0; e4 < r4; e4++) {
const n2 = t4[e4].value, r5 = n2.length, s4 = new Array(r5);
for (let e5 = 0; e5 < r5; e5++) {
const t5 = n2[e5];
let r6 = t5.value;
if ("prefix" === t5.type) {
const e6 = t5.value;
r6 = t5.inputs[0].value, "-" === e6 && (r6 = -r6);
}
s4[e5] = r6;
}
o3[e4] = s4;
}
i2[s3] = n(o3);
}
else {
if ("empty" !== r3) return c2.push(e3), e3;
i2[s3] = void 0;
}
});
const f2 = new Array(a2.size);
a2.forEach((e3, t3) => {
const n2 = t3.value, r3 = n2.colIndex, s3 = n2.rowIndex, i3 = n2.$colIndex, o3 = n2.$rowIndex, a3 = { colStart: r3, rowStart: s3, colEnd: r3, rowEnd: s3, $colStart: i3, $rowStart: o3, $colEnd: i3, $rowEnd: o3 };
r3 === Number.MIN_SAFE_INTEGER && (a3.colEnd = Number.MAX_SAFE_INTEGER), s3 === Number.MIN_SAFE_INTEGER && (a3.rowEnd = Number.MAX_SAFE_INTEGER), n2.sheetName && (a3.sheetName = n2.sheetName), f2[e3] = a3;
});
const h2 = f2.length, g2 = new Array(h2);
for (let e3 = 0; e3 < h2; e3++) g2[e3] = { colStart: 0, rowStart: 0, colEnd: 0, rowEnd: 0, sheetName: null };
const d2 = new Array(u2.size);
let m2;
u2.forEach((e3) => {
d2[e3.index] = e3;
}), l2 && (m2 = [], l2.forEach((e3, t3) => {
m2.push(t3);
}));
const E2 = [];
o2.forEach((e3) => {
E2.push(e3.index);
});
const A2 = c2.length;
for (let e3 = 0; e3 < A2; e3++) {
const t3 = c2[e3], n2 = t3.type;
if ("infix" === n2) {
const e4 = t3.value;
t3.fn = ye[e4];
} else if ("prefix" === n2) {
const e4 = t3.value;
t3.fn = we[e4];
} else if ("postfix" === n2) {
const e4 = t3.value;
t3.fn = Ce[e4];
}
}
const N2 = function(e3) {
const t3 = [], n2 = (e4, n3) => {
const r4 = { type: e4.type, value: e4.value };
void 0 !== e4.evalIndex && (r4.evalIndex = e4.evalIndex), void 0 !== e4.refIndex && (r4.refIndex = e4.refIndex), n3 && (r4.ctx = n3), t3.push(r4);
}, r3 = (e4, n3, r4, s4) => {
if (null == n3) return;
if (t3.length > 1 && "whitespace" === e4 && "whitespace" === t3[t3.length - 1].type) return;
const i3 = { type: e4, value: n3 };
r4 && (i3.ctx = r4), void 0 !== s4 && (i3.evalIndex = s4), t3.push(i3);
};
!function e4(t4, s4, i3) {
const o3 = t4.evalIndex ?? i3 ?? 0, a3 = t4.type, l3 = (t5, n3, s5) => {
if (!t5) return;
const i4 = t5.length;
for (let o4 = 0; o4 < i4; o4++) e4(t5[o4], n3, s5), o4 < i4 - 1 && r3("comma", ",", n3);
};
if (t4.isLiteral) {
if (r3("whitespace", t4.wsBefore, s4), "array" === a3) {
r3("type", "{", s4);
const n3 = t4.value, i4 = n3.length;
for (let t5 = 0; t5 < i4; t5++) {
const a4 = n3[t5], l4 = a4.value, u3 = l4.length;
for (let t6 = 0; t6 < u3; t6++) {
const n4 = l4[t6];
r3("whitespace", n4.wsBefore, s4), e4(n4, s4, o3), r3("whitespace", n4.wsAfter, s4), t6 < u3 - 1 && r3("comma", ",", s4);
}
t5 < i4 - 1 && (r3("whitespace", a4.wsBefore, s4), r3("comma", ";", s4), r3("whitespace", a4.wsAfter, s4));
}
t4.error || r3("type", "}", s4);
} else "quotedString" === a3 ? (t4 = { type: a3, value: '"' + t4.value + '"' }, n2(t4, s4)) : n2(t4, s4);
r3("whitespace", t4.wsAfter, s4);
} else if ("infix" === a3) e4(t4.inputs[0], s4, o3), r3("whitespace", t4.wsBefore, s4), n2(t4, s4), r3("whitespace", t4.wsAfter, s4), e4(t4.inputs[1], s4, o3);
else if ("prefix" === a3) r3("whitespace", t4.wsBefore, s4), n2(t4, s4), r3("whitespace", t4.wsAfter, s4), e4(t4.inputs[0], s4, o3);
else if ("postfix" === a3) e4(t4.inputs[0], s4, o3), r3("whitespace", t4.wsBefore, s4), n2(t4, s4), r3("whitespace", t4.wsAfter, s4);
else {
r3("whitespace", t4.wsBefore, s4);
const i4 = t4.inputs;
switch (a3) {
case "function":
n2(t4, s4);
const u3 = { name: String(t4.value), argIndex: -1 };
if (r3("paren", "(", u3, t4.evalIndex), i4) {
const t5 = i4.length;
for (let n3 = 0; n3 < t5; n3++) {
const s5 = { ...u3, argIndex: n3 };
e4(i4[n3], s5, o3), n3 < t5 - 1 && r3("comma", ",", s5);
}
}
t4.error || r3("paren", ")", u3, t4.evalIndex);
break;
case "cell":
n2(t4, s4);
break;
case "paren":
r3(a3, "(", s4, o3), l3(i4, s4, o3), t4.error || r3(a3, ")", s4, o3);
break;
case "squareParen":
r3(a3, "[", s4, o3), l3(i4, s4, o3), t4.error || r3(a3, "]", s4, o3);
break;
case "tableReference":
n2(t4, s4);
const c3 = { name: String(t4.value), argIndex: -1 };
if (r3("paren", "[", c3), i4) {
const t5 = i4.length;
for (let n3 = 0; n3 < t5; n3++) {
const s5 = { ...c3, argIndex: n3 };
e4(i4[n3], s5, o3), n3 < t5 - 1 && r3("comma", ",", s5);
}
}
t4.error || r3("paren", "]", c3);
break;
default:
void 0 !== t4.value && n2(t4, s4), i4 && i4.forEach((t5) => e4(t5, s4, o3));
}
r3("whitespace", t4.wsAfter, s4);
}
}(e3);
const s3 = t3.length;
for (let e4 = 0; e4 < s3; e4++) {
const n3 = t3[e4];
if ("whitespace" === n3.type && void 0 === n3.evalIndex) {
const r4 = t3[e4 + 1];
r4 && void 0 !== r4.evalIndex && (n3.evalIndex = r4.evalIndex);
}
}
return t3;
}(s2);
return { ast: s2, evaluations: i2, executions: c2, precedentsAbsolute: g2, precedentsExecute: d2, precedentsNamed: m2, precedentsRelative: f2, precedentsRoot: E2, references: p2, tokens: N2, error: t2 };
}
function He(e2, t2) {
let n2, r2 = -1, s2 = "";
Number.isSafeInteger(e2.previousToken?.startLine) ? (r2 = e2.previousToken.startLine, n2 = e2.previousToken.endColumn + 1) : Number.isSafeInteger(e2.token?.startLine) && (r2 = e2.token.startLine, n2 = e2.token.startColumn), -1 !== r2 ? (s2 += "\n" + t2.split("\n")[r2 - 1] + "\n", s2 += Array(n2 - 1).fill(" ").join("") + "^\n", s2 += `Error at position ${r2}:${n2}
` + e2.message, e2.errorLocation = { line: r2, column: n2 }) : s2 = t2 + "\n" + e2.message;
const i2 = new c.Parse(s2);
return i2.details = e2, i2;
}
const Ke = function(e2, t2) {
return t2.wsBefore && (e2.wsBefore = t2.wsBefore), t2.wsAfter && (e2.wsAfter = t2.wsAfter), t2.image && (e2.image = t2.image), e2;
}, Qe = "_XLFN.", Xe = Object.freeze([[":", ".:.", ".:", , ":."], ["^"], ["*", "/"], ["+", "-"], ["&"], ["<", ">", "=", "<>", "<=", ">="]]), Je = Object.freeze([":", ".:.", ".:", , ":."]), et = Object.freeze([":", " ", ".:.", ".:", , ":."]), tt = Object.freeze(["@"]), nt = Object.freeze(["#"]), rt = Object.freeze(et.concat(tt).concat(nt)), { String: st, SheetQuoted: it, SingleQuotedString: ot, FunctionToken: at, NamedTableReference: lt, LiteralError: ut, RefError: ct, Cell: pt, Sheet: ft, Name: ht, NumberToken: gt, Boolean: dt, Column: mt, AbsRow: Et, ImplicitIntersectOp: At, Comma: Nt, RangeUnion: It, RangeTrimFull: Ot, RangeTrimLeading: xt, RangeTrimTrailing: St, Semicolon: Lt, OpenParen: Tt, CloseParen: Rt, OpenSquareParen: vt, CloseSquareParen: Ut, OpenCurlyParen: yt, CloseCurlyParen: wt, MulOp: Ct, PlusOp: _t, DivOp: Mt, MinOp: bt, ConcatOp: Pt, ExOp: Bt, PercentOp: Ft, ArrayAnchorOp: $t, TableSpecifier: Wt, BracketedString: zt, NeqOp: kt, GteOp: Vt, LteOp: Gt, GtOp: qt, EqOp: jt, LtOp: Yt } = le;
class Dt extends m {
constructor() {
super(le, { nodeLocationTracking: "full", maxLookahead: 1, skipValidations: true, recoveryEnabled: true }), this.position = { colIndex: 0, rowIndex: 0 }, this.astErrors = [];
const e2 = this, t2 = (t3, n2, r2) => {
let s2;
e2.CONSUME(n2);
const i2 = e2.getLexerPosition();
s2 = e2.ACTION(() => (s2 = { type: t3, value: null, inputs: null }, this._ensureWhitespace(s2, i2, true)));
const o2 = [], a2 = e2.SUBRULE(e2.intersectOp);
a2 && o2.push(a2);
const l2 = e2.SUBRULE(e2.group), u2 = e2.OPTION(() => this.CONSUME(r2));
return s2 = e2.ACTION(() => {
if (l2) for (let e3 = 0; e3 < l2.length; e3++) o2.push(l2[e3]);
return s2 && (u2 || this._reportError(s2, "Missing closing parenthesis", i2), s2.inputs = o2), this._ensureWhitespace(s2, e2.getLexerPosition(), false, true);
}), s2;
};
e2.RULE("infixOp", () => {
const t3 = [], n2 = [e2.SUBRULE(e2.postfixOp)];
return e2.MANY(() => {
const r2 = e2.OR(e2.c1 || (e2.c1 = [{ ALT: () => e2.CONSUME(It).image }, { ALT: () => e2.CONSUME(_t).image }, { ALT: () => e2.CONSUME(bt).image }, { ALT: () => e2.CONSUME(Ct).image }, { ALT: () => e2.CONSUME(Mt).image }, { ALT: () => e2.CONSUME(Bt).image }, { ALT: () => e2.CONSUME(Pt).image }, { ALT: () => e2.CONSUME(qt).image }, { ALT: () => e2.CONSUME(jt).image }, { ALT: () => e2.CONSUME(Yt).image }, { ALT: () => e2.CONSUME(kt).image }, { ALT: () => e2.CONSUME(Vt).image }, { ALT: () => e2.CONSUME(Gt).image }, { ALT: () => e2.CONSUME(Ot).image }, { ALT: () => e2.CONSUME(xt).image }, { ALT: () => e2.CONSUME(St).image }]));
t3.push([r2, e2.getLexerPosition(), rt.includes(r2)]), n2.push(e2.SUBRULE2(e2.postfixOp));
}), e2.ACTION(() => {
let e3 = t3.length;
const r2 = Xe.length;
for (let s2 = 0; e3 > 0 && s2 < r2; s2++) {
const r3 = Xe[s2];
let i2 = t3.length;
for (let s3 = 0; s3 < i2; s3++) {
const o2 = t3[s3], a2 = o2[0];
if (!r3.includes(a2)) continue;
let l2 = $e(a2, n2[s3], n2[s3 + 1], o2[2]);
l2 = this._ensureWhitespace(l2, o2[1]), t3.splice(s3, 1), n2.splice(s3, 2, l2), s3--, i2--, e3--;
}
}
}), n2[0];
}), e2.RULE("plusMinusOp", () => e2.OR([{ ALT: () => e2.CONSUME(_t).image }, { ALT: () => e2.CONSUME(bt).image }])), e2.RULE("postfixOp", () => {
let t3 = e2.SUBRULE(e2.prefixOp);
const n2 = [];
return e2.MANY(() => {
const t4 = e2.OR([{ ALT: () => e2.CONSUME(Ft).image }, { ALT: () => e2.CONSUME($t).image }]);
e2.ACTION(() => {
n2.push([t4, e2.getLexerPosition()]);
});
}), e2.ACTION(() => {
const e3 = n2.length;
if (0 !== e3) for (let r2 = 0; r2 < e3; r2++) {
const e4 = n2[r2], s2 = e4[0], i2 = e4[1], o2 = rt.includes(s2);
t3 = We(s2, t3, o2), t3 = this._ensureWhitespace(t3, i2);
}
}), t3;
}), e2.RULE("prefixOp", () => {
const t3 = [];
e2.MANY(() => {
const n3 = e2.OR([{ ALT: () => e2.CONSUME(_t).image }, { ALT: () => e2.CONSUME(bt).image }, { ALT: () => e2.CONSUME(At).image }]);
e2.ACTION(() => {
t3.push([n3, e2.getLexerPosition()]);
});
});
let n2 = e2.SUBRULE(e2.formula);
return e2.ACTION(() => {
const e3 = t3.length;
if (0 !== e3) for (let r2 = e3 - 1; r2 >= 0; r2--) {
const e4 = t3[r2], s2 = e4[0], i2 = e4[1], o2 = rt.includes(s2);
n2 = ze(s2, n2, o2), n2 = this._ensureWhitespace(n2, i2);
}
}), n2;
}), e2.RULE("intersectOp", () => {
const t3 = [e2.SUBRULE(e2.infixOp)];
return e2.MANY(() => {
e2.OPTION({ GATE: () => {
const t4 = e2.LA(0);
return e2.LA(1).startOffset > t4.endOffset + 1;
}, DEF: () => {
t3.push(e2.SUBRULE3(e2.infixOp));
} });
}), e2.ACTION(() => {
for (; t3.length > 1; ) {
let e3 = t3.length - 1;
for (let n2 = 0; n2 < e3; n2++) {
const r2 = t3[n2], s2 = t3[n2 + 1], i2 = $e(" ", r2, s2, true);
if (delete r2.wsAfter, s2.wsBefore) {
const e4 = s2.wsBefore.slice(0, -1), t4 = e4.length;
delete s2.wsBefore, t4 > 0 && (i2.wsBefore = e4);
}
n2 + 1 < e3 && delete s2.wsAfter, t3.splice(n2, 2, i2), n2--, e3--;
}
}
}), t3[0];
}), e2.RULE("formula", () => e2.OR9([{ ALT: () => e2.SUBRULE(e2.referenceWithoutInfix) }, { ALT: () => e2.SUBRULE(e2.function) }, { ALT: () => e2.SUBRULE(e2.paren) }, { ALT: () => e2.SUBRULE(e2.namedTableReference) }, { ALT: () => e2.SUBRULE(e2.bracketedString) }, { ALT: () => e2.SUBRULE(e2.squareParen) }, { ALT: () => e2.SUBRULE(e2.literal) }, { ALT: () => e2.SUBRULE(e2.literalArray) }])), e2.RULE("group", () => {
const t3 = [];
return e2.MANY(() => {
e2.CONSUME(Nt);
const n2 = e2.SUBRULE2(e2.intersectOp);
e2.ACTION(() => {
t3.push(n2);
});
}), t3;
}), e2.RULE("paren", () => t2("paren", Tt, Rt)), e2.RULE("literalArray", () => {
let t3 = { type: "row", value: [], isLiteral: true };
e2.CONSUME(yt);
const n2 = e2.getLexerPosition();
let r2 = e2.ACTION(() => this._ensureWhitespace({ type: "array", value: [t3], isLiteral: true }, n2, true));
const s2 = e2.SUBRULE(e2.literalForArray);
e2.ACTION(() => {
t3.value.push(s2);
}), e2.MANY(() => {
const n3 = e2.OR([{ ALT: () => e2.CONSUME(Nt).image }, { ALT: () => e2.CONSUME(Lt).image }]), s3 = e2.SUBRULE2(e2.literalForArray);
e2.ACTION(() => {
"," === n3 || (t3 = { type: "row", value: [], isLiteral: true }, r2.value.push(t3)), t3.value.push(s3);
});
});
const i2 = e2.OPTION(() => this.CONSUME(wt));
return r2 = e2.ACTION(() => (i2 || this._reportError(r2, "Missing closing parenthesis '}'", n2), this._ensureWhitespace(r2, e2.getLexerPosition(), false, true))), r2;
}), e2.RULE("literalForArray", () => e2.OR([{ ALT: () => {
const t3 = e2.OPTION(() => e2.SUBRULE(e2.plusMinusOp)), n2 = e2.CONSUME(gt), r2 = e2.ACTION(() => this._ensureWhitespace(Ve(n2.image), e2.getLexerPosition()));
return t3 ? e2.ACTION(() => /* @__PURE__ */ function(e3, t4) {
return { type: "prefix", value: e3, inputs: [t4] };
}(t3, r2)) : r2;
} }, { ALT: () => {
const t3 = e2.CONSUME(st);
return e2.ACTION(() => this._ensureWhitespace(Ge(t3.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t3 = e2.CONSUME(dt);
return e2.ACTION(() => this._ensureWhitespace(qe(t3.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t3 = e2.CONSUME(ut);
return e2.ACTION(() => this._ensureWhitespace(je(t3.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t3 = e2.CONSUME(ct);
return e2.ACTION(() => this._ensureWhitespace(Ye(t3.image), e2.getLexerPosition()));
} }])), e2.RULE("literal", () => e2.OR([{ ALT: () => {
const t3 = e2.CONSUME(gt);
return e2.ACTION(() => this._ensureWhitespace(Ve(t3.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t3 = e2.CONSUME(st);
return e2.ACTION(() => this._ensureWhitespace(Ge(t3.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t3 = e2.CONSUME(dt);
return e2.ACTION(() => this._ensureWhitespace(qe(t3.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t3 = e2.CONSUME(ut);
return e2.ACTION(() => this._ensureWhitespace(je(t3.image), e2.getLexerPosition()));
} }])), e2.RULE("function", () => {
const t3 = e2.CONSUME(at).image.slice(0, -1), n2 = e2.getLexerPosition(), r2 = e2.SUBRULE(e2.functionArguments);
let s2 = e2.ACTION(() => this._ensureWhitespace(Pe(t3, r2), n2, true));
const i2 = e2.OPTION(() => this.CONSUME(Rt));
return s2 = e2.ACTION(() => (i2 || this._reportError(s2, "Missing closing parenthesis ')'", n2), this._ensureWhitespace(s2, e2.getLexerPosition(), false, true))), s2;
}), e2.RULE("functionArguments", () => {
const t3 = [];
return e2.MANY2(() => {
let n2;
e2.CONSUME2(Nt), n2 = e2.ACTION(() => this._ensureWhitespace({ type: "empty", value: "" }, e2.getLexerPosition(), false, true)), t3.push(n2);
}), e2.OPTION(() => {
t3.push(e2.SUBRULE(e2.intersectOp)), e2.MANY(() => {
let n2;
e2.CONSUME1(Nt), n2 = e2.ACTION(() => this._ensureWhitespace({ type: "empty", value: "" }, e2.getLexerPosition(), false, true)), t3.push(n2), e2.OPTION3(() => {
t3.pop(), t3.push(e2.SUBRULE2(e2.intersectOp));
});
});
}), t3;
}), e2.RULE("bracketedString", () => {
const t3 = e2.CONSUME(zt), n2 = e2.getLexerPosition();
return e2.ACTION(() => {
const r2 = t3.image;
let s2 = Be("", [Fe(r2.substring(1, r2.length - 1))]);
return s2 = this._ensureWhitespace(s2, n2, true, false), s2 = this._ensureWhitespace(s2, e2.getLexerPosition(), false, true), s2;
});
}), e2.RULE("squareParen", () => {
e2.CONSUME(vt);
const t3 = e2.getLexerPosition();
let n2 = Be("", [e2.SUBRULE(e2.structuredArgument)]);
const r2 = e2.OPTION(() => this.CONSUME(Ut));
return e2.ACTION(() => {
r2 || this._reportError(n2, "Missing closing parenthesis ']'", t3), n2 = this._ensureWhitespace(n2, t3, true, false), n2 = this._ensureWhitespace(n2, e2.getLexerPosition(), false, true);
}), n2;
}), e2.RULE("namedTableReference", () => {
const t3 = e2.CONSUME(lt).image.slice(0, -1), n2 = e2.getLexerPosition(), r2 = e2.SUBRULE(e2.structuredArguments);
let s2 = e2.ACTION(() => this._ensureWhitespace(Be(t3, r2), n2, true));
const i2 = e2.OPTION(() => this.CONSUME(Ut));
return s2 = e2.ACTION(() => (i2 || this._reportError(s2, "Missing closing parenthesis ']'", n2), this._ensureWhitespace(s2, e2.getLexerPosition(), false, true))), s2;
}), e2.RULE("structuredArguments", () => {
const t3 = [];
return e2.MANY2(() => {
e2.CONSUME2(Nt), e2.ACTION(() => {
t3.push(this._ensureWhitespace({ type: "empty", value: "" }, e2.getLexerPosition(), false, true));
});
}), e2.OPTION(() => {
const n2 = e2.SUBRULE(e2.structuredArgument);
e2.ACTION(() => {
n2 && t3.push(n2);
}), e2.MANY(() => {
e2.CONSUME1(Nt), e2.OPTION3(() => {
let n3 = e2.SUBRULE2(e2.structuredArgument);
e2.ACTION(() => {
n3 || (n3 = this._ensureWhitespace({ type: "empty", value: "" }, e2.getLexerPosition(), false, true)), t3.push(n3);
});
});
});
}), t3;
}), e2.RULE("structuredArgument", () => {
const t3 = e2.OPTION(() => e2.CONSUME(At)), n2 = e2.getLexerPosition(), r2 = e2.OPTION2(() => this.CONSUME(vt));
let s2 = e2.OR([{ ALT: () => {
const t4 = e2.CONSUME(Wt);
return e2.ACTION(() => this._ensureWhitespace(Fe(t4.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t4 = e2.CONSUME(zt);
return e2.ACTION(() => this._ensureWhitespace(Fe(t4.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t4 = e2.CONSUME(ht);
return e2.ACTION(() => this._ensureWhitespace(ke(t4.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t4 = e2.CONSUME(ot);
return e2.ACTION(() => this._ensureWhitespace(Ge(t4.image), e2.getLexerPosition()));
} }]);
if (r2) {
const t4 = e2.OPTION3(() => this.CONSUME(Rt));
e2.ACTION(() => (t4 || this._reportError(s2, "Missing closing parenthesis ']'", n2), this._ensureWhitespace(s2, e2.getLexerPosition(), false, true))), s2 = { type: "structuredArg", value: null, inputs: [s2] };
}
return e2.ACTION(() => {
t3 && (s2 = ze(t3.image, s2, true), s2 = this._ensureWhitespace(s2, e2.getLexerPosition()));
}), s2;
}), e2.RULE("referenceWithoutInfix", () => e2.OR([{ ALT: () => e2.SUBRULE(e2.reference) }, { ALT: () => {
const t3 = e2.SUBRULE(e2.prefixSheetName), n2 = e2.SUBRULE2(e2.formula);
return e2.ACTION(() => {
if ((e3 = n2) && e3.isFormulaError) return n2;
var e3;
n2.ref && (n2.ref.sheet = t3);
}), n2;
} }])), e2.RULE("reference", () => {
const t3 = e2.OPTION4(() => e2.CONSUME(At));
let n2 = e2.OR([{ ALT: () => {
const t4 = e2.CONSUME(pt), n3 = e2.getLexerPosition(), r2 = e2.OPTION(() => e2.CONSUME($t));
return e2.ACTION(() => {
const s2 = this._ensureWhitespace(function(e3, t5) {
const n4 = e3.match(/([$]?)([A-Za-z]{1,3})([$]?)([1-9][0-9]*)/);
let r3 = _e(n4[2]) - 1;
const s3 = 1 === n4[1].length;
let i2 = +n4[4] - 1;
const o2 = 1 === n4[3].length;
return s3 || r3 === Number.MIN_SAFE_INTEGER || (r3 -= t5.colIndex), o2 || i2 === Number.MIN_SAFE_INTEGER || (i2 -= t5.rowIndex), { type: "cell", value: Object.freeze({ colIndex: r3, rowIndex: i2, $colIndex: s3, $rowIndex: o2 }), inputs: null, isReference: true };
}(t4.image, e2.position), n3);
return r2 ? this._ensureWhitespace(We("#", s2, true), n3) : s2;
});
} }, { ALT: () => {
const t4 = e2.CONSUME(ht);
return e2.ACTION(() => this._ensureWhitespace(ke(t4.image), e2.getLexerPosition()));
} }, { ALT: () => {
const t4 = e2.CONSUME(mt);
return e2.ACTION(() => this._ensureWhitespace(function(e3, t5) {
const n3 = e3.startsWith("$");
n3 && (e3 = e3.substring(1));
let r2 = _e(e3) - 1;
return n3 || r2 === Number.MIN_SAFE_INTEGER || (r2 -= t5.colIndex), { type: "cell", value: Object.freeze({ colIndex: r2, rowIndex: Number.MIN_SAFE_INTEGER, $colIndex: n3, $rowIndex: false }), inputs: null, isReference: true };
}(t4.image, e2.position), e2.getLexerPosition()));
} }, { ALT: () => {
const t4 = e2.CONSUME(Et);
return e2.ACTION(() => this._ensureWhitespace(be(t4.image, e2.position), e2.getLexerPosition()));
} }, { ALT: () => {
const t4 = e2.CONSUME(ct);
return e2.ACTION(() => this._ensureWhitespace(Ye(t4.image), e2.getLexerPosition()));
} }]);
return e2.ACTION(() => {
t3 && (n2 = ze(t3, n2, true), n2 = this._ensureWhitespace(n2, e2.getLexerPosition()));
}), n2;
}), e2.RULE("prefixSheetName", () => e2.OR([{ ALT: () => e2.CONSUME(ft).image.slice(0, -1) }, { ALT: () => e2.CONSUME(it).image.slice(1, -2).replace(/''/g, "'") }])), e2.performSelfAnalysis();
}
_reportError(e2, t2, n2 = void 0, r2 = "SyntaxError") {
void 0 === n2 && (n2 = this.getLexerPosition()), e2.error = true, this.astErrors.push({ name: r2, message: t2, previousToken: this.input[n2], ast: e2 });
}
_ensureWhitespace(e2, t2, n2 = false, r2 = false) {
if (!e2) return console.warn("node is null"), e2;
const s2 = this.input, i2 = s2[t2];
if (e2.image || (e2.image = i2.image), !r2) {
const n3 = i2.startOffset, r3 = s2[t2 - 1], o2 = r3?.endOffset ?? -1;
o2 + 1 < n3 && (e2.wsBefore = " ".repeat(n3 - o2 - 1));
}
if (!n2) {
const n3 = i2.endOffset, r3 = s2[t2 + 1], o2 = r3?.startOffset ?? this.inputTextLength;
n3 + 1 < o2 && (e2.wsAfter = " ".repeat(o2 - n3 - 1));
}
return e2;
}
_createAST(e2, t2) {
const n2 = function(e3) {
const t3 = ae.tokenize(e3);
if (t3.errors.length > 0) {
const n3 = t3.errors[0], r3 = n3.line, s3 = n3.column;
let i3 = "\n" + e3.split("\n")[r3 - 1] + "\n";
throw i3 += Array(s3 - 1).fill(" ").join("") + "^\n", n3.message = i3 + `Error at position ${r3}:${s3}
` + n3.message, n3.errorLocation = { line: r3, column: s3 }, new c.Parse(n3.message, { line: r3, column: s3, offset: n3.offset, length: n3.length });
}
return t3;
}(t2);
let r2;
if (!n2) return r2 = { type: "text", value: t2 }, r2;
const s2 = n2.tokens;
this.input = s2, this.inputTextLength = t2.length;
const i2 = e2.getPosition();
return this.position = i2, this.astErrors = [], this.reset(), r2 = this.intersectOp(), r2 = De(r2, (e3, t3) => {
let n3 = e3.type;
if ("function" === n3 && e3.value && e3.value.toUpperCase().startsWith(Qe)) {
const t4 = e3.value.substring(6);
let r4 = e3.image.substring(6), s3 = e3;
"ANCHORARRAY" === t4 ? (s3 = We("#", e3.inputs[0], true), r4 = "#") : "SINGLE" === t4 ? (s3 = ze("@", e3.inputs[0], true), r4 = "@") : s3 = Pe(t4, e3.inputs), Ke(s3, e3), s3.image = r4, n3 = (e3 = s3).type;
}
const r3 = t3?.isReference;
if (r3) {
const n4 = t3.value;
if ((":" === n4 || ".:." === n4 || ".:" === n4 || ":." === n4) && Number.isInteger(e3.value)) {
const n5 = t3.inputs[0] === e3 ? t3.inputs[1] : t3.inputs[0];
if (n5 && Number.isInteger(n5.value)) {
const t4 = be(e3.image, i2);
return Ke(t4, e3), t4;
}
}
} else if ("cell" === n3) {
const t4 = e3.value;
if (t4.rowIndex === Number.MIN_SAFE_INTEGER || t4.colIndex >= 16384) {
const t5 = ke(e3.image);
return Ke(t5, e3), t5;
}
}
return e3;
}), r2;
}
build(e2, t2) {
if (0 === t2.length) throw Error("Input must not be empty.");
let n2, r2, s2;
try {
n2 = this._createAST(e2, t2);
} catch (e3) {
s2 = e3 instanceof c.Parse ? e3 : new c.Parse(e3.message, e3);
}
const i2 = this.errors;
if (i2.length > 0) {
s2 = He(i2[0], t2);
}
const o2 = this.astErrors;
if (o2.length > 0) {
s2 = He(o2[0], t2);
}
return r2 = n2 ? Ze(n2, s2) : { ast: null, evaluations: h.EmptyArray, executions: h.EmptyArray, precedentsAbsolute: h.EmptyArray, precedentsExecute: h.EmptyArray, precedentsNamed: null, precedentsRelative: h.EmptyArray, precedentsRoot: h.EmptyArray, references: h.EmptyArray, tokens: h.EmptyArray, error: s2 }, r2;
}
}
class Zt {
constructor(e2, t2) {
this._options = e2, this._compiled = t2;
}
getTextAt(e2, t2, n2 = false) {
return n2 ? s(this._compiled.tokens) : r(this._compiled.tokens, e2, t2);
}
getTokens() {
return this._compiled.tokens;
}
getError() {
return this._compiled.error ?? null;
}
isEquals(e2) {
if (!(e2 && e2 instanceof Zt)) return false;
if (this === e2) return true;
const t2 = this._compiled.tokens, n2 = e2._compiled.tokens;
if (t2.length !== n2.length) return false;
return s(t2) === s(n2);
}
getReferences() {
const e2 = this._compiled, t2 = e2.references, n2 = t2.length;
if (0 === n2) return h.EmptyArray;
const r2 = e2.precedentsExecute, s2 = e2.precedentsRelative, i2 = new Array(n2);
for (let o2 = 0; o2 < n2; o2++) {
const n3 = r2[t2[o2]], a2 = n3.inputs;
if (a2 && 2 === a2.length) {
const e3 = s2[r2[a2[0]].value], t3 = s2[r2[a2[1]].value];
i2[o2] = { colStart: e3.colStart, rowStart: e3.rowStart, colEnd: t3.colEnd, rowEnd: t3.rowEnd, $colStart: e3.$colStart, $rowStart: e3.$rowStart, $colEnd: t3.$colEnd, $rowEnd: t3.$rowEnd, sheetName: e3.sheetName };
} else if ("cell" === n3.node.type) {
const e3 = s2[n3.value];
i2[o2] = { ...e3 };
} else if ("named" === n3.op) {
const t3 = e2.precedentsNamed;
i2[o2] = t3[n3.value];
} else "error" === n3.op && (i2[o2] = n3.node.value);
}
return i2;
}
setReferenceAt(e2, t2) {
const n2 = this._compiled, r2 = n2.references;
if (0 === r2.length) return h.EmptyArray;
const s2 = n2.precedentsExecute, i2 = r2[e2];
if (void 0 === i2) throw new Error(`Invalid reference index: ${e2}`);
const o2 = s2[i2], a2 = o2.node, l2 = a2.inputs ?? h.EmptyArray;
let u2, c2, p2 = false;
t2 && (u2 = { colIndex: t2.colStart, rowIndex: t2.rowStart, $colIndex: t2.$colStart ?? false, $rowIndex: t2.$rowStart ?? false }, t2.sheetName && (u2.sheetName = t2.sheetName), p2 = !f.isSingleCell(t2), p2 && (c2 = { colIndex: t2.colEnd, rowIndex: t2.rowEnd, $colIndex: t2.$colEnd ?? false, $rowIndex: t2.$rowEnd ?? false }, t2.colEnd === Number.MAX_SAFE_INTEGER && (c2.colIndex = Number.MIN_SAFE_INTEGER), t2.rowEnd === Number.MAX_SAFE_INTEGER && (c2.rowIndex = Number.MIN_SAFE_INTEGER)));
const g2 = 2 === l2.length;
let d2 = -1, m2 = -1;
if (g2) d2 = l2[0].evalIndex, m2 = l2[1].evalIndex;
else {
if ("cell" !== a2.type) throw "named" === o2.op ? new Error("Cannot setReference for a named reference") : new Error(`Invalidate reference index: ${e2}`);
d2 = a2.evalIndex;
}
const E2 = this._compiled.ast, A2 = De(E2, (e3) => {
if (!e3 || !e3.isReference) return;
const n3 = e3.type;
if (!t2 && Je.includes(e3.value)) {
const e4 = l2[0], t3 = l2[1];
let n4 = e4.evalIndex === d2, r4 = t3.evalIndex === m2;
if (n4 || r4) {
const e5 = Ye();
return e5.image = "#REF!", e5;
}
}
if (!("cell" === n3 || "error" === n3)) return;
const r3 = e3.evalIndex;
let s3, i3 = r3 === d2;
if (i3 || r3 === m2) {
if (t2) if (g2 === p2) {
let t3 = i3 ? u2 : c2;
s3 = { ...e3 }, s3.value = t3, s3.image = null;
} else s3 = p2 ? $e(":", Me(u2), Me(c2), true) : Me(u2);
else s3 = Ye(), s3.image = "#REF!";
return s3;
}
});
if (A2 === E2) return this;
const N2 = Ze(A2, this._compiled.error), I2 = this._options;
return new Zt(I2, N2);
}
_resolveNamed(e2, t2, n2, r2) {
const s2 = this._options?.getNamed;
if (!s2) return c.BuiltIn.Name;
let o2 = s2?.(e2, this._options.getSheetName?.())?.[0];
return o2 ? (o2.isFormulaError || (o2 = i(o2, t2, n2, r2)), o2) : c.BuiltIn.Name;
}
getDirectPrecedentsAt(e2, t2, n2 = false, r2, s2) {
const o2 = this._compiled, a2 = o2.precedentsRoot, l2 = a2.length;
if (0 === l2) return h.EmptyArray;
const u2 = o2.precedentsRelative, p2 = o2.precedentsAbsolute, g2 = u2.length;
for (let n3 = 0; n3 < g2; n3++) {
const r3 = u2[n3];
let s3 = p2[n3], o3 = i(r3, e2, t2, s3);
p2[n3] = o3;
}
let d2 = false;
const m2 = o2.precedentsExecute, E2 = m2.length, A2 = Ht;
for (let n3 = 0; n3 < E2; n3++) {
const r3 = m2[n3], s3 = r3.op;
if (!s3) {
const e3 = p2[r3.value];
A2[r3.index] = e3;
continue;
}
if ("named" === s3) {
d2 = true, A2[r3.index] = this._resolveNamed(r3.node.value, e2, t2);
continue;
}
if ("error" === s3) {
A2[r3.index] = r3.node.value;
continue;
}
if ("@" === s3 || "#" === s3) {
A2[r3.index] = A2[r3.inputs[0]];
continue;
}
const i2 = r3.inputs;
if (!i2) continue;
let o3 = A2[i2[0]];
if (void 0 === o3) {
A2[r3.index] = c.BuiltIn.Value;
continue;
}
if (o3.isFormulaError) {
A2[r3.index] = o3;
continue;
}
let a3, l3 = A2[i2[1]];
void 0 !== l3 ? l3.isFormulaError ? A2[r3.index] = l3 : (" " === s3 ? a3 = f.intersectRanges(o3, l3) : ":" !== s3 && ".:." !== s3 && ":." !== s3 && ".:" !== s3 || (a3 = A2[r3.index] = f.unionRanges(o3, l3)), A2[r3.index] = a3 ?? c.BuiltIn.Null) : A2[r3.index] = c.BuiltIn.Value;
}
const N2 = new Array(l2);
for (let e3 = 0; e3 < l2; e3++) {
const t3 = a2[e3], n3 = A2[t3];
if (N2[e3] = void 0 !== n3?.rowStart ? { ...n3 } : n3, r2 || s2) {
const i2 = m2[t3];
d2 && "named" === i2.op ? (r2 && (r2[e3] = n3.$colStart || n3.$colEnd), s2 && (s2[e3] = n3.$rowStart || n3.$rowEnd)) : (r2 && (r2[e3] = i2.hasVerticalAbs), s2 && (s2[e3] = i2.hasHorizontalAbs));
}
}
return N2;
}
evaluate(e2, t2, n2) {
const r2 = e2.getPosition(), s2 = r2?.rowIndex ?? 0, o2 = r2?.colIndex ?? 0;
let a2 = this._compiled;
if (void 0 !== t2) {
let e3;
if (De(a2.ast, (n3) => {
n3.evalIndex === t2 && (e3 = n3);
}), !e3) throw new Error(`Invalid evalIndex: ${t2}`);
a2 = Ze(e3, a2.error);
}
if (a2.error) return a2.error;
const u2 = a2.evaluations, p2 = a2.executions;
let f2, h2;
n2 || (n2 = this._resolvePrecedents(e2));
const g2 = a2.precedentsExecute, d2 = a2.precedentsRelative, m2 = a2.precedentsAbsolute, E2 = g2.length;
for (let t3 = 0; t3 < E2; t3++) {
const n3 = g2[t3], r3 = n3.op;
if (r3) {
if ("named" === r3) {
const t4 = n3.node;
let r4 = this._resolveNamed(n3.node.value, s2, o2);
void 0 !== r4?.colStart && (r4 = e2.getReference(r4)), u2[t4.evalIndex] = r4;
} else if ("error" === r3) {
const e3 = n3.node;
u2[e3.evalIndex] = n3.node.value;
}
} else {
const e3 = d2[n3.value];
let r4 = m2[t3];
const a3 = i(e3, s2, o2, r4), l2 = n3.node;
u2[l2.evalIndex] = a3;
}
}
const A2 = a2.precedentsRoot, N2 = A2.length;
if (N2 !== n2.length) return c.BuiltIn.Parse;
for (let e3 = 0; e3 < N2; e3++) {
const t3 = g2[A2[e3]].node;
let r3 = n2[e3];
r3.isIRange && "cell" === t3.type && r3.size > 1 && (r3 = r3.getValueAt(0, 0) ?? null), u2[t3.evalIndex] = r3;
}
let I2;
const O2 = (t3) => {
const n3 = t3.inputs, r3 = n3 ? n3.length : 0;
let s3;
switch (t3.type) {
case "infix":
const i2 = t3.value;
let o3 = u2[n3[0].evalIndex], a3 = u2[n3[1].evalIndex];
if ("+" === i2 && "number" == typeof o3 && "number" == typeof a3) {
const e3 = o3 + a3;
return Math.abs(e3) < 99e-14 ? 0 : e3;
}
if ("-" === i2 && "number" == typeof o3 && "number" == typeof a3) {
const e3 = o3 - a3;
return Math.abs(e3) < 99e-14 ? 0 : e3;
}
if (o3 && o3.isFormulaError) return o3;
if (a3 && a3.isFormulaError) return a3;
const p3 = t3.fn;
return s3 = p3 ? p3(e2, o3, a3) : c.BuiltIn.Value, s3 = l(s3, null), s3;
case "function":
I2 || (I2 = new Array(r3)), I2.length !== r3 && (I2.length = r3);
for (let e3 = 0; e3 < r3; e3++) I2[e3] = u2[n3[e3].evalIndex];
return s3 = this._callFunction(e2, t3, I2), s3 && "function" == typeof s3.then ? s3.then((n4) => {
n4 = l(n4, e2), s3 instanceof c.Known && (h2 = s3), u2[t3.evalIndex] = n4;
}).catch((e3) => {
const n4 = e3 instanceof c.Known ? e3 : new c.Value("Uncaught error", { cause: e3 });
u2[t3.evalIndex] = n4;
}) : s3 instanceof c.Known && (h2 = s3), s3;
case "prefix":
case "postfix":
let f3 = u2[n3[0].evalIndex];
if (f3 && f3.isFormulaError) return f3;
const g3 = t3.fn;
return s3 = g3 ? g3(e2, f3) : c.BuiltIn.Value, s3;
case "paren":
if (1 === r3) return u2[n3[0].evalIndex];
{
const e3 = new Array(r3);
for (let t4 = 0; t4 < r3; t4++) e3[t4] = u2[n3[t4].evalIndex];
return e3;
}
case "named":
return null;
case "empty":
return;
}
};
let x2 = p2.length;
for (let e3 = 0; e3 < x2; e3++) {
const t3 = p2[e3];
if (h2) return h2;
if (f2) f2 = f2.then(() => {
const e4 = O2(t3);
return u2[t3.evalIndex] = e4, e4;
});
else {
const e4 = O2(t3);
u2[t3.evalIndex] = e4, e4 && "function" == typeof e4.then && (f2 = e4);
}
}
if (f2) return f2.then(() => {
const t3 = u2[u2.length - 1];
return this._finalizeReturnValue(e2, t3);
});
const S2 = u2[u2.length - 1];
return this._finalizeReturnValue(e2, S2);
}
_resolvePrecedents(e2) {
const t2 = e2.getPosition(), n2 = t2?.rowIndex ?? 0, r2 = t2?.colIndex ?? 0;
const s2 = this.getDirectPrecedentsAt(n2, r2), i2 = s2.length;
let o2;
if (i2 > 0) {
o2 = new Array(i2);
for (let t3 = 0; t3 < i2; t3++) {
const n3 = s2[t3];
if (n3 instanceof c.Known) o2[t3] = n3;
else if (Array.isArray(n3)) {
const r3 = new Array(n3.length);
for (let t4 = 0; t4 < n3.length; t4++) r3[t4] = e2.getReference(n3[t4]);
o2[t3] = r3;
} else o2[t3] = e2.getReference(n3);
}
} else o2 = h.EmptyArray;
return o2;
}
wrapImplicit(e2, t2, n2) {
const r2 = this._compiled.ast;
if (!r2 || !r2.isReference) return this;
if ("cell" === r2.type) return this;
if ("@" === r2.value) return this;
if (!n2) return this;
const s2 = o(t2) + a(e2);
if (n2.has(s2)) return this;
const i2 = Ze(ze("@", r2, true), this._compiled.error);
return new Zt(this._options, i2);
}
_callFunction(e2, t2, n2) {
const r2 = t2?.cacheFn ?? e2.getFunction(t2.value);
if (!r2) return new c.Parse();
const s2 = r2.isBuiltIn();
let i2;
s2 ? t2.cacheFn = r2 : this._context = e2;
try {
i2 = r2.execute(...n2);
} catch (e3) {
i2 = e3 instanceof c.Known ? e3 : new c.Value(e3.message, { cause: e3 });
}
return s2 || (this._context = null), void 0 === i2 ? new c.Parse() : i2;
}
_finalizeReturnValue(e2, t2) {
if (t2 && void 0 !== t2.colStart && (t2 = e2.getValueAt(t2.rowStart, t2.colStart)), Array.isArray(t2)) if (1 === t2.length && Array.isArray(t2[0]) && 1 === t2[0].length) t2 = t2[0][0], Array.isArray(t2) && (t2 = c.BuiltIn.Value);
else try {
t2 = e2.getRange(t2);
} catch (e3) {
t2 = c.BuiltIn.Value;
}
return t2?.isIRange ? 1 === t2.size ? (t2 = t2.getValueAt(0, 0, Kt), null === (t2 = l(t2, e2)) && (t2 = 0)) : t2 = t2.fillEmpty(0) : null === (t2 = l(t2, e2)) && (t2 = 0), t2;
}
get [Symbol.toStringTag]() {
return "[FormulaBlock]";
}
toString() {
const e2 = this._compiled;
if (e2.error) return e2.error.toString();
const t2 = this._context;
if (t2) {
const e3 = t2.getPosition();
return this.getTextAt(e3.rowIndex, e3.colIndex);
}
return s(e2.tokens);
}
}
const Ht = new Array(20);
for (let e2 = 0; e2 < Ht.length; e2++) Ht[e2] = { colStart: 0, rowStart: 0, colEnd: 0, rowEnd: 0, sheetName: null };
const Kt = { type: null };
class Qt {
constructor(e2) {
this._options = { getEntireCoords: u, ...e2 }, this._astBuilder = new Dt();
}
parse(e2, t2) {
const n2 = e2.getPosition();
n2.sheetName;
const r2 = this._astBuilder.build(e2, t2);
return new Zt(this._options, r2);
}
eval(e2, t2) {
return this.parse(e2, t2).evaluate(e2);
}
}
export {
Qt as FormulaParser
};