@sheetxl/sdk 0.1.98

package/build/node/esm/CNOiP4baOWSizP6F.mjs

@@ -0,0 +1,1070 @@
+/**
+ * @license @sheetxl/sdk - A high-performance, embeddable spreadsheet engine. - v0.0.0
+ *
+ * (C) 2025-present SheetXL Inc. & Michael T. Ford
+ * License: The license can be found at https://www.sheetxl.com/license.
+ */
+import { FormulaError as e, CoordUtils as t, c as n, ScalarType as r, t as s, g as i, CommonUtils as o, a, b as l, d as u, e as c, r as p, m as f, f as h } from "./index.mjs";
+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: r.Number, coerce: true, includeBoolean: true, includeMistyped: true, mismatchFill: e.BuiltIn.NA }, Se = { type: r.String, coerce: true, includeMistyped: true, mismatchFill: e.BuiltIn.NA }, Le = { type: null, coerce: true, includeMistyped: true, mismatchFill: e.BuiltIn.NA }, Te = (t2, i2, o2, a2) => {
+  if (null !== i2 && void 0 !== i2.colStart && (i2 = t2.getValueAt(i2.rowStart, i2.colStart)), null !== o2 && void 0 !== o2.colStart && (o2 = t2.getValueAt(o2.rowStart, o2.colStart)), "number" == typeof i2 && "number" == typeof o2) return a2(i2, o2);
+  let l2, u2;
+  if (i2?.isIRange ? l2 = i2 : o2?.isIRange && (u2 = o2), !l2 && !u2) {
+    const t3 = false;
+    return i2 = n(i2, s(i2, true), r.Number, true, t3), o2 = n(o2, s(o2, true), r.Number, true, t3), i2 instanceof e.Value ? i2 : o2 instanceof e.Value ? o2 : a2(i2, o2);
+  }
+  return l2 || (l2 = t2.getRange(i2)), l2.broadcast(o2, a2, 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 = (t2, i2) => {
+  null == i2 && (i2 = 0);
+  let o2, a2 = 1;
+  if ("+" === t2) return i2;
+  if ("-" !== t2) throw new e.Value(`Unrecognized prefix: ${t2}`);
+  return a2 = -a2, i2?.isIRange && (o2 = i2), o2 ? o2.broadcast(a2, fe, Le) : "number" != typeof (i2 = n(i2, s(i2, true), r.Number)) || isNaN(i2) ? e.BuiltIn.Value : i2 * a2;
+}, Ue = (t2, n2, r2, s2) => {
+  if (!n2) return e.BuiltIn.Ref;
+  if (n2.isIReferenceRange && (n2 = n2.getCoords()), void 0 === n2.colStart) return e.BuiltIn.Ref;
+  if (r2.isIReferenceRange && (r2 = r2.getCoords()), void 0 === r2.colStart) return e.BuiltIn.Ref;
+  const i2 = s2(n2, r2);
+  return i2 ? t2.getReference(i2) : e.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, n2, r2, s2) => Ue(e2, n2, r2, t.intersectRanges), ":": (e2, n2, r2, s2) => Ue(e2, n2, r2, t.unionRanges), ".:.": (e2, n2, r2, s2) => {
+  const i2 = Ue(e2, n2, r2, t.unionRanges);
+  return e2.getFunction("TRIMRANGE").execute(i2, 3, 3);
+}, ".:": (e2, n2, r2, s2) => {
+  const i2 = Ue(e2, n2, r2, t.unionRanges);
+  return e2.getFunction("TRIMRANGE").execute(i2, 1, 1);
+}, ":.": (e2, n2, r2, s2) => {
+  const i2 = Ue(e2, n2, r2, t.unionRanges);
+  return e2.getFunction("TRIMRANGE").execute(i2, 2, 2);
+}, "&": (e2, t2, i2) => ((e3, t3, i3, o2) => {
+  if (null !== t3 && void 0 !== t3.colStart && (t3 = e3.getValueAt(t3.rowStart, t3.colStart)), null !== i3 && void 0 !== i3.colStart && (i3 = e3.getValueAt(i3.rowStart, i3.colStart)), "string" == typeof t3 && "string" == typeof i3) return o2(t3, i3);
+  let a2, l2;
+  return t3?.isIRange ? a2 = t3 : i3?.isIRange && (l2 = i3), a2 || l2 ? (a2 || (a2 = e3.getRange(t3)), a2.broadcast(i3, o2, Se)) : o2(t3 = n(t3, s(t3, true), r.String), i3 = n(i3, s(i3, true), r.String));
+})(e2, t2, i2, 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), "@": (t2, n2) => {
+  if (!n2 || !n2.isIReferenceRange) return n2;
+  const r2 = n2.getCoords(), s2 = n2, i2 = t2.getPosition(), o2 = s2.getHeight(), a2 = s2.getWidth();
+  if (a2 > 1 && o2 > 1) return e.BuiltIn.Value;
+  if (o2 > 1) {
+    const e2 = i2.rowIndex - r2.rowStart;
+    if (e2 >= 0 && e2 < o2) return s2.getValueAt(e2, 0);
+  } else {
+    if (!(a2 > 1)) return s2.getValueAt(0, 0);
+    {
+      const e2 = i2.colIndex - r2.colStart;
+      if (e2 >= 0 && e2 < a2) return s2.getValueAt(0, e2);
+    }
+  }
+  return e.BuiltIn.Value;
+} }, Ce = { "%": (e2, t2) => Te(e2, t2, 100, he), "#": (t2, n2) => {
+  const r2 = t2.getSpillAt(n2.rowStart, n2.colStart);
+  return r2 || e.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(t2) {
+  return { type: "error", value: e.getBuiltInByLabel(t2.toUpperCase()), isLiteral: true };
+}
+function Ye(t2) {
+  return { type: "error", value: t2 ? e.getBuiltInByLabel(t2.toUpperCase()) : e.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 n2 = 0, r2 = De(e2, (e3) => {
+    const t3 = { ...e3 };
+    return t3.evalIndex = n2++, t3;
+  });
+  const s2 = new Array(n2), o2 = /* @__PURE__ */ new Set(), a2 = /* @__PURE__ */ new Map();
+  let l2;
+  const u2 = /* @__PURE__ */ new Map(), c2 = [], p2 = [];
+  r2 = De(r2, (e3, t3) => {
+    const n3 = e3.type, r3 = e3.evalIndex;
+    if (s2[r3] = null, e3.isReference) {
+      const t4 = e3, r4 = { node: e3, index: u2.size, op: null, value: null, inputs: null };
+      if (u2.set(t4, r4), "cell" === n3) {
+        const n4 = t4.value;
+        return n4.$colIndex && (r4.hasHorizontalAbs = true), n4.$rowIndex && (r4.hasVerticalAbs = true), r4.value = a2.size, a2.set(t4, a2.size), o2.add(r4), e3.refIndex = p2.length, void p2.push(r4.index);
+      }
+      if ("infix" === n3 || "prefix" === n3 || "postfix" === n3 || "spill" === n3) {
+        const n4 = t4.inputs, s3 = n4.length, i2 = e3.value;
+        r4.op = i2;
+        const a3 = new Array(s3);
+        r4.inputs = a3;
+        for (let e4 = 0; e4 < s3; e4++) {
+          const t5 = n4[e4], s4 = u2.get(t5);
+          s4 && (s4.hasHorizontalAbs && (r4.hasHorizontalAbs = true), s4.hasVerticalAbs && (r4.hasVerticalAbs = true)), a3[e4] = s4 ? s4.index : -1, o2.delete(s4);
+        }
+        if (o2.add(r4), Je.includes(i2)) {
+          const t5 = n4[0], s4 = !!t5 && "cell" === t5.type, i3 = n4[1], o3 = !!i3 && "cell" === i3.type;
+          s4 && o3 && (p2.splice(i3.refIndex, 1), i3.refIndex = t5.refIndex, e3.refIndex = t5.refIndex, p2[t5.refIndex] = r4.index);
+        } else "#" === i2 && (e3.refIndex = n4[0].refIndex);
+        return void c2.push(e3);
+      }
+      if ("error" === n3 || "named" === n3) {
+        l2 || (l2 = /* @__PURE__ */ new Map());
+        const s3 = t4.value;
+        let i2 = l2.get(s3);
+        return r4.op = n3, void 0 === i2 && (i2 = l2.size, l2.set(s3, i2)), r4.value = i2, o2.add(r4), e3.refIndex = p2.length, void p2.push(r4.index);
+      }
+      "tableReference" === n3 && (r4.op = n3), "tableSpecifier" === n3 && (r4.op = n3), "structuredArg" === n3 && (r4.op = n3);
+    } else if (t3 && t3.isReference) {
+      const t4 = e3, n4 = { node: e3, index: u2.size, op: "function", value: e3.value, inputs: null };
+      u2.set(t4, n4);
+    }
+    if (e3.isLiteral) if ("array" !== n3) s2[r3] = e3.value;
+    else {
+      const t4 = e3.value, n4 = t4.length, o3 = new Array(n4);
+      for (let e4 = 0; e4 < n4; e4++) {
+        const n5 = t4[e4].value, r4 = n5.length, s3 = new Array(r4);
+        for (let e5 = 0; e5 < r4; e5++) {
+          const t5 = n5[e5];
+          let r5 = t5.value;
+          if ("prefix" === t5.type) {
+            const e6 = t5.value;
+            r5 = t5.inputs[0].value, "-" === e6 && (r5 = -r5);
+          }
+          s3[e5] = r5;
+        }
+        o3[e4] = s3;
+      }
+      s2[r3] = i(o3);
+    }
+    else {
+      if ("empty" !== n3) return c2.push(e3), e3;
+      s2[r3] = void 0;
+    }
+  });
+  const f2 = new Array(a2.size);
+  a2.forEach((e3, t3) => {
+    const n3 = t3.value, r3 = n3.colIndex, s3 = n3.rowIndex, i2 = n3.$colIndex, o3 = n3.$rowIndex, a3 = { colStart: r3, rowStart: s3, colEnd: r3, rowEnd: s3, $colStart: i2, $rowStart: o3, $colEnd: i2, $rowEnd: o3 };
+    r3 === Number.MIN_SAFE_INTEGER && (a3.colEnd = Number.MAX_SAFE_INTEGER), s3 === Number.MIN_SAFE_INTEGER && (a3.rowEnd = Number.MAX_SAFE_INTEGER), n3.sheetName && (a3.sheetName = n3.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], n3 = t3.type;
+    if ("infix" === n3) {
+      const e4 = t3.value;
+      t3.fn = ye[e4];
+    } else if ("prefix" === n3) {
+      const e4 = t3.value;
+      t3.fn = we[e4];
+    } else if ("postfix" === n3) {
+      const e4 = t3.value;
+      t3.fn = Ce[e4];
+    }
+  }
+  const N2 = function(e3) {
+    const t3 = [], n3 = (e4, n4) => {
+      const r4 = { type: e4.type, value: e4.value };
+      void 0 !== e4.evalIndex && (r4.evalIndex = e4.evalIndex), void 0 !== e4.refIndex && (r4.refIndex = e4.refIndex), n4 && (r4.ctx = n4), t3.push(r4);
+    }, r3 = (e4, n4, r4, s4) => {
+      if (null == n4) return;
+      if (t3.length > 1 && "whitespace" === e4 && "whitespace" === t3[t3.length - 1].type) return;
+      const i2 = { type: e4, value: n4 };
+      r4 && (i2.ctx = r4), void 0 !== s4 && (i2.evalIndex = s4), t3.push(i2);
+    };
+    !function e4(t4, s4, i2) {
+      const o3 = t4.evalIndex ?? i2 ?? 0, a3 = t4.type, l3 = (t5, n4, s5) => {
+        if (!t5) return;
+        const i3 = t5.length;
+        for (let o4 = 0; o4 < i3; o4++) e4(t5[o4], n4, s5), o4 < i3 - 1 && r3("comma", ",", n4);
+      };
+      if (t4.isLiteral) {
+        if (r3("whitespace", t4.wsBefore, s4), "array" === a3) {
+          r3("type", "{", s4);
+          const n4 = t4.value, i3 = n4.length;
+          for (let t5 = 0; t5 < i3; t5++) {
+            const a4 = n4[t5], l4 = a4.value, u3 = l4.length;
+            for (let t6 = 0; t6 < u3; t6++) {
+              const n5 = l4[t6];
+              r3("whitespace", n5.wsBefore, s4), e4(n5, s4, o3), r3("whitespace", n5.wsAfter, s4), t6 < u3 - 1 && r3("comma", ",", s4);
+            }
+            t5 < i3 - 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 + '"' }, n3(t4, s4)) : n3(t4, s4);
+        r3("whitespace", t4.wsAfter, s4);
+      } else if ("infix" === a3) e4(t4.inputs[0], s4, o3), r3("whitespace", t4.wsBefore, s4), n3(t4, s4), r3("whitespace", t4.wsAfter, s4), e4(t4.inputs[1], s4, o3);
+      else if ("prefix" === a3) r3("whitespace", t4.wsBefore, s4), n3(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), n3(t4, s4), r3("whitespace", t4.wsAfter, s4);
+      else {
+        r3("whitespace", t4.wsBefore, s4);
+        const i3 = t4.inputs;
+        switch (a3) {
+          case "function":
+            n3(t4, s4);
+            const u3 = { name: String(t4.value), argIndex: -1 };
+            if (r3("paren", "(", u3, t4.evalIndex), i3) {
+              const t5 = i3.length;
+              for (let n4 = 0; n4 < t5; n4++) {
+                const s5 = { ...u3, argIndex: n4 };
+                e4(i3[n4], s5, o3), n4 < t5 - 1 && r3("comma", ",", s5);
+              }
+            }
+            t4.error || r3("paren", ")", u3, t4.evalIndex);
+            break;
+          case "cell":
+            n3(t4, s4);
+            break;
+          case "paren":
+            r3(a3, "(", s4, o3), l3(i3, s4, o3), t4.error || r3(a3, ")", s4, o3);
+            break;
+          case "squareParen":
+            r3(a3, "[", s4, o3), l3(i3, s4, o3), t4.error || r3(a3, "]", s4, o3);
+            break;
+          case "tableReference":
+            n3(t4, s4);
+            const c3 = { name: String(t4.value), argIndex: -1 };
+            if (r3("paren", "[", c3), i3) {
+              const t5 = i3.length;
+              for (let n4 = 0; n4 < t5; n4++) {
+                const s5 = { ...c3, argIndex: n4 };
+                e4(i3[n4], s5, o3), n4 < t5 - 1 && r3("comma", ",", s5);
+              }
+            }
+            t4.error || r3("paren", "]", c3);
+            break;
+          default:
+            void 0 !== t4.value && n3(t4, s4), i3 && i3.forEach((t5) => e4(t5, s4, o3));
+        }
+        r3("whitespace", t4.wsAfter, s4);
+      }
+    }(e3);
+    const s3 = t3.length;
+    for (let e4 = 0; e4 < s3; e4++) {
+      const n4 = t3[e4];
+      if ("whitespace" === n4.type && void 0 === n4.evalIndex) {
+        const r4 = t3[e4 + 1];
+        r4 && void 0 !== r4.evalIndex && (n4.evalIndex = r4.evalIndex);
+      }
+    }
+    return t3;
+  }(r2);
+  return { ast: r2, evaluations: s2, executions: c2, precedentsAbsolute: g2, precedentsExecute: d2, precedentsNamed: m2, precedentsRelative: f2, precedentsRoot: E2, references: p2, tokens: N2, error: t2 };
+}
+function He(t2, n2) {
+  let r2, s2 = -1, i2 = "";
+  Number.isSafeInteger(t2.previousToken?.startLine) ? (s2 = t2.previousToken.startLine, r2 = t2.previousToken.endColumn + 1) : Number.isSafeInteger(t2.token?.startLine) && (s2 = t2.token.startLine, r2 = t2.token.startColumn), -1 !== s2 ? (i2 += "\n" + n2.split("\n")[s2 - 1] + "\n", i2 += Array(r2 - 1).fill(" ").join("") + "^\n", i2 += `Error at position ${s2}:${r2}
+` + t2.message, t2.errorLocation = { line: s2, column: r2 }) : i2 = n2 + "\n" + t2.message;
+  const o2 = new e.Parse(i2);
+  return o2.details = t2, o2;
+}
+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(t2, n2) {
+    const r2 = function(t3) {
+      const n3 = ae.tokenize(t3);
+      if (n3.errors.length > 0) {
+        const r3 = n3.errors[0], s3 = r3.line, i3 = r3.column;
+        let o3 = "\n" + t3.split("\n")[s3 - 1] + "\n";
+        throw o3 += Array(i3 - 1).fill(" ").join("") + "^\n", r3.message = o3 + `Error at position ${s3}:${i3}
+` + r3.message, r3.errorLocation = { line: s3, column: i3 }, new e.Parse(r3.message, { line: s3, column: i3, offset: r3.offset, length: r3.length });
+      }
+      return n3;
+    }(n2);
+    let s2;
+    if (!r2) return s2 = { type: "text", value: n2 }, s2;
+    const i2 = r2.tokens;
+    this.input = i2, this.inputTextLength = n2.length;
+    const o2 = t2.getPosition();
+    return this.position = o2, this.astErrors = [], this.reset(), s2 = this.intersectOp(), s2 = De(s2, (e2, t3) => {
+      let n3 = e2.type;
+      if ("function" === n3 && e2.value && e2.value.toUpperCase().startsWith(Qe)) {
+        const t4 = e2.value.substring(6);
+        let r4 = e2.image.substring(6), s3 = e2;
+        "ANCHORARRAY" === t4 ? (s3 = We("#", e2.inputs[0], true), r4 = "#") : "SINGLE" === t4 ? (s3 = ze("@", e2.inputs[0], true), r4 = "@") : s3 = Pe(t4, e2.inputs), Ke(s3, e2), s3.image = r4, n3 = (e2 = s3).type;
+      }
+      const r3 = t3?.isReference;
+      if (r3) {
+        const n4 = t3.value;
+        if ((":" === n4 || ".:." === n4 || ".:" === n4 || ":." === n4) && Number.isInteger(e2.value)) {
+          const n5 = t3.inputs[0] === e2 ? t3.inputs[1] : t3.inputs[0];
+          if (n5 && Number.isInteger(n5.value)) {
+            const t4 = be(e2.image, o2);
+            return Ke(t4, e2), t4;
+          }
+        }
+      } else if ("cell" === n3) {
+        const t4 = e2.value;
+        if (t4.rowIndex === Number.MIN_SAFE_INTEGER || t4.colIndex >= 16384) {
+          const t5 = ke(e2.image);
+          return Ke(t5, e2), t5;
+        }
+      }
+      return e2;
+    }), s2;
+  }
+  build(t2, n2) {
+    if (0 === n2.length) throw Error("Input must not be empty.");
+    let r2, s2, i2;
+    try {
+      r2 = this._createAST(t2, n2);
+    } catch (t3) {
+      i2 = t3 instanceof e.Parse ? t3 : new e.Parse(t3.message, t3);
+    }
+    const a2 = this.errors;
+    if (a2.length > 0) {
+      i2 = He(a2[0], n2);
+    }
+    const l2 = this.astErrors;
+    if (l2.length > 0) {
+      i2 = He(l2[0], n2);
+    }
+    return s2 = r2 ? Ze(r2, i2) : { ast: null, evaluations: o.EmptyArray, executions: o.EmptyArray, precedentsAbsolute: o.EmptyArray, precedentsExecute: o.EmptyArray, precedentsNamed: null, precedentsRelative: o.EmptyArray, precedentsRoot: o.EmptyArray, references: o.EmptyArray, tokens: o.EmptyArray, error: i2 }, s2;
+  }
+}
+class Zt {
+  constructor(e2, t2) {
+    this._options = e2, this._compiled = t2;
+  }
+  getTextAt(e2, t2, n2 = false) {
+    return n2 ? l(this._compiled.tokens) : a(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 l(t2) === l(n2);
+  }
+  getReferences() {
+    const e2 = this._compiled, t2 = e2.references, n2 = t2.length;
+    if (0 === n2) return o.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, n2) {
+    const r2 = this._compiled, s2 = r2.references;
+    if (0 === s2.length) return o.EmptyArray;
+    const i2 = r2.precedentsExecute, a2 = s2[e2];
+    if (void 0 === a2) throw new Error(`Invalid reference index: ${e2}`);
+    const l2 = i2[a2], u2 = l2.node, c2 = u2.inputs ?? o.EmptyArray;
+    let p2, f2, h2 = false;
+    n2 && (p2 = { colIndex: n2.colStart, rowIndex: n2.rowStart, $colIndex: n2.$colStart ?? false, $rowIndex: n2.$rowStart ?? false }, n2.sheetName && (p2.sheetName = n2.sheetName), h2 = !t.isSingleCell(n2), h2 && (f2 = { colIndex: n2.colEnd, rowIndex: n2.rowEnd, $colIndex: n2.$colEnd ?? false, $rowIndex: n2.$rowEnd ?? false }, n2.colEnd === Number.MAX_SAFE_INTEGER && (f2.colIndex = Number.MIN_SAFE_INTEGER), n2.rowEnd === Number.MAX_SAFE_INTEGER && (f2.rowIndex = Number.MIN_SAFE_INTEGER)));
+    const g2 = 2 === c2.length;
+    let d2 = -1, m2 = -1;
+    if (g2) d2 = c2[0].evalIndex, m2 = c2[1].evalIndex;
+    else {
+      if ("cell" !== u2.type) throw "named" === l2.op ? new Error("Cannot setReference for a named reference") : new Error(`Invalidate reference index: ${e2}`);
+      d2 = u2.evalIndex;
+    }
+    const E2 = this._compiled.ast, A2 = De(E2, (e3) => {
+      if (!e3 || !e3.isReference) return;
+      const t2 = e3.type;
+      if (!n2 && Je.includes(e3.value)) {
+        const e4 = c2[0], t3 = c2[1];
+        let n3 = e4.evalIndex === d2, r4 = t3.evalIndex === m2;
+        if (n3 || r4) {
+          const e5 = Ye();
+          return e5.image = "#REF!", e5;
+        }
+      }
+      if (!("cell" === t2 || "error" === t2)) return;
+      const r3 = e3.evalIndex;
+      let s3, i3 = r3 === d2;
+      if (i3 || r3 === m2) {
+        if (n2) if (g2 === h2) {
+          let t3 = i3 ? p2 : f2;
+          s3 = { ...e3 }, s3.value = t3, s3.image = null;
+        } else s3 = h2 ? $e(":", Me(p2), Me(f2), true) : Me(p2);
+        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(t2, n2, r2, s2) {
+    const i2 = this._options?.getNamed;
+    if (!i2) return e.BuiltIn.Name;
+    let o2 = i2?.(t2, this._options.getSheetName?.())?.[0];
+    return o2 ? (o2.isFormulaError || (o2 = u(o2, n2, r2, s2)), o2) : e.BuiltIn.Name;
+  }
+  getDirectPrecedentsAt(n2, r2, s2 = false, i2, a2) {
+    const l2 = this._compiled, c2 = l2.precedentsRoot, p2 = c2.length;
+    if (0 === p2) return o.EmptyArray;
+    const f2 = l2.precedentsRelative, h2 = l2.precedentsAbsolute, g2 = f2.length;
+    for (let e2 = 0; e2 < g2; e2++) {
+      const t2 = f2[e2];
+      let s3 = h2[e2], i3 = u(t2, n2, r2, s3);
+      h2[e2] = i3;
+    }
+    let d2 = false;
+    const m2 = l2.precedentsExecute, E2 = m2.length, A2 = Ht;
+    for (let s3 = 0; s3 < E2; s3++) {
+      const i3 = m2[s3], o2 = i3.op;
+      if (!o2) {
+        const e2 = h2[i3.value];
+        A2[i3.index] = e2;
+        continue;
+      }
+      if ("named" === o2) {
+        d2 = true, A2[i3.index] = this._resolveNamed(i3.node.value, n2, r2);
+        continue;
+      }
+      if ("error" === o2) {
+        A2[i3.index] = i3.node.value;
+        continue;
+      }
+      if ("@" === o2 || "#" === o2) {
+        A2[i3.index] = A2[i3.inputs[0]];
+        continue;
+      }
+      const a3 = i3.inputs;
+      if (!a3) continue;
+      let l3 = A2[a3[0]];
+      if (void 0 === l3) {
+        A2[i3.index] = e.BuiltIn.Value;
+        continue;
+      }
+      if (l3.isFormulaError) {
+        A2[i3.index] = l3;
+        continue;
+      }
+      let u2, c3 = A2[a3[1]];
+      void 0 !== c3 ? c3.isFormulaError ? A2[i3.index] = c3 : (" " === o2 ? u2 = t.intersectRanges(l3, c3) : ":" !== o2 && ".:." !== o2 && ":." !== o2 && ".:" !== o2 || (u2 = A2[i3.index] = t.unionRanges(l3, c3)), A2[i3.index] = u2 ?? e.BuiltIn.Null) : A2[i3.index] = e.BuiltIn.Value;
+    }
+    const N2 = new Array(p2);
+    for (let e2 = 0; e2 < p2; e2++) {
+      const t2 = c2[e2], n3 = A2[t2];
+      if (N2[e2] = void 0 !== n3?.rowStart ? { ...n3 } : n3, i2 || a2) {
+        const r3 = m2[t2];
+        d2 && "named" === r3.op ? (i2 && (i2[e2] = n3.$colStart || n3.$colEnd), a2 && (a2[e2] = n3.$rowStart || n3.$rowEnd)) : (i2 && (i2[e2] = r3.hasVerticalAbs), a2 && (a2[e2] = r3.hasHorizontalAbs));
+      }
+    }
+    return N2;
+  }
+  evaluate(t2, n2, r2) {
+    const s2 = t2.getPosition(), i2 = s2?.rowIndex ?? 0, o2 = s2?.colIndex ?? 0;
+    let a2 = this._compiled;
+    if (void 0 !== n2) {
+      let e2;
+      if (De(a2.ast, (t3) => {
+        t3.evalIndex === n2 && (e2 = t3);
+      }), !e2) throw new Error(`Invalid evalIndex: ${n2}`);
+      a2 = Ze(e2, a2.error);
+    }
+    if (a2.error) return a2.error;
+    const l2 = a2.evaluations, c2 = a2.executions;
+    let p2, h2;
+    r2 || (r2 = this._resolvePrecedents(t2));
+    const g2 = a2.precedentsExecute, d2 = a2.precedentsRelative, m2 = a2.precedentsAbsolute, E2 = g2.length;
+    for (let e2 = 0; e2 < E2; e2++) {
+      const n3 = g2[e2], r3 = n3.op;
+      if (r3) {
+        if ("named" === r3) {
+          const e3 = n3.node;
+          let r4 = this._resolveNamed(n3.node.value, i2, o2);
+          void 0 !== r4?.colStart && (r4 = t2.getReference(r4)), l2[e3.evalIndex] = r4;
+        } else if ("error" === r3) {
+          const e3 = n3.node;
+          l2[e3.evalIndex] = n3.node.value;
+        }
+      } else {
+        const t3 = d2[n3.value];
+        let r4 = m2[e2];
+        const s3 = u(t3, i2, o2, r4), a3 = n3.node;
+        l2[a3.evalIndex] = s3;
+      }
+    }
+    const A2 = a2.precedentsRoot, N2 = A2.length;
+    if (N2 !== r2.length) return e.BuiltIn.Parse;
+    for (let e2 = 0; e2 < N2; e2++) {
+      const t3 = g2[A2[e2]].node;
+      let n3 = r2[e2];
+      n3.isIRange && "cell" === t3.type && n3.size > 1 && (n3 = n3.getValueAt(0, 0) ?? null), l2[t3.evalIndex] = n3;
+    }
+    let I2;
+    const O2 = (n3) => {
+      const r3 = n3.inputs, s3 = r3 ? r3.length : 0;
+      let i3;
+      switch (n3.type) {
+        case "infix":
+          const o3 = n3.value;
+          let a3 = l2[r3[0].evalIndex], u2 = l2[r3[1].evalIndex];
+          if ("+" === o3 && "number" == typeof a3 && "number" == typeof u2) {
+            const e2 = a3 + u2;
+            return Math.abs(e2) < 99e-14 ? 0 : e2;
+          }
+          if ("-" === o3 && "number" == typeof a3 && "number" == typeof u2) {
+            const e2 = a3 - u2;
+            return Math.abs(e2) < 99e-14 ? 0 : e2;
+          }
+          if (a3 && a3.isFormulaError) return a3;
+          if (u2 && u2.isFormulaError) return u2;
+          const c3 = n3.fn;
+          return i3 = c3 ? c3(t2, a3, u2) : e.BuiltIn.Value, i3 = f(i3, null), i3;
+        case "function":
+          I2 || (I2 = new Array(s3)), I2.length !== s3 && (I2.length = s3);
+          for (let e2 = 0; e2 < s3; e2++) I2[e2] = l2[r3[e2].evalIndex];
+          return i3 = this._callFunction(t2, n3, I2), i3 && "function" == typeof i3.then ? i3.then((r4) => {
+            r4 = f(r4, t2), i3 instanceof e.Known && (h2 = i3), l2[n3.evalIndex] = r4;
+          }).catch((t3) => {
+            const r4 = t3 instanceof e.Known ? t3 : new e.Value("Uncaught error", { cause: t3 });
+            l2[n3.evalIndex] = r4;
+          }) : i3 instanceof e.Known && (h2 = i3), i3;
+        case "prefix":
+        case "postfix":
+          let p3 = l2[r3[0].evalIndex];
+          if (p3 && p3.isFormulaError) return p3;
+          const g3 = n3.fn;
+          return i3 = g3 ? g3(t2, p3) : e.BuiltIn.Value, i3;
+        case "paren":
+          if (1 === s3) return l2[r3[0].evalIndex];
+          {
+            const e2 = new Array(s3);
+            for (let t3 = 0; t3 < s3; t3++) e2[t3] = l2[r3[t3].evalIndex];
+            return e2;
+          }
+        case "named":
+          return null;
+        case "empty":
+          return;
+      }
+    };
+    let x2 = c2.length;
+    for (let e2 = 0; e2 < x2; e2++) {
+      const t3 = c2[e2];
+      if (h2) return h2;
+      if (p2) p2 = p2.then(() => {
+        const e3 = O2(t3);
+        return l2[t3.evalIndex] = e3, e3;
+      });
+      else {
+        const e3 = O2(t3);
+        l2[t3.evalIndex] = e3, e3 && "function" == typeof e3.then && (p2 = e3);
+      }
+    }
+    if (p2) return p2.then(() => {
+      const e2 = l2[l2.length - 1];
+      return this._finalizeReturnValue(t2, e2);
+    });
+    const S2 = l2[l2.length - 1];
+    return this._finalizeReturnValue(t2, S2);
+  }
+  _resolvePrecedents(t2) {
+    const n2 = t2.getPosition(), r2 = n2?.rowIndex ?? 0, s2 = n2?.colIndex ?? 0;
+    const i2 = this.getDirectPrecedentsAt(r2, s2), a2 = i2.length;
+    let l2;
+    if (a2 > 0) {
+      l2 = new Array(a2);
+      for (let n3 = 0; n3 < a2; n3++) {
+        const r3 = i2[n3];
+        if (r3 instanceof e.Known) l2[n3] = r3;
+        else if (Array.isArray(r3)) {
+          const e2 = new Array(r3.length);
+          for (let n4 = 0; n4 < r3.length; n4++) e2[n4] = t2.getReference(r3[n4]);
+          l2[n3] = e2;
+        } else l2[n3] = t2.getReference(r3);
+      }
+    } else l2 = o.EmptyArray;
+    return l2;
+  }
+  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 = c(t2) + p(e2);
+    if (n2.has(s2)) return this;
+    const i2 = Ze(ze("@", r2, true), this._compiled.error);
+    return new Zt(this._options, i2);
+  }
+  _callFunction(t2, n2, r2) {
+    const s2 = n2?.cacheFn ?? t2.getFunction(n2.value);
+    if (!s2) return new e.Parse();
+    const i2 = s2.isBuiltIn();
+    let o2;
+    i2 ? n2.cacheFn = s2 : this._context = t2;
+    try {
+      o2 = s2.execute(...r2);
+    } catch (t3) {
+      o2 = t3 instanceof e.Known ? t3 : new e.Value(t3.message, { cause: t3 });
+    }
+    return i2 || (this._context = null), void 0 === o2 ? new e.Parse() : o2;
+  }
+  _finalizeReturnValue(t2, n2) {
+    if (n2 && void 0 !== n2.colStart && (n2 = t2.getValueAt(n2.rowStart, n2.colStart)), Array.isArray(n2)) if (1 === n2.length && Array.isArray(n2[0]) && 1 === n2[0].length) n2 = n2[0][0], Array.isArray(n2) && (n2 = e.BuiltIn.Value);
+    else try {
+      n2 = t2.getRange(n2);
+    } catch (t3) {
+      n2 = e.BuiltIn.Value;
+    }
+    return n2?.isIRange ? 1 === n2.size ? (n2 = n2.getValueAt(0, 0, Kt), null === (n2 = f(n2, t2)) && (n2 = 0)) : n2 = n2.fillEmpty(0) : null === (n2 = f(n2, t2)) && (n2 = 0), n2;
+  }
+  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 l(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: h, ...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
+};