@devmm/puredocs-excel-formula 1.1.1 → 1.1.3

package/dist/index.js

@@ -1,21 +1,6 @@
-import { toOADate, fromOADate, columnLetter, parseCellRef, cellRefFromRowCol, parseRangeRef, shiftIndex, shiftFormulaRefs, shiftSpan, EXCEL_MAX_ROWS, EXCEL_MAX_COLUMNS, columnNumber } from '@devmm/puredocs-excel';
+import { toOADate, EXCEL_MAX_ROWS, columnNumber, EXCEL_MAX_COLUMNS, fromOADate, columnLetter, parseCellRef, cellRefFromRowCol, parseRangeRef, shiftIndex, shiftFormulaRefs, shiftSpan } from '@devmm/puredocs-excel';
 
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value2) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value2);
-var __privateSet = (obj, member, value2, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value2), value2);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value2) {
-    __privateSet(obj, member, value2);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
-  }
-});
+// src/formula-value.ts
 var FormulaError = /* @__PURE__ */ ((FormulaError2) => {
   FormulaError2[FormulaError2["None"] = 0] = "None";
   FormulaError2[FormulaError2["Null"] = 1] = "Null";
@@ -41,19 +26,36 @@ var TailCall = class {
     this.lambda = lambda;
     this.args = args;
   }
+  lambda;
+  args;
 };
-var _num, _obj;
-var _FormulaValue = class _FormulaValue {
+var FormulaValue = class _FormulaValue {
+  kind;
+  /** Numeric payload (also used for boolean: 1=true, 0=false). */
+  #num;
+  /** String, ArrayValue, or LambdaLike payload. */
+  #obj;
+  errorCode;
   constructor(kind, num5 = 0, obj, errorCode = 0 /* None */) {
-    /** Numeric payload (also used for boolean: 1=true, 0=false). */
-    __privateAdd(this, _num);
-    /** String, ArrayValue, or LambdaLike payload. */
-    __privateAdd(this, _obj);
     this.kind = kind;
-    __privateSet(this, _num, num5);
-    __privateSet(this, _obj, obj);
+    this.#num = num5;
+    this.#obj = obj;
     this.errorCode = errorCode;
   }
+  // ── Cached singletons ────────────────────────────────────────────────────
+  static blank = new _FormulaValue("blank");
+  static zero = new _FormulaValue("number", 0);
+  static one = new _FormulaValue("number", 1);
+  static true_ = new _FormulaValue("boolean", 1);
+  static false_ = new _FormulaValue("boolean", 0);
+  static emptyString = new _FormulaValue("text", 0, "");
+  static errorDiv0 = new _FormulaValue("error", 0, void 0, 2 /* Div0 */);
+  static errorValue = new _FormulaValue("error", 0, void 0, 3 /* Value */);
+  static errorRef = new _FormulaValue("error", 0, void 0, 4 /* Ref */);
+  static errorName = new _FormulaValue("error", 0, void 0, 5 /* Name */);
+  static errorNA = new _FormulaValue("error", 0, void 0, 7 /* NA */);
+  static errorNum = new _FormulaValue("error", 0, void 0, 6 /* Num */);
+  static errorNull = new _FormulaValue("error", 0, void 0, 1 /* Null */);
   // ── Static factories ─────────────────────────────────────────────────────
   static number(v) {
     if (v === 0) return _FormulaValue.zero;
@@ -120,19 +122,19 @@ var _FormulaValue = class _FormulaValue {
   }
   // ── Value accessors ──────────────────────────────────────────────────────
   get numberValue() {
-    return __privateGet(this, _num);
+    return this.#num;
   }
   get textValue() {
-    return __privateGet(this, _obj) ?? "";
+    return this.#obj ?? "";
   }
   get booleanValue() {
-    return __privateGet(this, _num) !== 0;
+    return this.#num !== 0;
   }
   get arrayVal() {
-    return __privateGet(this, _obj) ?? ArrayValue.empty;
+    return this.#obj ?? ArrayValue.empty;
   }
   get lambdaVal() {
-    return __privateGet(this, _obj);
+    return this.#obj;
   }
   // ── Coercion (Excel semantics, no exceptions) ─────────────────────────────
   coerceToNumber() {
@@ -142,7 +144,7 @@ var _FormulaValue = class _FormulaValue {
       case "blank":
         return _FormulaValue.zero;
       case "boolean":
-        return _FormulaValue.number(__privateGet(this, _num));
+        return _FormulaValue.number(this.#num);
       case "error":
         return this;
       case "text": {
@@ -156,11 +158,11 @@ var _FormulaValue = class _FormulaValue {
   tryAsDouble() {
     switch (this.kind) {
       case "number":
-        return { ok: true, value: __privateGet(this, _num) };
+        return { ok: true, value: this.#num };
       case "blank":
         return { ok: true, value: 0 };
       case "boolean":
-        return { ok: true, value: __privateGet(this, _num) };
+        return { ok: true, value: this.#num };
       case "text": {
         const n = parseFloat(this.textValue);
         return isNaN(n) ? { ok: false } : { ok: true, value: n };
@@ -174,7 +176,7 @@ var _FormulaValue = class _FormulaValue {
       case "boolean":
         return this;
       case "number":
-        return _FormulaValue.boolean(__privateGet(this, _num) !== 0);
+        return _FormulaValue.boolean(this.#num !== 0);
       case "blank":
         return _FormulaValue.false_;
       case "error":
@@ -194,9 +196,9 @@ var _FormulaValue = class _FormulaValue {
       case "text":
         return this.textValue;
       case "number":
-        return String(__privateGet(this, _num));
+        return String(this.#num);
       case "boolean":
-        return __privateGet(this, _num) !== 0 ? "TRUE" : "FALSE";
+        return this.#num !== 0 ? "TRUE" : "FALSE";
       case "blank":
         return "";
       case "error":
@@ -220,9 +222,9 @@ var _FormulaValue = class _FormulaValue {
     if (a.kind !== b.kind) return false;
     switch (a.kind) {
       case "number":
-        return Math.abs(__privateGet(a, _num) - __privateGet(b, _num)) < 1e-10;
+        return Math.abs(a.#num - b.#num) < 1e-10;
       case "boolean":
-        return __privateGet(a, _num) === __privateGet(b, _num);
+        return a.#num === b.#num;
       case "text":
         return a.textValue.toUpperCase() === b.textValue.toUpperCase();
       default:
@@ -240,7 +242,7 @@ var _FormulaValue = class _FormulaValue {
       case 1:
         return a.textValue.toUpperCase() < b.textValue.toUpperCase() ? -1 : a.textValue.toUpperCase() > b.textValue.toUpperCase() ? 1 : 0;
       case 2:
-        return __privateGet(a, _num) - __privateGet(b, _num);
+        return a.#num - b.#num;
       default:
         return 0;
     }
@@ -289,7 +291,7 @@ var _FormulaValue = class _FormulaValue {
   toObject() {
     switch (this.kind) {
       case "number":
-        return __privateGet(this, _num);
+        return this.#num;
       case "text":
         return this.textValue;
       case "boolean":
@@ -310,59 +312,44 @@ var _FormulaValue = class _FormulaValue {
     return this.asText();
   }
 };
-_num = new WeakMap();
-_obj = new WeakMap();
-// ── Cached singletons ────────────────────────────────────────────────────
-_FormulaValue.blank = new _FormulaValue("blank");
-_FormulaValue.zero = new _FormulaValue("number", 0);
-_FormulaValue.one = new _FormulaValue("number", 1);
-_FormulaValue.true_ = new _FormulaValue("boolean", 1);
-_FormulaValue.false_ = new _FormulaValue("boolean", 0);
-_FormulaValue.emptyString = new _FormulaValue("text", 0, "");
-_FormulaValue.errorDiv0 = new _FormulaValue("error", 0, void 0, 2 /* Div0 */);
-_FormulaValue.errorValue = new _FormulaValue("error", 0, void 0, 3 /* Value */);
-_FormulaValue.errorRef = new _FormulaValue("error", 0, void 0, 4 /* Ref */);
-_FormulaValue.errorName = new _FormulaValue("error", 0, void 0, 5 /* Name */);
-_FormulaValue.errorNA = new _FormulaValue("error", 0, void 0, 7 /* NA */);
-_FormulaValue.errorNum = new _FormulaValue("error", 0, void 0, 6 /* Num */);
-_FormulaValue.errorNull = new _FormulaValue("error", 0, void 0, 1 /* Null */);
-var FormulaValue = _FormulaValue;
-var _data;
-var _ArrayValue = class _ArrayValue {
+var ArrayValue = class _ArrayValue {
+  static empty = new _ArrayValue(0, 0);
+  #data;
+  rows;
+  columns;
   constructor(rows2, columns2) {
-    __privateAdd(this, _data);
     this.rows = rows2;
     this.columns = columns2;
-    __privateSet(this, _data, new Array(rows2 * columns2).fill(FormulaValue.blank));
+    this.#data = new Array(rows2 * columns2).fill(FormulaValue.blank);
   }
   get length() {
-    return __privateGet(this, _data).length;
+    return this.#data.length;
   }
   get(row2, col) {
     if (row2 < 0 || row2 >= this.rows || col < 0 || col >= this.columns) {
       return FormulaValue.errorRef;
     }
-    return __privateGet(this, _data)[row2 * this.columns + col];
+    return this.#data[row2 * this.columns + col];
   }
   set(row2, col, value2) {
     if (row2 >= 0 && row2 < this.rows && col >= 0 && col < this.columns) {
-      __privateGet(this, _data)[row2 * this.columns + col] = value2;
+      this.#data[row2 * this.columns + col] = value2;
     }
   }
   getFlat(index) {
-    return index >= 0 && index < __privateGet(this, _data).length ? __privateGet(this, _data)[index] : FormulaValue.errorRef;
+    return index >= 0 && index < this.#data.length ? this.#data[index] : FormulaValue.errorRef;
   }
   setFlat(index, value2) {
-    if (index >= 0 && index < __privateGet(this, _data).length) {
-      __privateGet(this, _data)[index] = value2;
+    if (index >= 0 && index < this.#data.length) {
+      this.#data[index] = value2;
     }
   }
   /** Iterate all values in row-major order. */
   values() {
-    return __privateGet(this, _data);
+    return this.#data;
   }
   toObjectArray() {
-    return __privateGet(this, _data).map((v) => v.toObject());
+    return this.#data.map((v) => v.toObject());
   }
   /** Create from a flat array (single column). */
   static fromFlat(values) {
@@ -420,9 +407,6 @@ var _ArrayValue = class _ArrayValue {
     return result;
   }
 };
-_data = new WeakMap();
-_ArrayValue.empty = new _ArrayValue(0, 0);
-var ArrayValue = _ArrayValue;
 
 // src/formula-token.ts
 var TokenType = /* @__PURE__ */ ((TokenType2) => {
@@ -484,262 +468,257 @@ var KNOWN_ERRORS = /* @__PURE__ */ new Set([
   "#CALC!",
   "#SPILL!"
 ]);
-var _formula, _pos, _FormulaLexer_instances, readNextToken_fn, readString_fn, readErrorLiteral_fn, readQuotedSheetRef_fn, readNumber_fn, readIdentifier_fn, stripReservedPrefixes_fn, readCellRefChars_fn, readOperator_fn, skipWhitespace_fn;
 var FormulaLexer = class {
+  #formula;
+  #pos = 0;
   constructor(formula) {
-    __privateAdd(this, _FormulaLexer_instances);
-    __privateAdd(this, _formula);
-    __privateAdd(this, _pos, 0);
     if (!formula) throw new FormulaException("Formula cannot be empty.");
-    __privateSet(this, _formula, formula);
+    this.#formula = formula;
   }
   tokenize() {
-    __privateSet(this, _pos, 0);
+    this.#pos = 0;
     const tokens = [];
-    while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
-      __privateMethod(this, _FormulaLexer_instances, skipWhitespace_fn).call(this);
-      if (__privateGet(this, _pos) >= __privateGet(this, _formula).length) break;
-      const token = __privateMethod(this, _FormulaLexer_instances, readNextToken_fn).call(this);
+    while (this.#pos < this.#formula.length) {
+      this.#skipWhitespace();
+      if (this.#pos >= this.#formula.length) break;
+      const token = this.#readNextToken();
       if (token) tokens.push(token);
     }
-    tokens.push(makeToken(31 /* EOF */, "", __privateGet(this, _pos)));
+    tokens.push(makeToken(31 /* EOF */, "", this.#pos));
     return tokens;
   }
-};
-_formula = new WeakMap();
-_pos = new WeakMap();
-_FormulaLexer_instances = new WeakSet();
-// ── Private tokenisers ─────────────────────────────────────────────────────
-readNextToken_fn = function() {
-  const c = __privateGet(this, _formula)[__privateGet(this, _pos)];
-  if (c === '"') return __privateMethod(this, _FormulaLexer_instances, readString_fn).call(this);
-  if (c === "#") return __privateMethod(this, _FormulaLexer_instances, readErrorLiteral_fn).call(this);
-  if (c === "'") return __privateMethod(this, _FormulaLexer_instances, readQuotedSheetRef_fn).call(this);
-  if (c === "." && __privateGet(this, _pos) + 1 < __privateGet(this, _formula).length && /\d/.test(__privateGet(this, _formula)[__privateGet(this, _pos) + 1])) {
-    return __privateMethod(this, _FormulaLexer_instances, readNumber_fn).call(this);
-  }
-  if (/\d/.test(c)) return __privateMethod(this, _FormulaLexer_instances, readNumber_fn).call(this);
-  if (/[a-zA-Z_$]/.test(c)) return __privateMethod(this, _FormulaLexer_instances, readIdentifier_fn).call(this);
-  return __privateMethod(this, _FormulaLexer_instances, readOperator_fn).call(this);
-};
-readString_fn = function() {
-  const start = __privateWrapper(this, _pos)._++;
-  let value2 = "";
-  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
-    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
-    if (ch === '"') {
-      __privateWrapper(this, _pos)._++;
-      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === '"') {
-        value2 += '"';
-        __privateWrapper(this, _pos)._++;
-      } else return makeToken(1 /* String */, value2, start);
-    } else {
-      value2 += ch;
-      __privateWrapper(this, _pos)._++;
-    }
-  }
-  throw new FormulaException(`Unterminated string at position ${start}.`);
-};
-readErrorLiteral_fn = function() {
-  const start = __privateGet(this, _pos);
-  let raw = "#";
-  __privateWrapper(this, _pos)._++;
-  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
-    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
-    if (/[a-zA-Z0-9/]/.test(ch) || ch === "!" || ch === "?") {
-      raw += ch;
-      __privateWrapper(this, _pos)._++;
-      if (ch === "!" || ch === "?") break;
-    } else break;
-  }
-  const upper2 = raw.toUpperCase();
-  if (!KNOWN_ERRORS.has(upper2)) {
-    throw new FormulaException(`Unknown error literal "${raw}" at position ${start}.`);
-  }
-  return makeToken(30 /* ErrorLiteral */, upper2, start);
-};
-readQuotedSheetRef_fn = function() {
-  const start = __privateWrapper(this, _pos)._++;
-  let sheetName = "";
-  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
-    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
-    if (ch === "'") {
-      __privateWrapper(this, _pos)._++;
-      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "'") {
-        sheetName += "'";
-        __privateWrapper(this, _pos)._++;
+  // ── Private tokenisers ─────────────────────────────────────────────────────
+  #readNextToken() {
+    const c = this.#formula[this.#pos];
+    if (c === '"') return this.#readString();
+    if (c === "#") return this.#readErrorLiteral();
+    if (c === "'") return this.#readQuotedSheetRef();
+    if (c === "." && this.#pos + 1 < this.#formula.length && /\d/.test(this.#formula[this.#pos + 1])) {
+      return this.#readNumber();
+    }
+    if (/\d/.test(c)) return this.#readNumber();
+    if (/[a-zA-Z_$]/.test(c)) return this.#readIdentifier();
+    return this.#readOperator();
+  }
+  #readString() {
+    const start = this.#pos++;
+    let value2 = "";
+    while (this.#pos < this.#formula.length) {
+      const ch = this.#formula[this.#pos];
+      if (ch === '"') {
+        this.#pos++;
+        if (this.#formula[this.#pos] === '"') {
+          value2 += '"';
+          this.#pos++;
+        } else return makeToken(1 /* String */, value2, start);
       } else {
-        if (__privateGet(this, _formula)[__privateGet(this, _pos)] !== "!") {
-          throw new FormulaException(`Expected '!' after quoted sheet name at position ${start}.`);
-        }
-        __privateWrapper(this, _pos)._++;
-        const cellRef = __privateMethod(this, _FormulaLexer_instances, readCellRefChars_fn).call(this);
-        return makeToken(22 /* SheetReference */, `${sheetName}!${cellRef}`, start);
+        value2 += ch;
+        this.#pos++;
       }
-    } else {
-      sheetName += ch;
-      __privateWrapper(this, _pos)._++;
     }
-  }
-  throw new FormulaException(`Unterminated quoted sheet name at position ${start}.`);
-};
-readNumber_fn = function() {
-  const start = __privateGet(this, _pos);
-  let raw = "";
-  let hasDot = false;
-  let hasE = false;
-  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
-    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
-    if (/\d/.test(ch)) {
-      raw += ch;
-      __privateWrapper(this, _pos)._++;
-    } else if (ch === "." && !hasDot && !hasE) {
-      hasDot = true;
-      raw += ch;
-      __privateWrapper(this, _pos)._++;
-    } else if ((ch === "e" || ch === "E") && !hasE && raw.length > 0) {
-      hasE = true;
-      raw += ch;
-      __privateWrapper(this, _pos)._++;
-      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "+" || __privateGet(this, _formula)[__privateGet(this, _pos)] === "-") {
-        raw += __privateGet(this, _formula)[__privateWrapper(this, _pos)._++];
+    throw new FormulaException(`Unterminated string at position ${start}.`);
+  }
+  #readErrorLiteral() {
+    const start = this.#pos;
+    let raw = "#";
+    this.#pos++;
+    while (this.#pos < this.#formula.length) {
+      const ch = this.#formula[this.#pos];
+      if (/[a-zA-Z0-9/]/.test(ch) || ch === "!" || ch === "?") {
+        raw += ch;
+        this.#pos++;
+        if (ch === "!" || ch === "?") break;
+      } else break;
+    }
+    const upper2 = raw.toUpperCase();
+    if (!KNOWN_ERRORS.has(upper2)) {
+      throw new FormulaException(`Unknown error literal "${raw}" at position ${start}.`);
+    }
+    return makeToken(30 /* ErrorLiteral */, upper2, start);
+  }
+  #readQuotedSheetRef() {
+    const start = this.#pos++;
+    let sheetName = "";
+    while (this.#pos < this.#formula.length) {
+      const ch = this.#formula[this.#pos];
+      if (ch === "'") {
+        this.#pos++;
+        if (this.#formula[this.#pos] === "'") {
+          sheetName += "'";
+          this.#pos++;
+        } else {
+          if (this.#formula[this.#pos] !== "!") {
+            throw new FormulaException(`Expected '!' after quoted sheet name at position ${start}.`);
+          }
+          this.#pos++;
+          const cellRef = this.#readCellRefChars();
+          return makeToken(22 /* SheetReference */, `${sheetName}!${cellRef}`, start);
+        }
+      } else {
+        sheetName += ch;
+        this.#pos++;
       }
-    } else break;
-  }
-  return makeToken(0 /* Number */, raw, start);
-};
-readIdentifier_fn = function() {
-  const start = __privateGet(this, _pos);
-  let raw = "";
-  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
-    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
-    if (/[a-zA-Z0-9_$.]/.test(ch)) {
-      raw += ch;
-      __privateWrapper(this, _pos)._++;
-    } else break;
-  }
-  let upper2 = raw.toUpperCase();
-  raw = __privateMethod(this, _FormulaLexer_instances, stripReservedPrefixes_fn).call(this, raw, upper2);
-  if (raw.length !== upper2.length) upper2 = upper2.slice(upper2.length - raw.length);
-  if (upper2 === "TRUE") return makeToken(2 /* Boolean */, "TRUE", start);
-  if (upper2 === "FALSE") return makeToken(2 /* Boolean */, "FALSE", start);
-  if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "!") {
-    __privateWrapper(this, _pos)._++;
-    const cellRef = __privateMethod(this, _FormulaLexer_instances, readCellRefChars_fn).call(this);
-    return makeToken(22 /* SheetReference */, `${raw}!${cellRef}`, start);
-  }
-  __privateMethod(this, _FormulaLexer_instances, skipWhitespace_fn).call(this);
-  if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "(") {
-    return makeToken(5 /* Function */, upper2, start);
-  }
-  const stripped = raw.replace(/\$/g, "");
-  if (isCellRef(stripped)) {
-    if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "#") {
-      __privateWrapper(this, _pos)._++;
-      return makeToken(24 /* SpillReference */, stripped, start);
-    }
-    return makeToken(3 /* CellReference */, stripped, start);
-  }
-  return makeToken(23 /* NamedRange */, raw, start);
-};
-/**
- * Drops Excel's storage-level name decorations. They carry no semantics — the
- * writer stamps them so an older reader fails loudly instead of silently
- * mis-evaluating — and they *stack*: `_xlfn._xlws.FILTER` wears two. Stripping
- * one prefix once, as this used to, leaves `_XLWS.FILTER` unresolvable.
- *
- * Every identifier in every formula passes through here, so the common case is
- * gated on a single char-code test: a name not starting with '_' returns
- * untouched without so much as a comparison against the prefix table.
- */
-stripReservedPrefixes_fn = function(raw, upper2) {
-  if (raw.charCodeAt(0) !== UNDERSCORE) return raw;
-  let cut = 0;
-  outer: for (; ; ) {
-    for (const prefix of RESERVED_PREFIXES) {
-      if (upper2.startsWith(prefix, cut)) {
-        cut += prefix.length;
-        continue outer;
+    }
+    throw new FormulaException(`Unterminated quoted sheet name at position ${start}.`);
+  }
+  #readNumber() {
+    const start = this.#pos;
+    let raw = "";
+    let hasDot = false;
+    let hasE = false;
+    while (this.#pos < this.#formula.length) {
+      const ch = this.#formula[this.#pos];
+      if (/\d/.test(ch)) {
+        raw += ch;
+        this.#pos++;
+      } else if (ch === "." && !hasDot && !hasE) {
+        hasDot = true;
+        raw += ch;
+        this.#pos++;
+      } else if ((ch === "e" || ch === "E") && !hasE && raw.length > 0) {
+        hasE = true;
+        raw += ch;
+        this.#pos++;
+        if (this.#formula[this.#pos] === "+" || this.#formula[this.#pos] === "-") {
+          raw += this.#formula[this.#pos++];
+        }
+      } else break;
+    }
+    return makeToken(0 /* Number */, raw, start);
+  }
+  #readIdentifier() {
+    const start = this.#pos;
+    let raw = "";
+    while (this.#pos < this.#formula.length) {
+      const ch = this.#formula[this.#pos];
+      if (/[a-zA-Z0-9_$.]/.test(ch)) {
+        raw += ch;
+        this.#pos++;
+      } else break;
+    }
+    let upper2 = raw.toUpperCase();
+    raw = this.#stripReservedPrefixes(raw, upper2);
+    if (raw.length !== upper2.length) upper2 = upper2.slice(upper2.length - raw.length);
+    if (upper2 === "TRUE") return makeToken(2 /* Boolean */, "TRUE", start);
+    if (upper2 === "FALSE") return makeToken(2 /* Boolean */, "FALSE", start);
+    if (this.#formula[this.#pos] === "!") {
+      this.#pos++;
+      const cellRef = this.#readCellRefChars();
+      return makeToken(22 /* SheetReference */, `${raw}!${cellRef}`, start);
+    }
+    this.#skipWhitespace();
+    if (this.#formula[this.#pos] === "(") {
+      return makeToken(5 /* Function */, upper2, start);
+    }
+    const stripped = raw.replace(/\$/g, "");
+    if (isCellRef(stripped)) {
+      if (this.#formula[this.#pos] === "#") {
+        this.#pos++;
+        return makeToken(24 /* SpillReference */, stripped, start);
       }
+      return makeToken(3 /* CellReference */, stripped, start);
     }
-    break;
+    return makeToken(23 /* NamedRange */, raw, start);
   }
-  return cut > 0 && cut < raw.length ? raw.slice(cut) : raw;
-};
-readCellRefChars_fn = function() {
-  let ref = "";
-  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
-    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
-    if (/[a-zA-Z0-9$]/.test(ch)) {
-      ref += ch;
-      __privateWrapper(this, _pos)._++;
-    } else break;
-  }
-  return ref.replace(/\$/g, "");
-};
-readOperator_fn = function() {
-  const start = __privateGet(this, _pos);
-  const ch = __privateGet(this, _formula)[__privateWrapper(this, _pos)._++];
-  switch (ch) {
-    case "(":
-      return makeToken(6 /* LeftParen */, "(", start);
-    case ")":
-      return makeToken(7 /* RightParen */, ")", start);
-    case ",":
-      return makeToken(8 /* Comma */, ",", start);
-    case ":":
-      return makeToken(4 /* Colon */, ":", start);
-    case "+":
-      return makeToken(9 /* Plus */, "+", start);
-    case "-":
-      return makeToken(10 /* Minus */, "-", start);
-    case "*":
-      return makeToken(11 /* Multiply */, "*", start);
-    case "/":
-      return makeToken(12 /* Divide */, "/", start);
-    case "^":
-      return makeToken(13 /* Power */, "^", start);
-    case "%":
-      return makeToken(14 /* Percent */, "%", start);
-    case "&":
-      return makeToken(15 /* Ampersand */, "&", start);
-    case "=":
-      return makeToken(16 /* Equal */, "=", start);
-    case "@":
-      return makeToken(26 /* AtSign */, "@", start);
-    case "!":
-      return makeToken(25 /* Exclamation */, "!", start);
-    case "{":
-      return makeToken(27 /* LeftBrace */, "{", start);
-    case "}":
-      return makeToken(28 /* RightBrace */, "}", start);
-    // Inside an array constant ';' separates rows. Excel always stores ',' as
-    // the argument separator regardless of locale, so ';' has no other role.
-    case ";":
-      return makeToken(29 /* Semicolon */, ";", start);
-    case "<":
-      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === ">") {
-        __privateWrapper(this, _pos)._++;
-        return makeToken(17 /* NotEqual */, "<>", start);
-      }
-      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "=") {
-        __privateWrapper(this, _pos)._++;
-        return makeToken(19 /* LessThanOrEqual */, "<=", start);
-      }
-      return makeToken(18 /* LessThan */, "<", start);
-    case ">":
-      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "=") {
-        __privateWrapper(this, _pos)._++;
-        return makeToken(21 /* GreaterThanOrEqual */, ">=", start);
+  /**
+   * Drops Excel's storage-level name decorations. They carry no semantics — the
+   * writer stamps them so an older reader fails loudly instead of silently
+   * mis-evaluating — and they *stack*: `_xlfn._xlws.FILTER` wears two. Stripping
+   * one prefix once, as this used to, leaves `_XLWS.FILTER` unresolvable.
+   *
+   * Every identifier in every formula passes through here, so the common case is
+   * gated on a single char-code test: a name not starting with '_' returns
+   * untouched without so much as a comparison against the prefix table.
+   */
+  #stripReservedPrefixes(raw, upper2) {
+    if (raw.charCodeAt(0) !== UNDERSCORE) return raw;
+    let cut = 0;
+    outer: for (; ; ) {
+      for (const prefix of RESERVED_PREFIXES) {
+        if (upper2.startsWith(prefix, cut)) {
+          cut += prefix.length;
+          continue outer;
+        }
       }
-      return makeToken(20 /* GreaterThan */, ">", start);
-    default:
-      throw new FormulaException(`Unexpected character '${ch}' at position ${start}.`);
+      break;
+    }
+    return cut > 0 && cut < raw.length ? raw.slice(cut) : raw;
+  }
+  #readCellRefChars() {
+    let ref = "";
+    while (this.#pos < this.#formula.length) {
+      const ch = this.#formula[this.#pos];
+      if (/[a-zA-Z0-9$]/.test(ch)) {
+        ref += ch;
+        this.#pos++;
+      } else break;
+    }
+    return ref.replace(/\$/g, "");
+  }
+  #readOperator() {
+    const start = this.#pos;
+    const ch = this.#formula[this.#pos++];
+    switch (ch) {
+      case "(":
+        return makeToken(6 /* LeftParen */, "(", start);
+      case ")":
+        return makeToken(7 /* RightParen */, ")", start);
+      case ",":
+        return makeToken(8 /* Comma */, ",", start);
+      case ":":
+        return makeToken(4 /* Colon */, ":", start);
+      case "+":
+        return makeToken(9 /* Plus */, "+", start);
+      case "-":
+        return makeToken(10 /* Minus */, "-", start);
+      case "*":
+        return makeToken(11 /* Multiply */, "*", start);
+      case "/":
+        return makeToken(12 /* Divide */, "/", start);
+      case "^":
+        return makeToken(13 /* Power */, "^", start);
+      case "%":
+        return makeToken(14 /* Percent */, "%", start);
+      case "&":
+        return makeToken(15 /* Ampersand */, "&", start);
+      case "=":
+        return makeToken(16 /* Equal */, "=", start);
+      case "@":
+        return makeToken(26 /* AtSign */, "@", start);
+      case "!":
+        return makeToken(25 /* Exclamation */, "!", start);
+      case "{":
+        return makeToken(27 /* LeftBrace */, "{", start);
+      case "}":
+        return makeToken(28 /* RightBrace */, "}", start);
+      // Inside an array constant ';' separates rows. Excel always stores ',' as
+      // the argument separator regardless of locale, so ';' has no other role.
+      case ";":
+        return makeToken(29 /* Semicolon */, ";", start);
+      case "<":
+        if (this.#formula[this.#pos] === ">") {
+          this.#pos++;
+          return makeToken(17 /* NotEqual */, "<>", start);
+        }
+        if (this.#formula[this.#pos] === "=") {
+          this.#pos++;
+          return makeToken(19 /* LessThanOrEqual */, "<=", start);
+        }
+        return makeToken(18 /* LessThan */, "<", start);
+      case ">":
+        if (this.#formula[this.#pos] === "=") {
+          this.#pos++;
+          return makeToken(21 /* GreaterThanOrEqual */, ">=", start);
+        }
+        return makeToken(20 /* GreaterThan */, ">", start);
+      default:
+        throw new FormulaException(`Unexpected character '${ch}' at position ${start}.`);
+    }
   }
-};
-skipWhitespace_fn = function() {
-  while (__privateGet(this, _pos) < __privateGet(this, _formula).length && /\s/.test(__privateGet(this, _formula)[__privateGet(this, _pos)])) {
-    __privateWrapper(this, _pos)._++;
+  #skipWhitespace() {
+    while (this.#pos < this.#formula.length && /\s/.test(this.#formula[this.#pos])) {
+      this.#pos++;
+    }
   }
 };
 function isCellRef(s) {
@@ -768,6 +747,7 @@ var NumberNode = class extends FormulaNode {
     super();
     this.value = value2;
   }
+  value;
   evaluate() {
     return FormulaValue.number(this.value);
   }
@@ -777,6 +757,7 @@ var StringNode = class extends FormulaNode {
     super();
     this.value = value2;
   }
+  value;
   evaluate() {
     return FormulaValue.text(this.value);
   }
@@ -786,6 +767,7 @@ var BooleanNode = class extends FormulaNode {
     super();
     this.value = value2;
   }
+  value;
   evaluate() {
     return FormulaValue.boolean(this.value);
   }
@@ -795,29 +777,30 @@ var ErrorNode = class extends FormulaNode {
     super();
     this.errorValue = errorValue;
   }
+  errorValue;
   evaluate() {
     return this.errorValue;
   }
 };
-var _value;
 var ArrayLiteralNode = class extends FormulaNode {
   constructor(array) {
     super();
     this.array = array;
-    __privateAdd(this, _value);
-    __privateSet(this, _value, FormulaValue.array(array));
+    this.#value = FormulaValue.array(array);
   }
+  array;
+  #value;
   evaluate() {
-    return __privateGet(this, _value);
+    return this.#value;
   }
 };
-_value = new WeakMap();
 var ValueNode = class extends FormulaNode {
   /** Mutable so one wrapper can be re-pointed across a lifted call's cells. */
   constructor(value2) {
     super();
     this.value = value2;
   }
+  value;
   evaluate() {
     return this.value;
   }
@@ -832,6 +815,7 @@ var CellReferenceNode = class extends FormulaNode {
     super();
     this.reference = reference;
   }
+  reference;
   evaluate(ctx) {
     return ctx.getCellValue(this.reference);
   }
@@ -842,6 +826,8 @@ var RangeReferenceNode = class extends FormulaNode {
     this.startRef = startRef;
     this.endRef = endRef;
   }
+  startRef;
+  endRef;
   evaluate(ctx) {
     return ctx.getRangeValues(this.startRef, this.endRef);
   }
@@ -852,6 +838,8 @@ var SheetCellReferenceNode = class extends FormulaNode {
     this.sheetName = sheetName;
     this.cellReference = cellReference;
   }
+  sheetName;
+  cellReference;
   evaluate(ctx) {
     return ctx.getSheetCellValue(this.sheetName, this.cellReference);
   }
@@ -863,6 +851,9 @@ var SheetRangeReferenceNode = class extends FormulaNode {
     this.startRef = startRef;
     this.endRef = endRef;
   }
+  sheetName;
+  startRef;
+  endRef;
   evaluate(ctx) {
     return ctx.getSheetRangeValues(this.sheetName, this.startRef, this.endRef);
   }
@@ -876,6 +867,11 @@ var FullRangeReferenceNode = class extends FormulaNode {
     this.endRow = endRow;
     this.sheetName = sheetName;
   }
+  startCol;
+  endCol;
+  startRow;
+  endRow;
+  sheetName;
   evaluate(ctx) {
     return this.sheetName === void 0 ? ctx.getFullRangeValues(this.startCol, this.endCol, this.startRow, this.endRow) : ctx.getSheetFullRangeValues(this.sheetName, this.startCol, this.endCol, this.startRow, this.endRow);
   }
@@ -885,6 +881,7 @@ var NamedRangeNode = class extends FormulaNode {
     super();
     this.name = name;
   }
+  name;
   evaluate(ctx) {
     return ctx.resolveNamedRange(this.name);
   }
@@ -894,6 +891,7 @@ var SpillReferenceNode = class extends FormulaNode {
     super();
     this.anchorRef = anchorRef;
   }
+  anchorRef;
   evaluate(ctx) {
     return ctx.resolveSpillRange(this.anchorRef);
   }
@@ -919,15 +917,16 @@ var UnaryOperator = /* @__PURE__ */ ((UnaryOperator2) => {
   UnaryOperator2[UnaryOperator2["Percent"] = 2] = "Percent";
   return UnaryOperator2;
 })(UnaryOperator || {});
-var _BinaryOpNode_instances, evalScalar_fn;
 var BinaryOpNode = class extends FormulaNode {
   constructor(left2, op, right2) {
     super();
     this.left = left2;
     this.op = op;
     this.right = right2;
-    __privateAdd(this, _BinaryOpNode_instances);
   }
+  left;
+  op;
+  right;
   evaluate(ctx) {
     const l = this.left.evaluate(ctx);
     const r = this.right.evaluate(ctx);
@@ -935,46 +934,45 @@ var BinaryOpNode = class extends FormulaNode {
       const la = l.isArray ? l.arrayVal : ArrayValue.fromScalar(l);
       const ra = r.isArray ? r.arrayVal : ArrayValue.fromScalar(r);
       return FormulaValue.array(
-        ArrayValue.broadcast(la, ra, (a, b) => __privateMethod(this, _BinaryOpNode_instances, evalScalar_fn).call(this, a, b))
+        ArrayValue.broadcast(la, ra, (a, b) => this.#evalScalar(a, b))
       );
     }
-    return __privateMethod(this, _BinaryOpNode_instances, evalScalar_fn).call(this, l, r);
-  }
-};
-_BinaryOpNode_instances = new WeakSet();
-evalScalar_fn = function(l, r) {
-  const op = this.op;
-  if (op === 6 /* Equal */) return FormulaValue.boolean(FormulaValue.areEqual(l, r));
-  if (op === 7 /* NotEqual */) return FormulaValue.boolean(!FormulaValue.areEqual(l, r));
-  if (op === 8 /* LessThan */) return FormulaValue.boolean(FormulaValue.compare(l, r) < 0);
-  if (op === 9 /* LessThanOrEqual */) return FormulaValue.boolean(FormulaValue.compare(l, r) <= 0);
-  if (op === 10 /* GreaterThan */) return FormulaValue.boolean(FormulaValue.compare(l, r) > 0);
-  if (op === 11 /* GreaterThanOrEqual */) return FormulaValue.boolean(FormulaValue.compare(l, r) >= 0);
-  if (op === 5 /* Concatenate */) {
-    if (l.isError) return l;
-    if (r.isError) return r;
-    return FormulaValue.text(l.asText() + r.asText());
-  }
-  const ln2 = l.coerceToNumber();
-  if (ln2.isError) return ln2;
-  const rn = r.coerceToNumber();
-  if (rn.isError) return rn;
-  const lv = ln2.numberValue;
-  const rv = rn.numberValue;
-  switch (op) {
-    case 0 /* Add */:
-      return FormulaValue.number(lv + rv);
-    case 1 /* Subtract */:
-      return FormulaValue.number(lv - rv);
-    case 2 /* Multiply */:
-      return FormulaValue.number(lv * rv);
-    case 3 /* Divide */:
-      if (rv === 0) return FormulaValue.errorDiv0;
-      return FormulaValue.number(lv / rv);
-    case 4 /* Power */:
-      return FormulaValue.number(Math.pow(lv, rv));
-    default:
-      return FormulaValue.errorValue;
+    return this.#evalScalar(l, r);
+  }
+  #evalScalar(l, r) {
+    const op = this.op;
+    if (op === 6 /* Equal */) return FormulaValue.boolean(FormulaValue.areEqual(l, r));
+    if (op === 7 /* NotEqual */) return FormulaValue.boolean(!FormulaValue.areEqual(l, r));
+    if (op === 8 /* LessThan */) return FormulaValue.boolean(FormulaValue.compare(l, r) < 0);
+    if (op === 9 /* LessThanOrEqual */) return FormulaValue.boolean(FormulaValue.compare(l, r) <= 0);
+    if (op === 10 /* GreaterThan */) return FormulaValue.boolean(FormulaValue.compare(l, r) > 0);
+    if (op === 11 /* GreaterThanOrEqual */) return FormulaValue.boolean(FormulaValue.compare(l, r) >= 0);
+    if (op === 5 /* Concatenate */) {
+      if (l.isError) return l;
+      if (r.isError) return r;
+      return FormulaValue.text(l.asText() + r.asText());
+    }
+    const ln2 = l.coerceToNumber();
+    if (ln2.isError) return ln2;
+    const rn = r.coerceToNumber();
+    if (rn.isError) return rn;
+    const lv = ln2.numberValue;
+    const rv = rn.numberValue;
+    switch (op) {
+      case 0 /* Add */:
+        return FormulaValue.number(lv + rv);
+      case 1 /* Subtract */:
+        return FormulaValue.number(lv - rv);
+      case 2 /* Multiply */:
+        return FormulaValue.number(lv * rv);
+      case 3 /* Divide */:
+        if (rv === 0) return FormulaValue.errorDiv0;
+        return FormulaValue.number(lv / rv);
+      case 4 /* Power */:
+        return FormulaValue.number(Math.pow(lv, rv));
+      default:
+        return FormulaValue.errorValue;
+    }
   }
 };
 var UnaryOpNode = class extends FormulaNode {
@@ -983,6 +981,8 @@ var UnaryOpNode = class extends FormulaNode {
     this.op = op;
     this.operand = operand;
   }
+  op;
+  operand;
   evaluate(ctx) {
     const val = this.operand.evaluate(ctx);
     if (this.op === 1 /* Plus */) {
@@ -1006,6 +1006,7 @@ var ImplicitIntersectionNode = class extends FormulaNode {
     super();
     this.inner = inner;
   }
+  inner;
   evaluate(ctx) {
     const val = this.inner.evaluate(ctx);
     if (!val.isArray) return val;
@@ -1018,6 +1019,8 @@ var FunctionCallNode = class extends FormulaNode {
     this.functionName = functionName;
     this.args = args;
   }
+  functionName;
+  args;
   evaluate(ctx) {
     return ctx.evaluateFunction(this.functionName, this.args);
   }
@@ -1084,6 +1087,8 @@ var CallNode = class extends FormulaNode {
     this.callee = callee;
     this.args = args;
   }
+  callee;
+  args;
   evaluate(ctx) {
     const fn = this.callee.evaluate(ctx);
     if (fn.isError) return fn;
@@ -1099,317 +1104,313 @@ var CallNode = class extends FormulaNode {
 };
 
 // src/formula-parser.ts
-var _tokens, _pos2, _FormulaParser_instances, current_get, advance_fn, expect_fn, parseComparison_fn, parseConcatenation_fn, parseAddSub_fn, parseMulDiv_fn, parseUnary_fn, parsePower_fn, parsePercent_fn, parsePostfix_fn, parsePrimary_fn, tryParseFullRange_fn, parseArrayLiteral_fn, parseArrayElement_fn, parseFunction_fn, parseArgList_fn;
 var FormulaParser = class {
+  #tokens;
+  #pos = 0;
   constructor(tokens) {
-    __privateAdd(this, _FormulaParser_instances);
-    __privateAdd(this, _tokens);
-    __privateAdd(this, _pos2, 0);
-    __privateSet(this, _tokens, tokens);
+    this.#tokens = tokens;
   }
   parse() {
-    __privateSet(this, _pos2, 0);
-    const node = __privateMethod(this, _FormulaParser_instances, parseComparison_fn).call(this);
-    if (__privateGet(this, _FormulaParser_instances, current_get).type !== 31 /* EOF */) {
+    this.#pos = 0;
+    const node = this.#parseComparison();
+    if (this.#current.type !== 31 /* EOF */) {
       throw new FormulaException(
-        `Unexpected token '${__privateGet(this, _FormulaParser_instances, current_get).value}' at position ${__privateGet(this, _FormulaParser_instances, current_get).position}.`
+        `Unexpected token '${this.#current.value}' at position ${this.#current.position}.`
       );
     }
     return node;
   }
-};
-_tokens = new WeakMap();
-_pos2 = new WeakMap();
-_FormulaParser_instances = new WeakSet();
-current_get = function() {
-  return __privateGet(this, _tokens)[__privateGet(this, _pos2)] ?? { type: 31 /* EOF */, value: "", position: -1 };
-};
-advance_fn = function() {
-  const t = __privateGet(this, _FormulaParser_instances, current_get);
-  __privateWrapper(this, _pos2)._++;
-  return t;
-};
-expect_fn = function(type) {
-  if (__privateGet(this, _FormulaParser_instances, current_get).type !== type) {
-    throw new FormulaException(
-      `Expected token type ${type} but got ${__privateGet(this, _FormulaParser_instances, current_get).type} ('${__privateGet(this, _FormulaParser_instances, current_get).value}') at position ${__privateGet(this, _FormulaParser_instances, current_get).position}.`
-    );
-  }
-  return __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-};
-// ── Precedence levels ──────────────────────────────────────────────────────
-parseComparison_fn = function() {
-  let left2 = __privateMethod(this, _FormulaParser_instances, parseConcatenation_fn).call(this);
-  while (true) {
-    const op = comparisonOp(__privateGet(this, _FormulaParser_instances, current_get).type);
-    if (op === null) break;
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    left2 = new BinaryOpNode(left2, op, __privateMethod(this, _FormulaParser_instances, parseConcatenation_fn).call(this));
-  }
-  return left2;
-};
-parseConcatenation_fn = function() {
-  let left2 = __privateMethod(this, _FormulaParser_instances, parseAddSub_fn).call(this);
-  while (__privateGet(this, _FormulaParser_instances, current_get).type === 15 /* Ampersand */) {
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    left2 = new BinaryOpNode(left2, 5 /* Concatenate */, __privateMethod(this, _FormulaParser_instances, parseAddSub_fn).call(this));
-  }
-  return left2;
-};
-parseAddSub_fn = function() {
-  let left2 = __privateMethod(this, _FormulaParser_instances, parseMulDiv_fn).call(this);
-  while (true) {
-    const t = __privateGet(this, _FormulaParser_instances, current_get).type;
-    if (t !== 9 /* Plus */ && t !== 10 /* Minus */) break;
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    const op = t === 9 /* Plus */ ? 0 /* Add */ : 1 /* Subtract */;
-    left2 = new BinaryOpNode(left2, op, __privateMethod(this, _FormulaParser_instances, parseMulDiv_fn).call(this));
-  }
-  return left2;
-};
-parseMulDiv_fn = function() {
-  let left2 = __privateMethod(this, _FormulaParser_instances, parseUnary_fn).call(this);
-  while (true) {
-    const t = __privateGet(this, _FormulaParser_instances, current_get).type;
-    if (t !== 11 /* Multiply */ && t !== 12 /* Divide */) break;
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    const op = t === 11 /* Multiply */ ? 2 /* Multiply */ : 3 /* Divide */;
-    left2 = new BinaryOpNode(left2, op, __privateMethod(this, _FormulaParser_instances, parseUnary_fn).call(this));
-  }
-  return left2;
-};
-parseUnary_fn = function() {
-  if (__privateGet(this, _FormulaParser_instances, current_get).type === 10 /* Minus */) {
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    return new UnaryOpNode(0 /* Negate */, __privateMethod(this, _FormulaParser_instances, parsePower_fn).call(this));
+  // ── Token helpers ──────────────────────────────────────────────────────────
+  get #current() {
+    return this.#tokens[this.#pos] ?? { type: 31 /* EOF */, value: "", position: -1 };
   }
-  if (__privateGet(this, _FormulaParser_instances, current_get).type === 9 /* Plus */) {
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    return new UnaryOpNode(1 /* Plus */, __privateMethod(this, _FormulaParser_instances, parsePower_fn).call(this));
+  #advance() {
+    const t = this.#current;
+    this.#pos++;
+    return t;
   }
-  if (__privateGet(this, _FormulaParser_instances, current_get).type === 26 /* AtSign */) {
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    return new ImplicitIntersectionNode(__privateMethod(this, _FormulaParser_instances, parsePower_fn).call(this));
-  }
-  return __privateMethod(this, _FormulaParser_instances, parsePower_fn).call(this);
-};
-parsePower_fn = function() {
-  const left2 = __privateMethod(this, _FormulaParser_instances, parsePercent_fn).call(this);
-  if (__privateGet(this, _FormulaParser_instances, current_get).type === 13 /* Power */) {
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    return new BinaryOpNode(left2, 4 /* Power */, __privateMethod(this, _FormulaParser_instances, parseUnary_fn).call(this));
+  #expect(type) {
+    if (this.#current.type !== type) {
+      throw new FormulaException(
+        `Expected token type ${type} but got ${this.#current.type} ('${this.#current.value}') at position ${this.#current.position}.`
+      );
+    }
+    return this.#advance();
+  }
+  // ── Precedence levels ──────────────────────────────────────────────────────
+  #parseComparison() {
+    let left2 = this.#parseConcatenation();
+    while (true) {
+      const op = comparisonOp(this.#current.type);
+      if (op === null) break;
+      this.#advance();
+      left2 = new BinaryOpNode(left2, op, this.#parseConcatenation());
+    }
+    return left2;
+  }
+  #parseConcatenation() {
+    let left2 = this.#parseAddSub();
+    while (this.#current.type === 15 /* Ampersand */) {
+      this.#advance();
+      left2 = new BinaryOpNode(left2, 5 /* Concatenate */, this.#parseAddSub());
+    }
+    return left2;
+  }
+  #parseAddSub() {
+    let left2 = this.#parseMulDiv();
+    while (true) {
+      const t = this.#current.type;
+      if (t !== 9 /* Plus */ && t !== 10 /* Minus */) break;
+      this.#advance();
+      const op = t === 9 /* Plus */ ? 0 /* Add */ : 1 /* Subtract */;
+      left2 = new BinaryOpNode(left2, op, this.#parseMulDiv());
+    }
+    return left2;
+  }
+  #parseMulDiv() {
+    let left2 = this.#parseUnary();
+    while (true) {
+      const t = this.#current.type;
+      if (t !== 11 /* Multiply */ && t !== 12 /* Divide */) break;
+      this.#advance();
+      const op = t === 11 /* Multiply */ ? 2 /* Multiply */ : 3 /* Divide */;
+      left2 = new BinaryOpNode(left2, op, this.#parseUnary());
+    }
+    return left2;
+  }
+  #parseUnary() {
+    if (this.#current.type === 10 /* Minus */) {
+      this.#advance();
+      return new UnaryOpNode(0 /* Negate */, this.#parsePower());
+    }
+    if (this.#current.type === 9 /* Plus */) {
+      this.#advance();
+      return new UnaryOpNode(1 /* Plus */, this.#parsePower());
+    }
+    if (this.#current.type === 26 /* AtSign */) {
+      this.#advance();
+      return new ImplicitIntersectionNode(this.#parsePower());
+    }
+    return this.#parsePower();
+  }
+  #parsePower() {
+    const left2 = this.#parsePercent();
+    if (this.#current.type === 13 /* Power */) {
+      this.#advance();
+      return new BinaryOpNode(left2, 4 /* Power */, this.#parseUnary());
+    }
+    return left2;
+  }
+  #parsePercent() {
+    let node = this.#parsePostfix();
+    while (this.#current.type === 14 /* Percent */) {
+      this.#advance();
+      node = new UnaryOpNode(2 /* Percent */, node);
+    }
+    return node;
   }
-  return left2;
-};
-parsePercent_fn = function() {
-  let node = __privateMethod(this, _FormulaParser_instances, parsePostfix_fn).call(this);
-  while (__privateGet(this, _FormulaParser_instances, current_get).type === 14 /* Percent */) {
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    node = new UnaryOpNode(2 /* Percent */, node);
+  /** Handles postfix call syntax on an expression, e.g. LAMBDA(x,x+1)(5). */
+  #parsePostfix() {
+    let node = this.#parsePrimary();
+    while (this.#current.type === 6 /* LeftParen */) {
+      this.#advance();
+      node = new CallNode(node, this.#parseArgList());
+    }
+    return node;
   }
-  return node;
-};
-/** Handles postfix call syntax on an expression, e.g. LAMBDA(x,x+1)(5). */
-parsePostfix_fn = function() {
-  let node = __privateMethod(this, _FormulaParser_instances, parsePrimary_fn).call(this);
-  while (__privateGet(this, _FormulaParser_instances, current_get).type === 6 /* LeftParen */) {
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-    node = new CallNode(node, __privateMethod(this, _FormulaParser_instances, parseArgList_fn).call(this));
-  }
-  return node;
-};
-parsePrimary_fn = function() {
-  const token = __privateGet(this, _FormulaParser_instances, current_get);
-  switch (token.type) {
-    case 0 /* Number */: {
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      if (__privateGet(this, _FormulaParser_instances, current_get).type === 4 /* Colon */) {
-        const full = __privateMethod(this, _FormulaParser_instances, tryParseFullRange_fn).call(this, token.value);
-        if (full) return full;
+  #parsePrimary() {
+    const token = this.#current;
+    switch (token.type) {
+      case 0 /* Number */: {
+        this.#advance();
+        if (this.#current.type === 4 /* Colon */) {
+          const full = this.#tryParseFullRange(token.value);
+          if (full) return full;
+        }
+        const n = parseFloat(token.value);
+        if (isNaN(n)) throw new FormulaException(`Invalid number: ${token.value}`);
+        return new NumberNode(n);
+      }
+      case 1 /* String */:
+        this.#advance();
+        return new StringNode(token.value);
+      case 2 /* Boolean */:
+        this.#advance();
+        return new BooleanNode(token.value === "TRUE");
+      case 30 /* ErrorLiteral */:
+        this.#advance();
+        return new ErrorNode(FormulaValue.error(FormulaValue.errorFromString(token.value)));
+      case 3 /* CellReference */: {
+        this.#advance();
+        if (this.#current.type === 4 /* Colon */) {
+          this.#advance();
+          const end = this.#expect(3 /* CellReference */);
+          return new RangeReferenceNode(token.value, end.value);
+        }
+        return new CellReferenceNode(token.value);
+      }
+      case 22 /* SheetReference */: {
+        this.#advance();
+        const parts = token.value.split("!");
+        const sheetName = parts[0];
+        const cellRef = parts[1] ?? "";
+        if (this.#current.type === 4 /* Colon */) {
+          const full = this.#tryParseFullRange(cellRef, sheetName);
+          if (full) return full;
+          this.#advance();
+          const end = this.#expect(3 /* CellReference */);
+          return new SheetRangeReferenceNode(sheetName, cellRef, end.value);
+        }
+        return new SheetCellReferenceNode(sheetName, cellRef);
       }
-      const n = parseFloat(token.value);
-      if (isNaN(n)) throw new FormulaException(`Invalid number: ${token.value}`);
-      return new NumberNode(n);
-    }
-    case 1 /* String */:
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      return new StringNode(token.value);
-    case 2 /* Boolean */:
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      return new BooleanNode(token.value === "TRUE");
-    case 30 /* ErrorLiteral */:
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      return new ErrorNode(FormulaValue.error(FormulaValue.errorFromString(token.value)));
-    case 3 /* CellReference */: {
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      if (__privateGet(this, _FormulaParser_instances, current_get).type === 4 /* Colon */) {
-        __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-        const end = __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 3 /* CellReference */);
-        return new RangeReferenceNode(token.value, end.value);
+      case 23 /* NamedRange */: {
+        this.#advance();
+        if (this.#current.type === 4 /* Colon */) {
+          const full = this.#tryParseFullRange(token.value);
+          if (full) return full;
+        }
+        return new NamedRangeNode(token.value);
       }
-      return new CellReferenceNode(token.value);
-    }
-    case 22 /* SheetReference */: {
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      const parts = token.value.split("!");
-      const sheetName = parts[0];
-      const cellRef = parts[1] ?? "";
-      if (__privateGet(this, _FormulaParser_instances, current_get).type === 4 /* Colon */) {
-        const full = __privateMethod(this, _FormulaParser_instances, tryParseFullRange_fn).call(this, cellRef, sheetName);
-        if (full) return full;
-        __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-        const end = __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 3 /* CellReference */);
-        return new SheetRangeReferenceNode(sheetName, cellRef, end.value);
+      case 24 /* SpillReference */:
+        this.#advance();
+        return new SpillReferenceNode(token.value);
+      case 5 /* Function */:
+        return this.#parseFunction();
+      case 27 /* LeftBrace */:
+        return this.#parseArrayLiteral();
+      case 6 /* LeftParen */: {
+        this.#advance();
+        const expr = this.#parseComparison();
+        this.#expect(7 /* RightParen */);
+        return expr;
       }
-      return new SheetCellReferenceNode(sheetName, cellRef);
+      default:
+        throw new FormulaException(
+          `Unexpected token '${token.value}' (type ${token.type}) at position ${token.position}.`
+        );
     }
-    case 23 /* NamedRange */: {
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      if (__privateGet(this, _FormulaParser_instances, current_get).type === 4 /* Colon */) {
-        const full = __privateMethod(this, _FormulaParser_instances, tryParseFullRange_fn).call(this, token.value);
-        if (full) return full;
+  }
+  /**
+   * Completes a whole-column or whole-row reference whose first half has already
+   * been consumed and whose ':' is the current token. Returns null — consuming
+   * nothing — when the two halves are not a matching pair of columns or rows, so
+   * the caller can fall back to its normal interpretation.
+   *
+   * Both halves must be the same kind: `A:A` and `1:5` are ranges, `A:1` is not
+   * a reference at all in Excel and must stay an error rather than becoming a
+   * silently different region.
+   */
+  #tryParseFullRange(startText, sheetName) {
+    const endToken = this.#tokens[this.#pos + 1];
+    if (!endToken) return null;
+    const start = classifyBound(startText);
+    const end = classifyBound(endToken.value);
+    if (!start || !end || start.kind !== end.kind) return null;
+    this.#advance();
+    this.#advance();
+    const lo = Math.min(start.index, end.index);
+    const hi = Math.max(start.index, end.index);
+    return start.kind === "col" ? new FullRangeReferenceNode(lo, hi, null, null, sheetName) : new FullRangeReferenceNode(null, null, lo, hi, sheetName);
+  }
+  /**
+   * Parses an array constant: `{1,2;3,4}` — ',' separates columns, ';' rows.
+   *
+   * Excel permits only literals inside one (no references, no calls, not even
+   * arithmetic beyond a leading sign), so the value is fully determined here and
+   * is materialised once into the node instead of being rebuilt on every eval.
+   *
+   * A ragged constant is rejected rather than padded: Excel refuses to accept
+   * one at entry, so a file cannot legitimately contain it, and silently filling
+   * the gaps would invent data the author never wrote.
+   */
+  #parseArrayLiteral() {
+    const open = this.#advance();
+    const rows2 = [];
+    let row2 = [];
+    for (; ; ) {
+      row2.push(this.#parseArrayElement());
+      if (this.#current.type === 8 /* Comma */) {
+        this.#advance();
+        continue;
+      }
+      if (this.#current.type === 29 /* Semicolon */) {
+        this.#advance();
+        rows2.push(row2);
+        row2 = [];
+        continue;
       }
-      return new NamedRangeNode(token.value);
-    }
-    case 24 /* SpillReference */:
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      return new SpillReferenceNode(token.value);
-    case 5 /* Function */:
-      return __privateMethod(this, _FormulaParser_instances, parseFunction_fn).call(this);
-    case 27 /* LeftBrace */:
-      return __privateMethod(this, _FormulaParser_instances, parseArrayLiteral_fn).call(this);
-    case 6 /* LeftParen */: {
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      const expr = __privateMethod(this, _FormulaParser_instances, parseComparison_fn).call(this);
-      __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 7 /* RightParen */);
-      return expr;
+      break;
     }
-    default:
+    rows2.push(row2);
+    this.#expect(28 /* RightBrace */);
+    const cols = rows2[0].length;
+    if (rows2.some((r) => r.length !== cols)) {
       throw new FormulaException(
-        `Unexpected token '${token.value}' (type ${token.type}) at position ${token.position}.`
+        `Array constant at position ${open.position} has rows of differing lengths.`
       );
-  }
-};
-/**
- * Completes a whole-column or whole-row reference whose first half has already
- * been consumed and whose ':' is the current token. Returns null — consuming
- * nothing — when the two halves are not a matching pair of columns or rows, so
- * the caller can fall back to its normal interpretation.
- *
- * Both halves must be the same kind: `A:A` and `1:5` are ranges, `A:1` is not
- * a reference at all in Excel and must stay an error rather than becoming a
- * silently different region.
- */
-tryParseFullRange_fn = function(startText, sheetName) {
-  const endToken = __privateGet(this, _tokens)[__privateGet(this, _pos2) + 1];
-  if (!endToken) return null;
-  const start = classifyBound(startText);
-  const end = classifyBound(endToken.value);
-  if (!start || !end || start.kind !== end.kind) return null;
-  __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-  __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-  const lo = Math.min(start.index, end.index);
-  const hi = Math.max(start.index, end.index);
-  return start.kind === "col" ? new FullRangeReferenceNode(lo, hi, null, null, sheetName) : new FullRangeReferenceNode(null, null, lo, hi, sheetName);
-};
-/**
- * Parses an array constant: `{1,2;3,4}` — ',' separates columns, ';' rows.
- *
- * Excel permits only literals inside one (no references, no calls, not even
- * arithmetic beyond a leading sign), so the value is fully determined here and
- * is materialised once into the node instead of being rebuilt on every eval.
- *
- * A ragged constant is rejected rather than padded: Excel refuses to accept
- * one at entry, so a file cannot legitimately contain it, and silently filling
- * the gaps would invent data the author never wrote.
- */
-parseArrayLiteral_fn = function() {
-  const open = __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-  const rows2 = [];
-  let row2 = [];
-  for (; ; ) {
-    row2.push(__privateMethod(this, _FormulaParser_instances, parseArrayElement_fn).call(this));
-    if (__privateGet(this, _FormulaParser_instances, current_get).type === 8 /* Comma */) {
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      continue;
-    }
-    if (__privateGet(this, _FormulaParser_instances, current_get).type === 29 /* Semicolon */) {
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      rows2.push(row2);
-      row2 = [];
-      continue;
-    }
-    break;
-  }
-  rows2.push(row2);
-  __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 28 /* RightBrace */);
-  const cols = rows2[0].length;
-  if (rows2.some((r) => r.length !== cols)) {
+    }
+    const array = new ArrayValue(rows2.length, cols);
+    for (let r = 0; r < rows2.length; r++) {
+      for (let c = 0; c < cols; c++) array.set(r, c, rows2[r][c]);
+    }
+    return new ArrayLiteralNode(array);
+  }
+  /** One element of an array constant: a literal, optionally signed. */
+  #parseArrayElement() {
+    let negate = false;
+    let signed = false;
+    while (this.#current.type === 10 /* Minus */ || this.#current.type === 9 /* Plus */) {
+      if (this.#current.type === 10 /* Minus */) negate = !negate;
+      signed = true;
+      this.#advance();
+    }
+    const token = this.#advance();
+    switch (token.type) {
+      case 0 /* Number */: {
+        const n = parseFloat(token.value);
+        if (isNaN(n)) throw new FormulaException(`Invalid number: ${token.value}`);
+        return FormulaValue.number(negate ? -n : n);
+      }
+      case 1 /* String */:
+        if (signed) break;
+        return FormulaValue.text(token.value);
+      case 2 /* Boolean */:
+        if (signed) break;
+        return FormulaValue.boolean(token.value === "TRUE");
+      case 30 /* ErrorLiteral */:
+        if (signed) break;
+        return FormulaValue.error(FormulaValue.errorFromString(token.value));
+    }
     throw new FormulaException(
-      `Array constant at position ${open.position} has rows of differing lengths.`
+      `Array constants accept only literal values; got '${token.value}' at position ${token.position}.`
     );
   }
-  const array = new ArrayValue(rows2.length, cols);
-  for (let r = 0; r < rows2.length; r++) {
-    for (let c = 0; c < cols; c++) array.set(r, c, rows2[r][c]);
+  #parseFunction() {
+    const nameToken = this.#advance();
+    this.#expect(6 /* LeftParen */);
+    return new FunctionCallNode(nameToken.value.toUpperCase(), this.#parseArgList());
   }
-  return new ArrayLiteralNode(array);
-};
-/** One element of an array constant: a literal, optionally signed. */
-parseArrayElement_fn = function() {
-  let negate = false;
-  let signed = false;
-  while (__privateGet(this, _FormulaParser_instances, current_get).type === 10 /* Minus */ || __privateGet(this, _FormulaParser_instances, current_get).type === 9 /* Plus */) {
-    if (__privateGet(this, _FormulaParser_instances, current_get).type === 10 /* Minus */) negate = !negate;
-    signed = true;
-    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-  }
-  const token = __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-  switch (token.type) {
-    case 0 /* Number */: {
-      const n = parseFloat(token.value);
-      if (isNaN(n)) throw new FormulaException(`Invalid number: ${token.value}`);
-      return FormulaValue.number(negate ? -n : n);
-    }
-    case 1 /* String */:
-      if (signed) break;
-      return FormulaValue.text(token.value);
-    case 2 /* Boolean */:
-      if (signed) break;
-      return FormulaValue.boolean(token.value === "TRUE");
-    case 30 /* ErrorLiteral */:
-      if (signed) break;
-      return FormulaValue.error(FormulaValue.errorFromString(token.value));
-  }
-  throw new FormulaException(
-    `Array constants accept only literal values; got '${token.value}' at position ${token.position}.`
-  );
-};
-parseFunction_fn = function() {
-  const nameToken = __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-  __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 6 /* LeftParen */);
-  return new FunctionCallNode(nameToken.value.toUpperCase(), __privateMethod(this, _FormulaParser_instances, parseArgList_fn).call(this));
-};
-/** Parses a comma-separated argument list up to and including the ')'. */
-parseArgList_fn = function() {
-  const args = [];
-  if (__privateGet(this, _FormulaParser_instances, current_get).type !== 7 /* RightParen */) {
-    if (__privateGet(this, _FormulaParser_instances, current_get).type === 8 /* Comma */) {
-      args.push(new BlankNode());
-    } else {
-      args.push(__privateMethod(this, _FormulaParser_instances, parseComparison_fn).call(this));
-    }
-    while (__privateGet(this, _FormulaParser_instances, current_get).type === 8 /* Comma */) {
-      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
-      if (__privateGet(this, _FormulaParser_instances, current_get).type === 8 /* Comma */ || __privateGet(this, _FormulaParser_instances, current_get).type === 7 /* RightParen */) {
+  /** Parses a comma-separated argument list up to and including the ')'. */
+  #parseArgList() {
+    const args = [];
+    if (this.#current.type !== 7 /* RightParen */) {
+      if (this.#current.type === 8 /* Comma */) {
         args.push(new BlankNode());
       } else {
-        args.push(__privateMethod(this, _FormulaParser_instances, parseComparison_fn).call(this));
+        args.push(this.#parseComparison());
+      }
+      while (this.#current.type === 8 /* Comma */) {
+        this.#advance();
+        if (this.#current.type === 8 /* Comma */ || this.#current.type === 7 /* RightParen */) {
+          args.push(new BlankNode());
+        } else {
+          args.push(this.#parseComparison());
+        }
       }
     }
+    this.#expect(7 /* RightParen */);
+    return args;
   }
-  __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 7 /* RightParen */);
-  return args;
 };
 function classifyBound(text) {
   const bare = text.replace(/\$/g, "");
@@ -2815,6 +2816,8 @@ function registerLookup(r) {
   r.register("COLUMNS", columns, 1, 1);
   r.register("OFFSET", offset, 3, 5, true);
   r.register("INDIRECT", indirect, 1, 2, true);
+  r.register("ANCHORARRAY", anchorArray, 1, 1);
+  r.register("SINGLE", single, 1, 1);
 }
 function num2(a, c, i) {
   const r = FormulaHelper.evalDouble(a[i], c);
@@ -2838,8 +2841,9 @@ function vlookup(a, c) {
   const tbl = tableVal.arrayVal;
   if (colIdx < 0 || colIdx >= tbl.columns) return FormulaValue.errorRef;
   if (exactMatch) {
+    const pattern = lookupPattern(lookupVal);
     for (let r = 0; r < tbl.rows; r++) {
-      if (FormulaValue.areEqual(tbl.get(r, 0), lookupVal)) return tbl.get(r, colIdx);
+      if (matchesLookup(tbl.get(r, 0), lookupVal, pattern)) return tbl.get(r, colIdx);
     }
     return FormulaValue.errorNA;
   }
@@ -2868,8 +2872,9 @@ function hlookup(a, c) {
   const tbl = tableVal.arrayVal;
   if (rowIdx < 0 || rowIdx >= tbl.rows) return FormulaValue.errorRef;
   if (exactMatch) {
+    const pattern = lookupPattern(lookupVal);
     for (let col = 0; col < tbl.columns; col++) {
-      if (FormulaValue.areEqual(tbl.get(0, col), lookupVal)) return tbl.get(rowIdx, col);
+      if (matchesLookup(tbl.get(0, col), lookupVal, pattern)) return tbl.get(rowIdx, col);
     }
     return FormulaValue.errorNA;
   }
@@ -2880,18 +2885,13 @@ function hlookup(a, c) {
   }
   return best >= 0 ? tbl.get(rowIdx, best) : FormulaValue.errorNA;
 }
-function wildcardRegex(pattern) {
-  let out = "";
-  for (let i = 0; i < pattern.length; i++) {
-    const ch = pattern[i];
-    if (ch === "~" && i + 1 < pattern.length) {
-      const next = pattern[++i];
-      out += next.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    } else if (ch === "*") out += ".*";
-    else if (ch === "?") out += ".";
-    else out += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  return new RegExp(`^${out}$`, "i");
+function lookupPattern(lookupVal) {
+  if (!lookupVal.isText) return null;
+  const text = lookupVal.textValue;
+  return FormulaHelper.hasWildcardSyntax(text) ? FormulaHelper.wildcardToRegex(text) : null;
+}
+function matchesLookup(candidate, lookupVal, pattern) {
+  return pattern === null ? FormulaValue.areEqual(candidate, lookupVal) : !candidate.isBlank && pattern.test(candidate.asText());
 }
 function findMatch(n, get, lookupVal, matchMode, searchMode) {
   if ((searchMode === 2 || searchMode === -2) && matchMode !== 2) {
@@ -2915,8 +2915,11 @@ function findMatch(n, get, lookupVal, matchMode, searchMode) {
   const reverse = searchMode === -1;
   const order = reverse ? Array.from({ length: n }, (_, k) => n - 1 - k) : Array.from({ length: n }, (_, k) => k);
   if (matchMode === 2) {
-    const re = wildcardRegex(lookupVal.asText());
-    for (const i of order) if (re.test(get(i).asText())) return i;
+    const re = FormulaHelper.wildcardToRegex(lookupVal.asText());
+    for (const i of order) {
+      const v = get(i);
+      if (!v.isBlank && re.test(v.asText())) return i;
+    }
     return -1;
   }
   if (matchMode === 0) {
@@ -3026,13 +3029,15 @@ function match(a, c) {
     matchType = Math.round(r.n);
   }
   if (!arrVal.isArray) {
-    return FormulaValue.areEqual(arrVal, lookupVal) ? FormulaValue.one : FormulaValue.errorNA;
+    const single2 = matchType === 0 ? matchesLookup(arrVal, lookupVal, lookupPattern(lookupVal)) : FormulaValue.areEqual(arrVal, lookupVal);
+    return single2 ? FormulaValue.one : FormulaValue.errorNA;
   }
   const arr = arrVal.arrayVal;
   const len2 = arr.length;
   if (matchType === 0) {
+    const pattern = lookupPattern(lookupVal);
     for (let i = 0; i < len2; i++) {
-      if (FormulaValue.areEqual(arr.getFlat(i), lookupVal)) return FormulaValue.number(i + 1);
+      if (matchesLookup(arr.getFlat(i), lookupVal, pattern)) return FormulaValue.number(i + 1);
     }
     return FormulaValue.errorNA;
   }
@@ -3262,6 +3267,15 @@ function offset(a, c) {
     cellRefFromRowCol(newRow + height - 1, newCol + width - 1)
   );
 }
+function anchorArray(a, c) {
+  const arg2 = a[0];
+  if (arg2 instanceof CellReferenceNode) return c.resolveSpillRange(arg2.reference);
+  if (arg2 instanceof SheetCellReferenceNode) return c.resolveSheetSpillRange(arg2.sheetName, arg2.cellReference);
+  return FormulaValue.errorRef;
+}
+function single(a, c) {
+  return new ImplicitIntersectionNode(a[0]).evaluate(c);
+}
 
 // src/functions/statistical-functions.ts
 function registerStatistical(r) {
@@ -4542,24 +4556,20 @@ function toRow(a, c) {
 
 // src/function-registry.ts
 var MAX_LIFTED_CELLS = 1048576;
-var _default, _functions, _FunctionRegistry_static, executeElementwise_fn, _FunctionRegistry_instances, registerBuiltIns_fn;
-var _FunctionRegistry = class _FunctionRegistry {
-  constructor() {
-    __privateAdd(this, _FunctionRegistry_instances);
-    __privateAdd(this, _functions, /* @__PURE__ */ new Map());
-  }
+var FunctionRegistry = class _FunctionRegistry {
+  static #default;
   /** Lazily-created default registry with all built-in functions registered. */
   static get default() {
-    var _a;
-    if (!__privateGet(_FunctionRegistry, _default)) {
-      __privateSet(_FunctionRegistry, _default, new _FunctionRegistry());
-      __privateMethod(_a = __privateGet(_FunctionRegistry, _default), _FunctionRegistry_instances, registerBuiltIns_fn).call(_a);
+    if (!_FunctionRegistry.#default) {
+      _FunctionRegistry.#default = new _FunctionRegistry();
+      _FunctionRegistry.#default.#registerBuiltIns();
     }
-    return __privateGet(_FunctionRegistry, _default);
+    return _FunctionRegistry.#default;
   }
+  #functions = /* @__PURE__ */ new Map();
   /** Registers a function. Name is normalised to UPPERCASE. */
   register(name, handler, minArgs = 0, maxArgs = -1, isVolatile = false) {
-    __privateGet(this, _functions).set(name.toUpperCase(), {
+    this.#functions.set(name.toUpperCase(), {
       name: name.toUpperCase(),
       minArgs,
       maxArgs,
@@ -4585,7 +4595,7 @@ var _FunctionRegistry = class _FunctionRegistry {
    * `register`, or lifting would map it over the array it is meant to reduce.
    */
   registerElementwise(name, handler, minArgs = 0, maxArgs = -1) {
-    __privateGet(this, _functions).set(name.toUpperCase(), {
+    this.#functions.set(name.toUpperCase(), {
       name: name.toUpperCase(),
       minArgs,
       maxArgs,
@@ -4596,81 +4606,84 @@ var _FunctionRegistry = class _FunctionRegistry {
   }
   /** Executes a function by name with argument validation. */
   execute(name, args, ctx) {
-    var _a;
-    const def = __privateGet(this, _functions).get(name.toUpperCase());
+    const def = this.#functions.get(name.toUpperCase());
     if (!def) return FormulaValue.errorName;
     if (args.length < def.minArgs) return FormulaValue.errorValue;
     if (def.maxArgs >= 0 && args.length > def.maxArgs) return FormulaValue.errorValue;
     try {
-      return def.elementwise ? __privateMethod(_a = _FunctionRegistry, _FunctionRegistry_static, executeElementwise_fn).call(_a, def, args, ctx) : def.handler(args, ctx);
+      return def.elementwise ? _FunctionRegistry.#executeElementwise(def, args, ctx) : def.handler(args, ctx);
     } catch {
       return FormulaValue.errorValue;
     }
   }
+  /**
+   * Runs a scalar handler, mapping it over any array arguments.
+   *
+   * Arguments are evaluated exactly once and the handler is re-driven through
+   * {@link ValueNode}s, so a nested call in an argument is not recomputed per
+   * output cell — the alternative (letting the handler re-evaluate the original
+   * nodes) would multiply the cost of `LEFT(expensive(), 3)` by the array size.
+   * The all-scalar case — the overwhelming majority of calls — costs one array of
+   * wrappers and takes the same path, so there is no second code path to keep in
+   * step.
+   */
+  static #executeElementwise(def, args, ctx) {
+    const values = args.map((a) => a.evaluate(ctx));
+    let rows2 = 1, cols = 1;
+    for (const v of values) {
+      if (!v.isArray) continue;
+      const a = v.arrayVal;
+      if (a.rows > rows2) rows2 = a.rows;
+      if (a.columns > cols) cols = a.columns;
+    }
+    if (rows2 === 1 && cols === 1) {
+      return def.handler(values.map((v) => new ValueNode(v.isArray ? v.arrayVal.get(0, 0) : v)), ctx);
+    }
+    if (rows2 * cols > MAX_LIFTED_CELLS) return FormulaValue.errorValue;
+    for (const v of values) {
+      if (!v.isArray) continue;
+      const a = v.arrayVal;
+      if (a.rows !== 1 && a.rows !== rows2 || a.columns !== 1 && a.columns !== cols) {
+        return FormulaValue.errorValue;
+      }
+    }
+    const nodes = values.map((v) => new ValueNode(v));
+    const out = new ArrayValue(rows2, cols);
+    for (let r = 0; r < rows2; r++) {
+      for (let c = 0; c < cols; c++) {
+        for (let i = 0; i < values.length; i++) {
+          const v = values[i];
+          if (!v.isArray) continue;
+          const a = v.arrayVal;
+          nodes[i].value = a.get(a.rows === 1 ? 0 : r, a.columns === 1 ? 0 : c);
+        }
+        out.set(r, c, def.handler(nodes, ctx));
+      }
+    }
+    return FormulaValue.array(out);
+  }
   /** Returns true if the named function is volatile (NOW, RAND, etc.). */
   isVolatile(name) {
-    return __privateGet(this, _functions).get(name.toUpperCase())?.isVolatile ?? false;
+    return this.#functions.get(name.toUpperCase())?.isVolatile ?? false;
   }
   /** Returns true if the function is registered. */
   has(name) {
-    return __privateGet(this, _functions).has(name.toUpperCase());
-  }
-};
-_default = new WeakMap();
-_functions = new WeakMap();
-_FunctionRegistry_static = new WeakSet();
-executeElementwise_fn = function(def, args, ctx) {
-  const values = args.map((a) => a.evaluate(ctx));
-  let rows2 = 1, cols = 1;
-  for (const v of values) {
-    if (!v.isArray) continue;
-    const a = v.arrayVal;
-    if (a.rows > rows2) rows2 = a.rows;
-    if (a.columns > cols) cols = a.columns;
-  }
-  if (rows2 === 1 && cols === 1) {
-    return def.handler(values.map((v) => new ValueNode(v.isArray ? v.arrayVal.get(0, 0) : v)), ctx);
-  }
-  if (rows2 * cols > MAX_LIFTED_CELLS) return FormulaValue.errorValue;
-  for (const v of values) {
-    if (!v.isArray) continue;
-    const a = v.arrayVal;
-    if (a.rows !== 1 && a.rows !== rows2 || a.columns !== 1 && a.columns !== cols) {
-      return FormulaValue.errorValue;
-    }
-  }
-  const nodes = values.map((v) => new ValueNode(v));
-  const out = new ArrayValue(rows2, cols);
-  for (let r = 0; r < rows2; r++) {
-    for (let c = 0; c < cols; c++) {
-      for (let i = 0; i < values.length; i++) {
-        const v = values[i];
-        if (!v.isArray) continue;
-        const a = v.arrayVal;
-        nodes[i].value = a.get(a.rows === 1 ? 0 : r, a.columns === 1 ? 0 : c);
-      }
-      out.set(r, c, def.handler(nodes, ctx));
-    }
+    return this.#functions.has(name.toUpperCase());
+  }
+  #registerBuiltIns() {
+    registerMath(this);
+    registerText(this);
+    registerLogical(this);
+    registerDate(this);
+    registerLookup(this);
+    registerStatistical(this);
+    registerInfo(this);
+    registerFinance(this);
+    registerMeta(this);
+    registerAggregate(this);
+    registerArray(this);
   }
-  return FormulaValue.array(out);
-};
-_FunctionRegistry_instances = new WeakSet();
-registerBuiltIns_fn = function() {
-  registerMath(this);
-  registerText(this);
-  registerLogical(this);
-  registerDate(this);
-  registerLookup(this);
-  registerStatistical(this);
-  registerInfo(this);
-  registerFinance(this);
-  registerMeta(this);
-  registerAggregate(this);
-  registerArray(this);
 };
-__privateAdd(_FunctionRegistry, _FunctionRegistry_static);
-__privateAdd(_FunctionRegistry, _default);
-var FunctionRegistry = _FunctionRegistry;
 var FormulaHelper;
 ((FormulaHelper2) => {
   function evalDouble(node, ctx) {
@@ -4743,7 +4756,7 @@ var FormulaHelper;
       const test = (v) => wanted(FormulaValue.compare(v, rhsValue));
       return rhsNum !== null ? { kind: "compareNumber", number: rhsNum, op, test } : { kind: "other", test };
     }
-    if (trimmed.includes("*") || trimmed.includes("?")) {
+    if (hasWildcardSyntax(trimmed)) {
       const pattern = wildcardToRegex(trimmed);
       return { kind: "other", test: (v) => pattern.test(v.asText()) };
     }
@@ -4775,53 +4788,106 @@ var FormulaHelper;
     return compileCriteria(criteria).test(value2);
   }
   FormulaHelper2.matchesCriteria = matchesCriteria;
-  function wildcardToRegex(pattern) {
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-    return new RegExp(`^${escaped}$`, "i");
+  function hasWildcardSyntax(pattern) {
+    for (let i = 0; i < pattern.length; i++) {
+      const ch = pattern.charCodeAt(i);
+      if (ch === 42 || ch === 63 || ch === 126) return true;
+    }
+    return false;
   }
+  FormulaHelper2.hasWildcardSyntax = hasWildcardSyntax;
+  function wildcardToRegex(pattern) {
+    let out = "";
+    for (let i = 0; i < pattern.length; i++) {
+      const ch = pattern[i];
+      const next = pattern[i + 1];
+      if (ch === "~" && (next === "*" || next === "?" || next === "~")) {
+        out += escapeRegex(next);
+        i++;
+      } else if (ch === "*") out += ".*";
+      else if (ch === "?") out += ".";
+      else out += escapeRegex(ch);
+    }
+    return new RegExp(`^${out}$`, "i");
+  }
+  FormulaHelper2.wildcardToRegex = wildcardToRegex;
+  const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 })(FormulaHelper || (FormulaHelper = {}));
 
 // src/formula-context.ts
-var _sheet, _functions2, _evaluating, _scopes, _FormulaContext_instances, lookupScope_fn, forSheet_fn;
-var _FormulaContext = class _FormulaContext {
-  constructor(sheet, formulaRow = 0, formulaCol = 0, evaluating, registry) {
-    __privateAdd(this, _FormulaContext_instances);
-    __privateAdd(this, _sheet);
-    __privateAdd(this, _functions2);
-    __privateAdd(this, _evaluating);
-    /**
-     * Lexical scope stack for LET/LAMBDA local names. Each frame maps an
-     * upper-cased local name to its value. Names resolve innermost-first and take
-     * precedence over workbook defined names.
-     */
-    __privateAdd(this, _scopes, []);
-    __privateSet(this, _sheet, sheet);
-    this.formulaRow = formulaRow;
-    this.formulaCol = formulaCol;
-    __privateSet(this, _evaluating, evaluating ?? /* @__PURE__ */ new Set());
-    __privateSet(this, _functions2, registry ?? FunctionRegistry.default);
-  }
+var FormulaContext = class _FormulaContext {
+  #sheet;
+  #functions;
+  #evaluating;
+  /** Row of the formula cell (for @ implicit intersection). */
+  formulaRow;
+  /** Column of the formula cell (for @ implicit intersection). */
+  formulaCol;
+  /** Optional workbook reference for cross-sheet references. */
+  workbook;
+  /**
+   * Optional memo for range reads, supplied by whoever owns the write side —
+   * the recalculation engine, which invalidates it as it writes results. Left
+   * undefined for one-shot evaluation, where a stale entry could otherwise
+   * outlive a caller's direct edit to the model.
+   */
+  rangeCache;
+  /**
+   * Optional named-range resolver, installed by the evaluator when the workbook
+   * exposes getDefinedName. Given a name, returns its evaluated value. Left
+   * undefined when no resolver is available, in which case named ranges are
+   * #NAME? (unchanged legacy behaviour).
+   */
+  nameResolver;
+  /**
+   * Shared recursion budget for LAMBDA calls, threaded across all contexts in a
+   * single evaluation. Guards non-tail recursion (which grows the JS stack);
+   * tail recursion is trampolined and does not count against it.
+   */
+  recursionGuard;
+  /**
+   * Lexical scope stack for LET/LAMBDA local names. Each frame maps an
+   * upper-cased local name to its value. Names resolve innermost-first and take
+   * precedence over workbook defined names.
+   */
+  #scopes = [];
   /** Pushes a new binding frame (used by LET/LAMBDA). */
   pushScope(bindings) {
-    __privateGet(this, _scopes).push(bindings);
+    this.#scopes.push(bindings);
   }
   /** Pops the innermost binding frame. */
   popScope() {
-    __privateGet(this, _scopes).pop();
+    this.#scopes.pop();
+  }
+  #lookupScope(name) {
+    if (this.#scopes.length === 0) return void 0;
+    const key = name.toUpperCase();
+    for (let i = this.#scopes.length - 1; i >= 0; i--) {
+      const v = this.#scopes[i].get(key);
+      if (v !== void 0) return v;
+    }
+    return void 0;
+  }
+  constructor(sheet, formulaRow = 0, formulaCol = 0, evaluating, registry) {
+    this.#sheet = sheet;
+    this.formulaRow = formulaRow;
+    this.formulaCol = formulaCol;
+    this.#evaluating = evaluating ?? /* @__PURE__ */ new Set();
+    this.#functions = registry ?? FunctionRegistry.default;
   }
   get worksheet() {
-    return __privateGet(this, _sheet);
+    return this.#sheet;
   }
   // ── Cell/Range resolution ─────────────────────────────────────────────────
   getCellValue(cellReference) {
     const norm = cellReference.replace(/\$/g, "").toUpperCase();
-    if (__privateGet(this, _evaluating).has(norm)) return FormulaValue.errorRef;
-    __privateGet(this, _evaluating).add(norm);
+    if (this.#evaluating.has(norm)) return FormulaValue.errorRef;
+    this.#evaluating.add(norm);
     try {
-      const raw = __privateGet(this, _sheet).getCellValue(cellReference);
+      const raw = this.#sheet.getCellValue(cellReference);
       return FormulaValue.fromObjectSync(raw);
     } finally {
-      __privateGet(this, _evaluating).delete(norm);
+      this.#evaluating.delete(norm);
     }
   }
   getRangeValues(startRef, endRef) {
@@ -4839,17 +4905,17 @@ var _FormulaContext = class _FormulaContext {
     const rows2 = endRow - startRow + 1;
     const cols = endCol - startCol + 1;
     const cache = rows2 * cols > 1 ? this.rangeCache : void 0;
-    const sheetKey = cache ? __privateGet(this, _sheet).name.toUpperCase() : "";
+    const sheetKey = cache ? this.#sheet.name.toUpperCase() : "";
     if (cache) {
       const hit = cache.get(sheetKey, startRow, startCol, endRow, endCol);
       if (hit !== void 0) return hit;
     }
     const arr = new ArrayValue(rows2, cols);
-    const at = __privateGet(this, _sheet).getCellValueAt;
+    const at = this.#sheet.getCellValueAt;
     if (at) {
       for (let r = 0; r < rows2; r++) {
         for (let c = 0; c < cols; c++) {
-          arr.set(r, c, FormulaValue.fromObjectSync(at.call(__privateGet(this, _sheet), startRow + r, startCol + c)));
+          arr.set(r, c, FormulaValue.fromObjectSync(at.call(this.#sheet, startRow + r, startCol + c)));
         }
       }
     } else {
@@ -4875,7 +4941,7 @@ var _FormulaContext = class _FormulaContext {
    * silently reading nothing would make SUM(A:A) return 0 on a full column.
    */
   getFullRangeValues(startCol, endCol, startRow, endRow) {
-    const bounds = __privateGet(this, _sheet).usedBounds;
+    const bounds = this.#sheet.usedBounds;
     if (!bounds) return FormulaValue.errorRef;
     if (bounds.rowCount === 0 || bounds.columnCount === 0) return FormulaValue.blank;
     const r0 = startRow ?? 1;
@@ -4890,7 +4956,7 @@ var _FormulaContext = class _FormulaContext {
   getSheetCellValue(sheetName, cellReference) {
     if (!this.workbook) return FormulaValue.errorRef;
     try {
-      return __privateMethod(this, _FormulaContext_instances, forSheet_fn).call(this, sheetName).getCellValue(cellReference);
+      return this.#forSheet(sheetName).getCellValue(cellReference);
     } catch {
       return FormulaValue.errorRef;
     }
@@ -4898,7 +4964,7 @@ var _FormulaContext = class _FormulaContext {
   getSheetRangeValues(sheetName, startRef, endRef) {
     if (!this.workbook) return FormulaValue.errorRef;
     try {
-      return __privateMethod(this, _FormulaContext_instances, forSheet_fn).call(this, sheetName).getRangeValues(startRef, endRef);
+      return this.#forSheet(sheetName).getRangeValues(startRef, endRef);
     } catch {
       return FormulaValue.errorRef;
     }
@@ -4907,13 +4973,28 @@ var _FormulaContext = class _FormulaContext {
   getSheetFullRangeValues(sheetName, startCol, endCol, startRow, endRow) {
     if (!this.workbook) return FormulaValue.errorRef;
     try {
-      return __privateMethod(this, _FormulaContext_instances, forSheet_fn).call(this, sheetName).getFullRangeValues(startCol, endCol, startRow, endRow);
+      return this.#forSheet(sheetName).getFullRangeValues(startCol, endCol, startRow, endRow);
     } catch {
       return FormulaValue.errorRef;
     }
   }
+  /**
+   * A sibling context bound to another sheet, sharing this one's circular-
+   * reference guard and range memo. These contexts only read values — they
+   * never evaluate an AST — so the name resolver and recursion budget are
+   * deliberately not carried over; passing them would suggest a scoping
+   * relationship that does not exist. The memo, on the other hand, must be
+   * carried: cross-sheet ranges are the most expensive reads in a workbook.
+   */
+  #forSheet(sheetName) {
+    const sheet = this.workbook.getWorksheet(sheetName);
+    const ctx = new _FormulaContext(sheet, this.formulaRow, this.formulaCol, this.#evaluating, this.#functions);
+    ctx.workbook = this.workbook;
+    ctx.rangeCache = this.rangeCache;
+    return ctx;
+  }
   resolveNamedRange(name) {
-    const scoped = __privateMethod(this, _FormulaContext_instances, lookupScope_fn).call(this, name);
+    const scoped = this.#lookupScope(name);
     if (scoped !== void 0) return scoped;
     return this.nameResolver ? this.nameResolver(name) : FormulaValue.errorName;
   }
@@ -4922,12 +5003,21 @@ var _FormulaContext = class _FormulaContext {
    * cell. Requires the worksheet to expose getSpillRange; otherwise #REF!.
    */
   resolveSpillRange(anchorRef) {
-    const spillRef = __privateGet(this, _sheet).getSpillRange?.(anchorRef);
+    const spillRef = this.#sheet.getSpillRange?.(anchorRef);
     if (!spillRef) return FormulaValue.errorRef;
     const colon = spillRef.indexOf(":");
     if (colon < 0) return this.getCellValue(spillRef);
     return this.getRangeValues(spillRef.slice(0, colon), spillRef.slice(colon + 1));
   }
+  /** {@link resolveSpillRange} for an anchor on another sheet ('S'!A1#). */
+  resolveSheetSpillRange(sheetName, anchorRef) {
+    if (!this.workbook) return FormulaValue.errorRef;
+    try {
+      return this.#forSheet(sheetName).resolveSpillRange(anchorRef);
+    } catch {
+      return FormulaValue.errorRef;
+    }
+  }
   getRangeBounds(startRef, endRef) {
     const s = parseCellRef(startRef);
     const e = parseCellRef(endRef);
@@ -4936,94 +5026,63 @@ var _FormulaContext = class _FormulaContext {
   // ── Function dispatch ─────────────────────────────────────────────────────
   /** True if a built-in function with this name is registered. */
   hasFunction(name) {
-    return __privateGet(this, _functions2).has(name);
+    return this.#functions.has(name);
   }
   evaluateFunction(name, args) {
-    if (!__privateGet(this, _functions2).has(name)) {
+    if (!this.#functions.has(name)) {
       const named = this.resolveNamedRange(name);
       if (named.isLambda) {
         return named.lambdaVal.call(args.map((a) => a.evaluate(this)));
       }
     }
-    return __privateGet(this, _functions2).execute(name, args, this);
+    return this.#functions.execute(name, args, this);
   }
 };
-_sheet = new WeakMap();
-_functions2 = new WeakMap();
-_evaluating = new WeakMap();
-_scopes = new WeakMap();
-_FormulaContext_instances = new WeakSet();
-lookupScope_fn = function(name) {
-  if (__privateGet(this, _scopes).length === 0) return void 0;
-  const key = name.toUpperCase();
-  for (let i = __privateGet(this, _scopes).length - 1; i >= 0; i--) {
-    const v = __privateGet(this, _scopes)[i].get(key);
-    if (v !== void 0) return v;
-  }
-  return void 0;
-};
-/**
- * A sibling context bound to another sheet, sharing this one's circular-
- * reference guard and range memo. These contexts only read values — they
- * never evaluate an AST — so the name resolver and recursion budget are
- * deliberately not carried over; passing them would suggest a scoping
- * relationship that does not exist. The memo, on the other hand, must be
- * carried: cross-sheet ranges are the most expensive reads in a workbook.
- */
-forSheet_fn = function(sheetName) {
-  const sheet = this.workbook.getWorksheet(sheetName);
-  const ctx = new _FormulaContext(sheet, this.formulaRow, this.formulaCol, __privateGet(this, _evaluating), __privateGet(this, _functions2));
-  ctx.workbook = this.workbook;
-  ctx.rangeCache = this.rangeCache;
-  return ctx;
-};
-var FormulaContext = _FormulaContext;
 
 // src/lru-cache.ts
-var _map, _capacity, _hits, _misses, _evictions;
 var LruCache = class {
+  #map;
+  #capacity;
+  #hits = 0;
+  #misses = 0;
+  #evictions = 0;
   constructor(capacity) {
-    __privateAdd(this, _map);
-    __privateAdd(this, _capacity);
-    __privateAdd(this, _hits, 0);
-    __privateAdd(this, _misses, 0);
-    __privateAdd(this, _evictions, 0);
     if (capacity <= 0) throw new RangeError("LruCache capacity must be > 0.");
-    __privateSet(this, _capacity, capacity);
-    __privateSet(this, _map, /* @__PURE__ */ new Map());
+    this.#capacity = capacity;
+    this.#map = /* @__PURE__ */ new Map();
   }
   get capacity() {
-    return __privateGet(this, _capacity);
+    return this.#capacity;
   }
   get size() {
-    return __privateGet(this, _map).size;
+    return this.#map.size;
   }
   get hits() {
-    return __privateGet(this, _hits);
+    return this.#hits;
   }
   get misses() {
-    return __privateGet(this, _misses);
+    return this.#misses;
   }
   get evictions() {
-    return __privateGet(this, _evictions);
+    return this.#evictions;
   }
   get hitRate() {
-    const total = __privateGet(this, _hits) + __privateGet(this, _misses);
-    return total === 0 ? 0 : __privateGet(this, _hits) / total;
+    const total = this.#hits + this.#misses;
+    return total === 0 ? 0 : this.#hits / total;
   }
   /**
    * Returns the value for key, or undefined if not present.
    * Moves the accessed key to the "most recently used" end.
    */
   get(key) {
-    const value2 = __privateGet(this, _map).get(key);
+    const value2 = this.#map.get(key);
     if (value2 === void 0) {
-      __privateWrapper(this, _misses)._++;
+      this.#misses++;
       return void 0;
     }
-    __privateGet(this, _map).delete(key);
-    __privateGet(this, _map).set(key, value2);
-    __privateWrapper(this, _hits)._++;
+    this.#map.delete(key);
+    this.#map.set(key, value2);
+    this.#hits++;
     return value2;
   }
   /**
@@ -5031,44 +5090,39 @@ var LruCache = class {
    * Evicts the least-recently-used entry if over capacity.
    */
   set(key, value2) {
-    if (__privateGet(this, _map).has(key)) {
-      __privateGet(this, _map).delete(key);
-    } else if (__privateGet(this, _map).size >= __privateGet(this, _capacity)) {
-      const oldest = __privateGet(this, _map).keys().next().value;
-      __privateGet(this, _map).delete(oldest);
-      __privateWrapper(this, _evictions)._++;
+    if (this.#map.has(key)) {
+      this.#map.delete(key);
+    } else if (this.#map.size >= this.#capacity) {
+      const oldest = this.#map.keys().next().value;
+      this.#map.delete(oldest);
+      this.#evictions++;
     }
-    __privateGet(this, _map).set(key, value2);
+    this.#map.set(key, value2);
   }
   /** Removes a key from the cache. Returns true if it existed. */
   delete(key) {
-    return __privateGet(this, _map).delete(key);
+    return this.#map.delete(key);
   }
   /** Returns true if the key is present (does NOT update LRU order). */
   has(key) {
-    return __privateGet(this, _map).has(key);
+    return this.#map.has(key);
   }
   /** Removes all entries and resets statistics. */
   clear() {
-    __privateGet(this, _map).clear();
-    __privateSet(this, _hits, __privateSet(this, _misses, __privateSet(this, _evictions, 0)));
+    this.#map.clear();
+    this.#hits = this.#misses = this.#evictions = 0;
   }
   /** Resizes the cache, evicting oldest entries if necessary. */
   resize(newCapacity) {
     if (newCapacity <= 0) throw new RangeError("Capacity must be > 0.");
-    __privateSet(this, _capacity, newCapacity);
-    while (__privateGet(this, _map).size > newCapacity) {
-      const oldest = __privateGet(this, _map).keys().next().value;
-      __privateGet(this, _map).delete(oldest);
-      __privateWrapper(this, _evictions)._++;
+    this.#capacity = newCapacity;
+    while (this.#map.size > newCapacity) {
+      const oldest = this.#map.keys().next().value;
+      this.#map.delete(oldest);
+      this.#evictions++;
     }
   }
 };
-_map = new WeakMap();
-_capacity = new WeakMap();
-_hits = new WeakMap();
-_misses = new WeakMap();
-_evictions = new WeakMap();
 
 // src/formula-evaluator.ts
 var DEFAULT_CACHE_CAPACITY = 1e4;
@@ -5176,143 +5230,126 @@ var TILE_ROWS = 64;
 var TILE_COLS = 64;
 var MAX_TILES_PER_RANGE = 32;
 var DEFAULT_MAX_CELLS = 2e6;
-var _entries, _tiles, _wide, _placements, _sizes, _cells, _maxCells, _RangeCache_static, contains_fn, _RangeCache_instances, drop_fn, fileIn_fn;
-var _RangeCache = class _RangeCache {
+var RangeCache = class _RangeCache {
+  /** entry key → the memoised rectangle. Insertion-ordered (FIFO eviction). */
+  #entries = /* @__PURE__ */ new Map();
+  /** `sheet tr tc` → entry keys whose rectangle overlaps that tile. */
+  #tiles = /* @__PURE__ */ new Map();
+  /** sheet → entry keys whose rectangle is too broad to tile. */
+  #wide = /* @__PURE__ */ new Map();
+  /** entry key → buckets it was filed under, for cheap removal. */
+  #placements = /* @__PURE__ */ new Map();
+  /** Number of cells across all cached rectangles, kept under {@link #maxCells}. */
+  #cells = 0;
+  #maxCells;
+  hits = 0;
+  misses = 0;
   constructor(maxCells = DEFAULT_MAX_CELLS) {
-    __privateAdd(this, _RangeCache_instances);
-    /** `SHEET r0 c0 r1 c1` → the memoised array value. Insertion-ordered (FIFO eviction). */
-    __privateAdd(this, _entries, /* @__PURE__ */ new Map());
-    /** `sheet tr tc` → entry keys whose rectangle overlaps that tile. */
-    __privateAdd(this, _tiles, /* @__PURE__ */ new Map());
-    /** sheet → entry keys whose rectangle is too broad to tile. */
-    __privateAdd(this, _wide, /* @__PURE__ */ new Map());
-    /** entry key → buckets it was filed under, for cheap removal. */
-    __privateAdd(this, _placements, /* @__PURE__ */ new Map());
-    /** entry key → its area, so eviction can give the budget back. */
-    __privateAdd(this, _sizes, /* @__PURE__ */ new Map());
-    /** Number of cells across all cached rectangles, kept under {@link #maxCells}. */
-    __privateAdd(this, _cells, 0);
-    __privateAdd(this, _maxCells);
-    this.hits = 0;
-    this.misses = 0;
-    __privateSet(this, _maxCells, maxCells);
+    this.#maxCells = maxCells;
   }
   get size() {
-    return __privateGet(this, _entries).size;
+    return this.#entries.size;
   }
   get cachedCells() {
-    return __privateGet(this, _cells);
+    return this.#cells;
   }
   static key(sheet, r0, c0, r1, c1) {
     return `${sheet} ${r0} ${c0} ${r1} ${c1}`;
   }
   get(sheet, r0, c0, r1, c1) {
-    const hit = __privateGet(this, _entries).get(_RangeCache.key(sheet, r0, c0, r1, c1));
+    const hit = this.#entries.get(_RangeCache.key(sheet, r0, c0, r1, c1));
     if (hit === void 0) this.misses++;
     else this.hits++;
-    return hit;
+    return hit?.value;
   }
   /** Memoises a rectangle's value. `cells` is its area, for the budget. */
   set(sheet, r0, c0, r1, c1, value2, cells) {
-    if (cells <= 0 || cells > __privateGet(this, _maxCells)) return;
+    if (cells <= 0 || cells > this.#maxCells) return;
     const key = _RangeCache.key(sheet, r0, c0, r1, c1);
-    if (__privateGet(this, _entries).has(key)) __privateMethod(this, _RangeCache_instances, drop_fn).call(this, key);
-    __privateGet(this, _entries).set(key, value2);
-    __privateSet(this, _cells, __privateGet(this, _cells) + cells);
+    if (this.#entries.has(key)) this.#drop(key);
+    this.#entries.set(key, { value: value2, sheet, r0, c0, r1, c1, cells });
+    this.#cells += cells;
     const buckets = [];
     const tileRow0 = r0 / TILE_ROWS | 0, tileRow1 = r1 / TILE_ROWS | 0;
     const tileCol0 = c0 / TILE_COLS | 0, tileCol1 = c1 / TILE_COLS | 0;
     const tileCount = (tileRow1 - tileRow0 + 1) * (tileCol1 - tileCol0 + 1);
     if (tileCount > MAX_TILES_PER_RANGE) {
-      __privateMethod(this, _RangeCache_instances, fileIn_fn).call(this, __privateGet(this, _wide), sheet, key, buckets, `w ${sheet}`);
+      this.#fileIn(this.#wide, sheet, key, buckets);
     } else {
       for (let tr = tileRow0; tr <= tileRow1; tr++) {
         for (let tc = tileCol0; tc <= tileCol1; tc++) {
-          const bucket = `${sheet} ${tr} ${tc}`;
-          __privateMethod(this, _RangeCache_instances, fileIn_fn).call(this, __privateGet(this, _tiles), bucket, key, buckets, `t ${bucket}`);
+          this.#fileIn(this.#tiles, `${sheet} ${tr} ${tc}`, key, buckets);
         }
       }
     }
-    __privateGet(this, _placements).set(key, buckets);
-    __privateGet(this, _sizes).set(key, cells);
-    if (__privateGet(this, _cells) > __privateGet(this, _maxCells)) {
-      for (const oldest of __privateGet(this, _entries).keys()) {
-        if (__privateGet(this, _cells) <= __privateGet(this, _maxCells)) break;
+    this.#placements.set(key, buckets);
+    if (this.#cells > this.#maxCells) {
+      for (const oldest of this.#entries.keys()) {
+        if (this.#cells <= this.#maxCells) break;
         if (oldest === key) continue;
-        __privateMethod(this, _RangeCache_instances, drop_fn).call(this, oldest);
+        this.#drop(oldest);
       }
     }
   }
-  /** Drops every cached rectangle containing the given cell. */
+  /**
+   * Drops every cached rectangle containing the given cell.
+   *
+   * The bucket sets are iterated in place. Removing an element of a `Set` while
+   * iterating it is defined behaviour — the iterator simply does not revisit it —
+   * and copying instead cost one array per write, which at one write per formula
+   * was a real share of a recalculation.
+   */
   invalidateCell(sheet, row2, col) {
-    var _a, _b;
-    const tile = __privateGet(this, _tiles).get(`${sheet} ${row2 / TILE_ROWS | 0} ${col / TILE_COLS | 0}`);
-    if (tile) {
-      for (const key of [...tile]) {
-        if (__privateMethod(_a = _RangeCache, _RangeCache_static, contains_fn).call(_a, key, sheet, row2, col)) __privateMethod(this, _RangeCache_instances, drop_fn).call(this, key);
+    const tile = this.#tiles.get(`${sheet} ${row2 / TILE_ROWS | 0} ${col / TILE_COLS | 0}`);
+    if (tile !== void 0) {
+      for (const key of tile) {
+        const entry = this.#entries.get(key);
+        if (entry !== void 0 && _RangeCache.#contains(entry, sheet, row2, col)) this.#drop(key);
       }
     }
-    const wide = __privateGet(this, _wide).get(sheet);
-    if (wide) {
-      for (const key of [...wide]) {
-        if (__privateMethod(_b = _RangeCache, _RangeCache_static, contains_fn).call(_b, key, sheet, row2, col)) __privateMethod(this, _RangeCache_instances, drop_fn).call(this, key);
+    const wide = this.#wide.get(sheet);
+    if (wide !== void 0) {
+      for (const key of wide) {
+        const entry = this.#entries.get(key);
+        if (entry !== void 0 && _RangeCache.#contains(entry, sheet, row2, col)) this.#drop(key);
       }
     }
   }
   clear() {
-    __privateGet(this, _entries).clear();
-    __privateGet(this, _tiles).clear();
-    __privateGet(this, _wide).clear();
-    __privateGet(this, _placements).clear();
-    __privateGet(this, _sizes).clear();
-    __privateSet(this, _cells, 0);
+    this.#entries.clear();
+    this.#tiles.clear();
+    this.#wide.clear();
+    this.#placements.clear();
+    this.#cells = 0;
+  }
+  static #contains(entry, sheet, row2, col) {
+    return row2 >= entry.r0 && row2 <= entry.r1 && col >= entry.c0 && col <= entry.c1 && entry.sheet === sheet;
+  }
+  #drop(key) {
+    const entry = this.#entries.get(key);
+    if (entry === void 0) return;
+    this.#entries.delete(key);
+    this.#cells -= entry.cells;
+    const buckets = this.#placements.get(key);
+    if (buckets !== void 0) {
+      for (const { store, bucketKey, set } of buckets) {
+        set.delete(key);
+        if (set.size === 0) store.delete(bucketKey);
+      }
+      this.#placements.delete(key);
+    }
   }
-};
-_entries = new WeakMap();
-_tiles = new WeakMap();
-_wide = new WeakMap();
-_placements = new WeakMap();
-_sizes = new WeakMap();
-_cells = new WeakMap();
-_maxCells = new WeakMap();
-_RangeCache_static = new WeakSet();
-contains_fn = function(key, sheet, row2, col) {
-  const parts = key.split(" ");
-  const n = parts.length;
-  const c1 = +parts[n - 1], r1 = +parts[n - 2], c0 = +parts[n - 3], r0 = +parts[n - 4];
-  if (parts.slice(0, n - 4).join(" ") !== sheet) return false;
-  return row2 >= r0 && row2 <= r1 && col >= c0 && col <= c1;
-};
-_RangeCache_instances = new WeakSet();
-drop_fn = function(key) {
-  if (!__privateGet(this, _entries).delete(key)) return;
-  __privateSet(this, _cells, __privateGet(this, _cells) - (__privateGet(this, _sizes).get(key) ?? 0));
-  __privateGet(this, _sizes).delete(key);
-  const buckets = __privateGet(this, _placements).get(key);
-  if (buckets) {
-    for (const bucket of buckets) {
-      const store = bucket.charCodeAt(0) === 119 ? __privateGet(this, _wide) : __privateGet(this, _tiles);
-      const bucketKey = bucket.slice(2);
-      const set = store.get(bucketKey);
-      if (!set) continue;
-      set.delete(key);
-      if (set.size === 0) store.delete(bucketKey);
+  #fileIn(store, bucketKey, entryKey, buckets) {
+    let set = store.get(bucketKey);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      store.set(bucketKey, set);
     }
-    __privateGet(this, _placements).delete(key);
+    if (set.has(entryKey)) return;
+    set.add(entryKey);
+    buckets.push({ store, bucketKey, set });
   }
 };
-fileIn_fn = function(store, bucketKey, entryKey, buckets, bucketId) {
-  let set = store.get(bucketKey);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    store.set(bucketKey, set);
-  }
-  if (set.has(entryKey)) return;
-  set.add(entryKey);
-  buckets.push(bucketId);
-};
-__privateAdd(_RangeCache, _RangeCache_static);
-var RangeCache = _RangeCache;
 function extractReferences(ast, formulaSheet, registry = FunctionRegistry.default, resolveName2) {
   const refs = [];
   let volatile = false;
@@ -5392,24 +5429,20 @@ var MAX_EXACT_SPAN = 16;
 var MAX_BUCKETS_PER_REF = 64;
 var tileOfRow = (row2) => row2 / TILE_ROWS2 | 0;
 var tileOfCol = (col) => col / TILE_COLS2 | 0;
-var _buckets, _placements2, _DependencyIndex_instances, visit_fn, file_fn;
 var DependencyIndex = class {
-  constructor() {
-    __privateAdd(this, _DependencyIndex_instances);
-    /**
-     * All buckets in one map, keyed by a discriminating prefix:
-     *
-     *   `t s tr tc`  rectangle compact in both dimensions
-     *   `c s col tr` narrow columns, row tiles     (the common case)
-     *   `C s col`    narrow columns, every row     (`A:A`)
-     *   `r s row tc` narrow rows, column tiles
-     *   `R s row`    narrow rows, every column     (`1:1`)
-     *   `w s`        broad in both dimensions
-     */
-    __privateAdd(this, _buckets, /* @__PURE__ */ new Map());
-    /** formula key → the buckets it was filed under, for cheap removal. */
-    __privateAdd(this, _placements2, /* @__PURE__ */ new Map());
-  }
+  /**
+   * All buckets in one map, keyed by a discriminating prefix:
+   *
+   *   `t s tr tc`  rectangle compact in both dimensions
+   *   `c s col tr` narrow columns, row tiles     (the common case)
+   *   `C s col`    narrow columns, every row     (`A:A`)
+   *   `r s row tc` narrow rows, column tiles
+   *   `R s row`    narrow rows, every column     (`1:1`)
+   *   `w s`        broad in both dimensions
+   */
+  #buckets = /* @__PURE__ */ new Map();
+  /** formula key → the buckets it was filed under, for cheap removal. */
+  #placements = /* @__PURE__ */ new Map();
   /** Registers (or re-registers) a formula's precedent rectangles. */
   add(formulaKey, refs) {
     this.remove(formulaKey);
@@ -5426,12 +5459,12 @@ var DependencyIndex = class {
         if (colSpan * rowTiles <= MAX_BUCKETS_PER_REF && rowTiles <= MAX_TILES_PER_REF) {
           for (let col = ref.startCol; col <= ref.endCol; col++) {
             for (let tr = rowTile0; tr <= rowTile1; tr++) {
-              __privateMethod(this, _DependencyIndex_instances, file_fn).call(this, `c ${ref.sheet} ${col} ${tr}`, formulaKey, buckets);
+              this.#file(`c ${ref.sheet} ${col} ${tr}`, formulaKey, buckets);
             }
           }
         } else {
           for (let col = ref.startCol; col <= ref.endCol; col++) {
-            __privateMethod(this, _DependencyIndex_instances, file_fn).call(this, `C ${ref.sheet} ${col}`, formulaKey, buckets);
+            this.#file(`C ${ref.sheet} ${col}`, formulaKey, buckets);
           }
         }
         continue;
@@ -5440,12 +5473,12 @@ var DependencyIndex = class {
         if (rowSpan * colTiles <= MAX_BUCKETS_PER_REF && colTiles <= MAX_TILES_PER_REF) {
           for (let row2 = ref.startRow; row2 <= ref.endRow; row2++) {
             for (let tc = colTile0; tc <= colTile1; tc++) {
-              __privateMethod(this, _DependencyIndex_instances, file_fn).call(this, `r ${ref.sheet} ${row2} ${tc}`, formulaKey, buckets);
+              this.#file(`r ${ref.sheet} ${row2} ${tc}`, formulaKey, buckets);
             }
           }
         } else {
           for (let row2 = ref.startRow; row2 <= ref.endRow; row2++) {
-            __privateMethod(this, _DependencyIndex_instances, file_fn).call(this, `R ${ref.sheet} ${row2}`, formulaKey, buckets);
+            this.#file(`R ${ref.sheet} ${row2}`, formulaKey, buckets);
           }
         }
         continue;
@@ -5453,31 +5486,31 @@ var DependencyIndex = class {
       if (rowTiles * colTiles <= MAX_TILES_PER_REF) {
         for (let tr = rowTile0; tr <= rowTile1; tr++) {
           for (let tc = colTile0; tc <= colTile1; tc++) {
-            __privateMethod(this, _DependencyIndex_instances, file_fn).call(this, `t ${ref.sheet} ${tr} ${tc}`, formulaKey, buckets);
+            this.#file(`t ${ref.sheet} ${tr} ${tc}`, formulaKey, buckets);
           }
         }
         continue;
       }
-      __privateMethod(this, _DependencyIndex_instances, file_fn).call(this, `w ${ref.sheet}`, formulaKey, buckets);
+      this.#file(`w ${ref.sheet}`, formulaKey, buckets);
     }
-    __privateGet(this, _placements2).set(formulaKey, buckets);
+    this.#placements.set(formulaKey, buckets);
   }
   /** Forgets a formula. */
   remove(formulaKey) {
-    const buckets = __privateGet(this, _placements2).get(formulaKey);
+    const buckets = this.#placements.get(formulaKey);
     if (!buckets) return;
     for (const bucket of buckets) {
-      const set = __privateGet(this, _buckets).get(bucket);
+      const set = this.#buckets.get(bucket);
       if (!set) continue;
       set.delete(formulaKey);
-      if (set.size === 0) __privateGet(this, _buckets).delete(bucket);
+      if (set.size === 0) this.#buckets.delete(bucket);
     }
-    __privateGet(this, _placements2).delete(formulaKey);
+    this.#placements.delete(formulaKey);
   }
   /** Drops every registration. */
   clear() {
-    __privateGet(this, _buckets).clear();
-    __privateGet(this, _placements2).clear();
+    this.#buckets.clear();
+    this.#placements.clear();
   }
   /**
    * Calls `visit` with the key of each formula that *may* read the given cell.
@@ -5489,31 +5522,28 @@ var DependencyIndex = class {
   candidates(sheet, row2, col, visit) {
     const tr = tileOfRow(row2);
     const tc = tileOfCol(col);
-    __privateMethod(this, _DependencyIndex_instances, visit_fn).call(this, `c ${sheet} ${col} ${tr}`, visit);
-    __privateMethod(this, _DependencyIndex_instances, visit_fn).call(this, `C ${sheet} ${col}`, visit);
-    __privateMethod(this, _DependencyIndex_instances, visit_fn).call(this, `r ${sheet} ${row2} ${tc}`, visit);
-    __privateMethod(this, _DependencyIndex_instances, visit_fn).call(this, `R ${sheet} ${row2}`, visit);
-    __privateMethod(this, _DependencyIndex_instances, visit_fn).call(this, `t ${sheet} ${tr} ${tc}`, visit);
-    __privateMethod(this, _DependencyIndex_instances, visit_fn).call(this, `w ${sheet}`, visit);
+    this.#visit(`c ${sheet} ${col} ${tr}`, visit);
+    this.#visit(`C ${sheet} ${col}`, visit);
+    this.#visit(`r ${sheet} ${row2} ${tc}`, visit);
+    this.#visit(`R ${sheet} ${row2}`, visit);
+    this.#visit(`t ${sheet} ${tr} ${tc}`, visit);
+    this.#visit(`w ${sheet}`, visit);
+  }
+  #visit(bucket, visit) {
+    const set = this.#buckets.get(bucket);
+    if (set) for (const key of set) visit(key);
+  }
+  #file(bucket, formulaKey, buckets) {
+    let set = this.#buckets.get(bucket);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.#buckets.set(bucket, set);
+    }
+    if (set.has(formulaKey)) return;
+    set.add(formulaKey);
+    buckets.push(bucket);
   }
 };
-_buckets = new WeakMap();
-_placements2 = new WeakMap();
-_DependencyIndex_instances = new WeakSet();
-visit_fn = function(bucket, visit) {
-  const set = __privateGet(this, _buckets).get(bucket);
-  if (set) for (const key of set) visit(key);
-};
-file_fn = function(bucket, formulaKey, buckets) {
-  let set = __privateGet(this, _buckets).get(bucket);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    __privateGet(this, _buckets).set(bucket, set);
-  }
-  if (set.has(formulaKey)) return;
-  set.add(formulaKey);
-  buckets.push(bucket);
-};
 
 // src/recalc-engine.ts
 function createWorkbookRecalcModel(workbook) {
@@ -5546,6 +5576,7 @@ function createWorkbookRecalcModel(workbook) {
   };
 }
 var MAX_ADOPTED_SPILL_CELLS = 262144;
+var resultOf = (fv2) => fv2.isBlank ? 0 : fv2.toObject();
 var normSheet = (s) => s.toUpperCase();
 var normRef = (r) => r.replace(/\$/g, "").toUpperCase();
 var keyOf = (sheet, ref) => `${normSheet(sheet)}!${normRef(ref)}`;
@@ -5556,42 +5587,70 @@ function parseKey(key) {
   const { row: row2, column: column2 } = parseCellRef(ref);
   return { sheet, ref, row: row2, col: column2 };
 }
-var _model, _registry, _formulas, _sheetNames, _spills, _spillOwner, _dependents, _volatiles, _sheetLikes, _workbookLike, _rangeCache, _RecalcEngine_instances, writeCell_fn, register_fn, unregister_fn, rememberSheet_fn, adoptDeclaredSpill_fn, recalcInOrder_fn, applyShift_fn, shiftPrecedents_fn, shiftSpillBookkeeping_fn, recalcFrom_fn, runFixpoint_fn, addVolatiles_fn, dependentClosure_fn, forEachDirectDependent_fn, evaluatePass_fn, writeResult_fn, isOccupied_fn, clearSpill_fn, evaluateFormulaValue_fn, sheetLike_fn, buildSheetLike_fn, buildWorkbookLike_fn;
 var RecalcEngine = class {
+  #model;
+  #registry;
+  #formulas = /* @__PURE__ */ new Map();
+  /** upper-cased sheet key → original casing, for case-correct model I/O. */
+  #sheetNames = /* @__PURE__ */ new Map();
+  /** anchor cellKey → set of spilled (non-anchor) cellKeys it currently owns. */
+  #spills = /* @__PURE__ */ new Map();
+  /** spilled cellKey → the anchor cellKey that owns it. */
+  #spillOwner = /* @__PURE__ */ new Map();
+  /**
+   * Reverse dependency index, so finding the formulas that read a cell does not
+   * mean testing every registered formula.
+   */
+  #dependents = new DependencyIndex();
+  /**
+   * Keys of the volatile formulas. Maintained incrementally: scanning every
+   * formula for volatility on each edit is O(F) per keystroke on its own.
+   */
+  #volatiles = /* @__PURE__ */ new Set();
+  /** Memoised per-sheet adapters — these are stateless w.r.t. the formula. */
+  #sheetLikes = /* @__PURE__ */ new Map();
+  #workbookLike;
+  /**
+   * Memo for range reads. The engine owns it because it owns the writes: every
+   * value written goes through {@link #writeCell}, which drops the cached
+   * rectangles containing that cell. Nothing else may write to the model behind
+   * the engine's back without calling {@link onCellChanged} — that was already
+   * true for dependency tracking, and now also keeps this memo honest.
+   */
+  #rangeCache = new RangeCache();
   constructor(model, registry = FunctionRegistry.default) {
-    __privateAdd(this, _RecalcEngine_instances);
-    __privateAdd(this, _model);
-    __privateAdd(this, _registry);
-    __privateAdd(this, _formulas, /* @__PURE__ */ new Map());
-    /** upper-cased sheet key → original casing, for case-correct model I/O. */
-    __privateAdd(this, _sheetNames, /* @__PURE__ */ new Map());
-    /** anchor cellKey → set of spilled (non-anchor) cellKeys it currently owns. */
-    __privateAdd(this, _spills, /* @__PURE__ */ new Map());
-    /** spilled cellKey → the anchor cellKey that owns it. */
-    __privateAdd(this, _spillOwner, /* @__PURE__ */ new Map());
-    /**
-     * Reverse dependency index, so finding the formulas that read a cell does not
-     * mean testing every registered formula.
-     */
-    __privateAdd(this, _dependents, new DependencyIndex());
-    /**
-     * Keys of the volatile formulas. Maintained incrementally: scanning every
-     * formula for volatility on each edit is O(F) per keystroke on its own.
-     */
-    __privateAdd(this, _volatiles, /* @__PURE__ */ new Set());
-    /** Memoised per-sheet adapters — these are stateless w.r.t. the formula. */
-    __privateAdd(this, _sheetLikes, /* @__PURE__ */ new Map());
-    __privateAdd(this, _workbookLike);
-    /**
-     * Memo for range reads. The engine owns it because it owns the writes: every
-     * value written goes through {@link #writeCell}, which drops the cached
-     * rectangles containing that cell. Nothing else may write to the model behind
-     * the engine's back without calling {@link onCellChanged} — that was already
-     * true for dependency tracking, and now also keeps this memo honest.
-     */
-    __privateAdd(this, _rangeCache, new RangeCache());
-    __privateSet(this, _model, model);
-    __privateSet(this, _registry, registry);
+    this.#model = model;
+    this.#registry = registry;
+  }
+  /**
+   * The single write path into the model. Writing a value invalidates the
+   * cached rectangles that contain the cell, so a formula evaluated later in the
+   * same pass cannot read a pre-write copy of a range. Coordinates are passed in
+   * where the caller already knows them, to avoid re-parsing the reference.
+   */
+  #writeCell(sheetName, ref, value2, row2, col) {
+    this.#model.setCellValue(sheetName, ref, value2);
+    if (row2 === void 0 || col === void 0) {
+      const parsed = parseCellRef(ref);
+      row2 = parsed.row;
+      col = parsed.column;
+    }
+    this.#rangeCache.invalidateCell(normSheet(sheetName), row2, col);
+  }
+  /** Registers an entry in the map, the reverse index and the volatile set. */
+  #register(entry) {
+    this.#formulas.set(entry.key, entry);
+    this.#dependents.add(entry.key, entry.refs);
+    if (entry.volatile) this.#volatiles.add(entry.key);
+    else this.#volatiles.delete(entry.key);
+  }
+  #unregister(key) {
+    this.#formulas.delete(key);
+    this.#dependents.remove(key);
+    this.#volatiles.delete(key);
+  }
+  #rememberSheet(name) {
+    this.#sheetNames.set(normSheet(name), name);
   }
   // ── Registration ─────────────────────────────────────────────────────────────
   /**
@@ -5609,12 +5668,12 @@ var RecalcEngine = class {
     const { refs, volatile } = extractReferences(
       ast,
       s,
-      __privateGet(this, _registry),
-      __privateGet(this, _model).getDefinedName ? (n, sh) => __privateGet(this, _model).getDefinedName(n, sh) : void 0
+      this.#registry,
+      this.#model.getDefinedName ? (n, sh) => this.#model.getDefinedName(n, sh) : void 0
     );
-    __privateMethod(this, _RecalcEngine_instances, rememberSheet_fn).call(this, sheet);
+    this.#rememberSheet(sheet);
     const key = keyOf(s, r);
-    __privateMethod(this, _RecalcEngine_instances, register_fn).call(this, {
+    this.#register({
       sheet: s,
       sheetName: sheet,
       ref: r,
@@ -5626,9 +5685,9 @@ var RecalcEngine = class {
       refs,
       volatile
     });
-    __privateGet(this, _model).setCellFormula?.(sheet, r, text);
-    __privateGet(this, _rangeCache).invalidateCell(s, row2, column2);
-    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }], key);
+    this.#model.setCellFormula?.(sheet, r, text);
+    this.#rangeCache.invalidateCell(s, row2, column2);
+    return this.#recalcFrom([{ sheet: s, row: row2, col: column2 }], key);
   }
   /**
    * Indexes many formulas **without evaluating anything**.
@@ -5650,7 +5709,7 @@ var RecalcEngine = class {
    * construct in a large workbook should not abort the load.
    */
   registerBulk(entries) {
-    const resolveName2 = __privateGet(this, _model).getDefinedName ? (n, sh) => __privateGet(this, _model).getDefinedName(n, sh) : void 0;
+    const resolveName2 = this.#model.getDefinedName ? (n, sh) => this.#model.getDefinedName(n, sh) : void 0;
     let registered = 0;
     const failed = [];
     for (const entry of entries) {
@@ -5662,10 +5721,10 @@ var RecalcEngine = class {
       try {
         const { row: row2, column: column2 } = parseCellRef(r);
         const ast = parseFormulaUncached(text);
-        const { refs, volatile } = extractReferences(ast, s, __privateGet(this, _registry), resolveName2);
-        __privateMethod(this, _RecalcEngine_instances, rememberSheet_fn).call(this, sheet);
+        const { refs, volatile } = extractReferences(ast, s, this.#registry, resolveName2);
+        this.#rememberSheet(sheet);
         const key = keyOf(s, r);
-        __privateMethod(this, _RecalcEngine_instances, register_fn).call(this, {
+        this.#register({
           sheet: s,
           sheetName: sheet,
           ref: r,
@@ -5677,15 +5736,60 @@ var RecalcEngine = class {
           refs,
           volatile
         });
-        __privateMethod(this, _RecalcEngine_instances, adoptDeclaredSpill_fn).call(this, s, sheet, r, key, row2, column2);
+        this.#adoptDeclaredSpill(s, sheet, r, key, row2, column2);
         registered++;
       } catch (err) {
         failed.push({ sheet, ref, error: err instanceof Error ? err.message : String(err) });
       }
     }
-    if (registered > 0) __privateGet(this, _rangeCache).clear();
+    if (registered > 0) this.#rangeCache.clear();
     return { registered, failed };
   }
+  /**
+   * Takes ownership of the spill block a *file* already declared for an anchor.
+   *
+   * Excel stores a dynamic array as one formula on the anchor plus the spilled
+   * results written as plain cached values in the cells below/right, and records
+   * the extent in the anchor's `<f t="array" ref="…">`. Without this step the
+   * engine meets those cached values on the first recalculation, sees literal
+   * content inside the block it wants to spill into, and reports `#SPILL!` for
+   * every dynamic array in every real file. Registering the declared block as
+   * this anchor's existing spill makes them what they actually are — the anchor's
+   * own territory, free to overwrite — and reuses the ordinary shrink path, so a
+   * result smaller than the declared block clears the leftovers.
+   *
+   * Cost is one Set entry per already-spilled cell, paid once at load. A declared
+   * block far larger than any real spill (a corrupt or hand-written `ref`) is
+   * skipped rather than materialised.
+   */
+  #adoptDeclaredSpill(s, sheetName, ref, anchorKey, row2, col) {
+    const declared = this.#model.getSpillRange?.(sheetName, ref);
+    if (!declared || !declared.includes(":")) return;
+    let rect;
+    try {
+      rect = parseRangeRef(declared);
+    } catch {
+      return;
+    }
+    if (rect.startRow !== row2 || rect.startColumn !== col) return;
+    const height = rect.endRow - rect.startRow + 1;
+    const width = rect.endColumn - rect.startColumn + 1;
+    if (height < 1 || width < 1) return;
+    if (height * width > MAX_ADOPTED_SPILL_CELLS) return;
+    if (height === 1 && width === 1) return;
+    const members = /* @__PURE__ */ new Set();
+    for (let r = rect.startRow; r <= rect.endRow; r++) {
+      for (let c = rect.startColumn; c <= rect.endColumn; c++) {
+        if (r === row2 && c === col) continue;
+        const key = keyOf(s, cellRefFromRowCol(r, c));
+        if (this.#formulas.has(key)) continue;
+        if (this.#spillOwner.has(key)) continue;
+        members.add(key);
+        this.#spillOwner.set(key, anchorKey);
+      }
+    }
+    if (members.size > 0) this.#spills.set(anchorKey, members);
+  }
   /**
    * Removes a formula from a cell and recalculates its dependents (which may now
    * read a plain input value instead). Returns the recomputed dependent cells.
@@ -5694,36 +5798,36 @@ var RecalcEngine = class {
     const s = normSheet(sheet);
     const r = normRef(ref);
     const key = keyOf(s, r);
-    if (!__privateGet(this, _formulas).has(key)) return [];
-    __privateMethod(this, _RecalcEngine_instances, unregister_fn).call(this, key);
-    __privateGet(this, _model).clearCell?.(sheet, r);
+    if (!this.#formulas.has(key)) return [];
+    this.#unregister(key);
+    this.#model.clearCell?.(sheet, r);
     const { row: row2, column: column2 } = parseCellRef(r);
-    __privateGet(this, _rangeCache).invalidateCell(s, row2, column2);
-    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }]);
+    this.#rangeCache.invalidateCell(s, row2, column2);
+    return this.#recalcFrom([{ sheet: s, row: row2, col: column2 }]);
   }
   /**
    * Writes a raw input value to a cell and recalculates every formula that
    * depends on it. Use this for non-formula edits so dependents stay current.
    */
   setCellValue(sheet, ref, value2) {
-    __privateMethod(this, _RecalcEngine_instances, rememberSheet_fn).call(this, sheet);
+    this.#rememberSheet(sheet);
     const s = normSheet(sheet);
     const r = normRef(ref);
     const { row: row2, column: column2 } = parseCellRef(r);
-    __privateMethod(this, _RecalcEngine_instances, writeCell_fn).call(this, sheet, r, value2, row2, column2);
-    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }]);
+    this.#writeCell(sheet, r, value2, row2, column2);
+    return this.#recalcFrom([{ sheet: s, row: row2, col: column2 }]);
   }
   /**
    * Signals that a cell changed by some external means (the model was already
    * updated) and recalculates its dependents.
    */
   onCellChanged(sheet, ref) {
-    __privateMethod(this, _RecalcEngine_instances, rememberSheet_fn).call(this, sheet);
+    this.#rememberSheet(sheet);
     const s = normSheet(sheet);
     const r = normRef(ref);
     const { row: row2, column: column2 } = parseCellRef(r);
-    __privateGet(this, _rangeCache).invalidateCell(s, row2, column2);
-    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }]);
+    this.#rangeCache.invalidateCell(s, row2, column2);
+    return this.#recalcFrom([{ sheet: s, row: row2, col: column2 }]);
   }
   /**
    * Recalculates every registered formula.
@@ -5756,18 +5860,61 @@ var RecalcEngine = class {
   recalcAll(options) {
     const order = options?.order;
     if (!order || order.length === 0) {
-      return __privateMethod(this, _RecalcEngine_instances, evaluatePass_fn).call(this, [...__privateGet(this, _formulas).values()]).results;
+      return this.#evaluatePass([...this.#formulas.values()]).results;
     }
-    const attempt = __privateMethod(this, _RecalcEngine_instances, recalcInOrder_fn).call(this, order);
+    const attempt = this.#recalcInOrder(order);
     if (attempt.conflict) {
       options?.onOrderConflict?.(attempt.conflict);
-      return __privateMethod(this, _RecalcEngine_instances, evaluatePass_fn).call(this, [...__privateGet(this, _formulas).values()]).results;
+      return this.#evaluatePass([...this.#formulas.values()]).results;
     }
     return attempt.results;
   }
+  /**
+   * One pass in a caller-supplied order, watching for inversions.
+   *
+   * The check is the mirror image of the topological sort: instead of asking
+   * "which of my precedents come first?", it asks, of each formula just
+   * evaluated, "has anything that reads me already run?". The dependency index
+   * answers that directly, and one positive answer is enough to know the order
+   * cannot be trusted.
+   */
+  #recalcInOrder(order) {
+    const results = [];
+    const changed = [];
+    const done = /* @__PURE__ */ new Set();
+    let spilled = false;
+    for (const { sheet, ref } of order) {
+      const key = keyOf(sheet, ref);
+      if (done.has(key)) continue;
+      const entry = this.#formulas.get(key);
+      if (!entry) continue;
+      done.add(key);
+      const written = this.#writeResult(entry);
+      results.push(written.result);
+      changed.push(...written.changed);
+      if (written.result.spill) spilled = true;
+      let conflict;
+      this.#forEachDirectDependent({ sheet: entry.sheet, row: entry.row, col: entry.col }, (dep) => {
+        if (conflict || dep.key === entry.key) return;
+        if (done.has(dep.key)) conflict = { dependent: dep.key, precedent: entry.key };
+      });
+      if (conflict) return { results: [], conflict };
+    }
+    const rest = [...this.#formulas.values()].filter((e) => !done.has(e.key));
+    if (rest.length > 0) {
+      const pass = this.#evaluatePass(rest);
+      results.push(...pass.results);
+      changed.push(...pass.changed);
+    }
+    if (spilled) {
+      const evaluated = new Set(done);
+      results.push(...this.#runFixpoint(this.#dependentClosure(changed, evaluated), evaluated));
+    }
+    return { results };
+  }
   /** The precedents recorded for a formula cell (mainly for tests/inspection). */
   getPrecedents(sheet, ref) {
-    return __privateGet(this, _formulas).get(keyOf(sheet, ref))?.refs ?? [];
+    return this.#formulas.get(keyOf(sheet, ref))?.refs ?? [];
   }
   // ── Structural edits ─────────────────────────────────────────────────────────
   /**
@@ -5782,7 +5929,7 @@ var RecalcEngine = class {
    * engine.onRowsInserted('S1', 3, 2);
    */
   onRowsInserted(sheet, at, count2 = 1) {
-    return __privateMethod(this, _RecalcEngine_instances, applyShift_fn).call(this, { dim: "row", kind: "insert", at, count: count2, sheetName: sheet });
+    return this.#applyShift({ dim: "row", kind: "insert", at, count: count2, sheetName: sheet });
   }
   /**
    * Tells the engine rows were deleted on a sheet. Call AFTER the
@@ -5792,556 +5939,420 @@ var RecalcEngine = class {
    * volatiles) are recomputed.
    */
   onRowsDeleted(sheet, at, count2 = 1) {
-    return __privateMethod(this, _RecalcEngine_instances, applyShift_fn).call(this, { dim: "row", kind: "delete", at, count: count2, sheetName: sheet });
+    return this.#applyShift({ dim: "row", kind: "delete", at, count: count2, sheetName: sheet });
   }
   /** Column counterpart to {@link onRowsInserted}. */
   onColumnsInserted(sheet, at, count2 = 1) {
-    return __privateMethod(this, _RecalcEngine_instances, applyShift_fn).call(this, { dim: "col", kind: "insert", at, count: count2, sheetName: sheet });
+    return this.#applyShift({ dim: "col", kind: "insert", at, count: count2, sheetName: sheet });
   }
   /** Column counterpart to {@link onRowsDeleted}. */
   onColumnsDeleted(sheet, at, count2 = 1) {
-    return __privateMethod(this, _RecalcEngine_instances, applyShift_fn).call(this, { dim: "col", kind: "delete", at, count: count2, sheetName: sheet });
-  }
-};
-_model = new WeakMap();
-_registry = new WeakMap();
-_formulas = new WeakMap();
-_sheetNames = new WeakMap();
-_spills = new WeakMap();
-_spillOwner = new WeakMap();
-_dependents = new WeakMap();
-_volatiles = new WeakMap();
-_sheetLikes = new WeakMap();
-_workbookLike = new WeakMap();
-_rangeCache = new WeakMap();
-_RecalcEngine_instances = new WeakSet();
-/**
- * The single write path into the model. Writing a value invalidates the
- * cached rectangles that contain the cell, so a formula evaluated later in the
- * same pass cannot read a pre-write copy of a range. Coordinates are passed in
- * where the caller already knows them, to avoid re-parsing the reference.
- */
-writeCell_fn = function(sheetName, ref, value2, row2, col) {
-  __privateGet(this, _model).setCellValue(sheetName, ref, value2);
-  if (row2 === void 0 || col === void 0) {
-    const parsed = parseCellRef(ref);
-    row2 = parsed.row;
-    col = parsed.column;
-  }
-  __privateGet(this, _rangeCache).invalidateCell(normSheet(sheetName), row2, col);
-};
-/** Registers an entry in the map, the reverse index and the volatile set. */
-register_fn = function(entry) {
-  __privateGet(this, _formulas).set(entry.key, entry);
-  __privateGet(this, _dependents).add(entry.key, entry.refs);
-  if (entry.volatile) __privateGet(this, _volatiles).add(entry.key);
-  else __privateGet(this, _volatiles).delete(entry.key);
-};
-unregister_fn = function(key) {
-  __privateGet(this, _formulas).delete(key);
-  __privateGet(this, _dependents).remove(key);
-  __privateGet(this, _volatiles).delete(key);
-};
-rememberSheet_fn = function(name) {
-  __privateGet(this, _sheetNames).set(normSheet(name), name);
-};
-/**
- * Takes ownership of the spill block a *file* already declared for an anchor.
- *
- * Excel stores a dynamic array as one formula on the anchor plus the spilled
- * results written as plain cached values in the cells below/right, and records
- * the extent in the anchor's `<f t="array" ref="…">`. Without this step the
- * engine meets those cached values on the first recalculation, sees literal
- * content inside the block it wants to spill into, and reports `#SPILL!` for
- * every dynamic array in every real file. Registering the declared block as
- * this anchor's existing spill makes them what they actually are — the anchor's
- * own territory, free to overwrite — and reuses the ordinary shrink path, so a
- * result smaller than the declared block clears the leftovers.
- *
- * Cost is one Set entry per already-spilled cell, paid once at load. A declared
- * block far larger than any real spill (a corrupt or hand-written `ref`) is
- * skipped rather than materialised.
- */
-adoptDeclaredSpill_fn = function(s, sheetName, ref, anchorKey, row2, col) {
-  const declared = __privateGet(this, _model).getSpillRange?.(sheetName, ref);
-  if (!declared || !declared.includes(":")) return;
-  let rect;
-  try {
-    rect = parseRangeRef(declared);
-  } catch {
-    return;
-  }
-  if (rect.startRow !== row2 || rect.startColumn !== col) return;
-  const height = rect.endRow - rect.startRow + 1;
-  const width = rect.endColumn - rect.startColumn + 1;
-  if (height < 1 || width < 1) return;
-  if (height * width > MAX_ADOPTED_SPILL_CELLS) return;
-  if (height === 1 && width === 1) return;
-  const members = /* @__PURE__ */ new Set();
-  for (let r = rect.startRow; r <= rect.endRow; r++) {
-    for (let c = rect.startColumn; c <= rect.endColumn; c++) {
-      if (r === row2 && c === col) continue;
-      const key = keyOf(s, cellRefFromRowCol(r, c));
-      if (__privateGet(this, _formulas).has(key)) continue;
-      if (__privateGet(this, _spillOwner).has(key)) continue;
-      members.add(key);
-      __privateGet(this, _spillOwner).set(key, anchorKey);
-    }
-  }
-  if (members.size > 0) __privateGet(this, _spills).set(anchorKey, members);
-};
-/**
- * One pass in a caller-supplied order, watching for inversions.
- *
- * The check is the mirror image of the topological sort: instead of asking
- * "which of my precedents come first?", it asks, of each formula just
- * evaluated, "has anything that reads me already run?". The dependency index
- * answers that directly, and one positive answer is enough to know the order
- * cannot be trusted.
- */
-recalcInOrder_fn = function(order) {
-  const results = [];
-  const changed = [];
-  const done = /* @__PURE__ */ new Set();
-  let spilled = false;
-  for (const { sheet, ref } of order) {
-    const key = keyOf(sheet, ref);
-    if (done.has(key)) continue;
-    const entry = __privateGet(this, _formulas).get(key);
-    if (!entry) continue;
-    done.add(key);
-    const written = __privateMethod(this, _RecalcEngine_instances, writeResult_fn).call(this, entry);
-    results.push(written.result);
-    changed.push(...written.changed);
-    if (written.result.spill) spilled = true;
-    let conflict;
-    __privateMethod(this, _RecalcEngine_instances, forEachDirectDependent_fn).call(this, { sheet: entry.sheet, row: entry.row, col: entry.col }, (dep) => {
-      if (conflict || dep.key === entry.key) return;
-      if (done.has(dep.key)) conflict = { dependent: dep.key, precedent: entry.key };
-    });
-    if (conflict) return { results: [], conflict };
-  }
-  const rest = [...__privateGet(this, _formulas).values()].filter((e) => !done.has(e.key));
-  if (rest.length > 0) {
-    const pass = __privateMethod(this, _RecalcEngine_instances, evaluatePass_fn).call(this, rest);
-    results.push(...pass.results);
-    changed.push(...pass.changed);
-  }
-  if (spilled) {
-    const evaluated = new Set(done);
-    results.push(...__privateMethod(this, _RecalcEngine_instances, runFixpoint_fn).call(this, __privateMethod(this, _RecalcEngine_instances, dependentClosure_fn).call(this, changed, evaluated), evaluated));
-  }
-  return { results };
-};
-applyShift_fn = function(shift) {
-  const editedSheet = normSheet(shift.sheetName);
-  const isRowShift = shift.dim === "row";
-  const bandEnd = shift.at + shift.count - 1;
-  const rekeyed = [];
-  const needsRecalc = /* @__PURE__ */ new Set();
-  for (const e of __privateGet(this, _formulas).values()) {
-    let row2 = e.row;
-    let col = e.col;
-    if (e.sheet === editedSheet) {
-      const shifted = shiftIndex(isRowShift ? row2 : col, shift);
-      if (shifted === null) continue;
-      if (isRowShift) row2 = shifted;
-      else col = shifted;
-    }
-    const touchedBand = shift.kind === "delete" && e.refs.some((r) => r.sheet === editedSheet && (isRowShift ? r.endRow >= shift.at && r.startRow <= bandEnd : r.endCol >= shift.at && r.startCol <= bandEnd));
-    const rewritten = shiftFormulaRefs(e.formula, shift, e.sheetName);
-    const moved = row2 !== e.row || col !== e.col;
-    const ref = moved ? cellRefFromRowCol(row2, col) : e.ref;
-    const key = moved ? keyOf(e.sheet, ref) : e.key;
-    rekeyed.push({
-      ...e,
-      ref,
-      key,
-      row: row2,
-      col,
-      formula: rewritten.changed ? rewritten.text : e.formula,
-      // A rewritten formula's cached AST no longer matches its text; it is
-      // re-parsed lazily, and only if the cell is actually evaluated again.
-      ast: rewritten.changed ? void 0 : e.ast,
-      refs: __privateMethod(this, _RecalcEngine_instances, shiftPrecedents_fn).call(this, e.refs, shift, editedSheet)
-      // Volatility is a property of which *functions* a formula calls, and
-      // rewriting references cannot change that.
-    });
-    if (touchedBand || rewritten.hasRefError) needsRecalc.add(key);
-  }
-  __privateSet(this, _formulas, /* @__PURE__ */ new Map());
-  __privateGet(this, _dependents).clear();
-  __privateGet(this, _volatiles).clear();
-  for (const e of rekeyed) __privateMethod(this, _RecalcEngine_instances, register_fn).call(this, e);
-  __privateMethod(this, _RecalcEngine_instances, shiftSpillBookkeeping_fn).call(this, shift, editedSheet);
-  __privateGet(this, _rangeCache).clear();
-  const pending = /* @__PURE__ */ new Map();
-  for (const k of needsRecalc) {
-    const e = __privateGet(this, _formulas).get(k);
-    if (e) pending.set(k, e);
-  }
-  for (const e of __privateGet(this, _formulas).values()) {
-    if (e.volatile) pending.set(e.key, e);
-  }
-  return __privateMethod(this, _RecalcEngine_instances, runFixpoint_fn).call(this, pending, /* @__PURE__ */ new Set());
-};
-/**
- * Translates precedent rectangles across a structural edit.
- *
- * This is arithmetic rather than a re-parse of the rewritten formula, and the
- * two are equivalent by construction: `shiftFormulaRefs` derives the new
- * reference text by calling `shiftSpan`/`shiftIndex` on exactly these numbers,
- * so applying the same functions to the stored rectangle yields the same
- * region. A rectangle that is entirely deleted disappears, matching the
- * `#REF!` the text rewrite produces.
- */
-shiftPrecedents_fn = function(refs, shift, editedSheet) {
-  const out = [];
-  for (const r of refs) {
-    if (r.sheet !== editedSheet) {
-      out.push(r);
-      continue;
-    }
-    if (shift.dim === "row") {
-      const span = shiftSpan(r.startRow, r.endRow, shift);
-      if (!span) continue;
-      out.push({
-        sheet: r.sheet,
-        startRow: span.start,
-        endRow: Math.min(span.end, EXCEL_MAX_ROWS),
-        startCol: r.startCol,
-        endCol: r.endCol
-      });
-    } else {
-      const span = shiftSpan(r.startCol, r.endCol, shift);
-      if (!span) continue;
-      out.push({
-        sheet: r.sheet,
-        startRow: r.startRow,
-        endRow: r.endRow,
-        startCol: span.start,
-        endCol: Math.min(span.end, EXCEL_MAX_COLUMNS)
+    return this.#applyShift({ dim: "col", kind: "delete", at, count: count2, sheetName: sheet });
+  }
+  #applyShift(shift) {
+    const editedSheet = normSheet(shift.sheetName);
+    const isRowShift = shift.dim === "row";
+    const bandEnd = shift.at + shift.count - 1;
+    const rekeyed = [];
+    const needsRecalc = /* @__PURE__ */ new Set();
+    for (const e of this.#formulas.values()) {
+      let row2 = e.row;
+      let col = e.col;
+      if (e.sheet === editedSheet) {
+        const shifted = shiftIndex(isRowShift ? row2 : col, shift);
+        if (shifted === null) continue;
+        if (isRowShift) row2 = shifted;
+        else col = shifted;
+      }
+      const touchedBand = shift.kind === "delete" && e.refs.some((r) => r.sheet === editedSheet && (isRowShift ? r.endRow >= shift.at && r.startRow <= bandEnd : r.endCol >= shift.at && r.startCol <= bandEnd));
+      const rewritten = shiftFormulaRefs(e.formula, shift, e.sheetName);
+      const moved = row2 !== e.row || col !== e.col;
+      const ref = moved ? cellRefFromRowCol(row2, col) : e.ref;
+      const key = moved ? keyOf(e.sheet, ref) : e.key;
+      rekeyed.push({
+        ...e,
+        ref,
+        key,
+        row: row2,
+        col,
+        formula: rewritten.changed ? rewritten.text : e.formula,
+        // A rewritten formula's cached AST no longer matches its text; it is
+        // re-parsed lazily, and only if the cell is actually evaluated again.
+        ast: rewritten.changed ? void 0 : e.ast,
+        refs: this.#shiftPrecedents(e.refs, shift, editedSheet)
+        // Volatility is a property of which *functions* a formula calls, and
+        // rewriting references cannot change that.
       });
+      if (touchedBand || rewritten.hasRefError) needsRecalc.add(key);
+    }
+    this.#formulas = /* @__PURE__ */ new Map();
+    this.#dependents.clear();
+    this.#volatiles.clear();
+    for (const e of rekeyed) this.#register(e);
+    this.#shiftSpillBookkeeping(shift, editedSheet);
+    this.#rangeCache.clear();
+    const pending = /* @__PURE__ */ new Map();
+    for (const k of needsRecalc) {
+      const e = this.#formulas.get(k);
+      if (e) pending.set(k, e);
     }
+    for (const e of this.#formulas.values()) {
+      if (e.volatile) pending.set(e.key, e);
+    }
+    return this.#runFixpoint(pending, /* @__PURE__ */ new Set());
   }
-  return out;
-};
-/** Translates spill ownership across a structural edit on `editedSheet`. */
-shiftSpillBookkeeping_fn = function(shift, editedSheet) {
-  const shiftCellKey = (key) => {
-    const { sheet, row: row2, col } = parseKey(key);
-    if (sheet !== editedSheet) return key;
-    const r = shift.dim === "row" ? shiftIndex(row2, shift) : row2;
-    const c = shift.dim === "col" ? shiftIndex(col, shift) : col;
-    if (r === null || c === null) return null;
-    return keyOf(sheet, cellRefFromRowCol(r, c));
-  };
-  const newSpills = /* @__PURE__ */ new Map();
-  __privateGet(this, _spillOwner).clear();
-  for (const [anchor, members] of __privateGet(this, _spills)) {
-    const newAnchor = shiftCellKey(anchor);
-    if (newAnchor === null) {
+  /**
+   * Translates precedent rectangles across a structural edit.
+   *
+   * This is arithmetic rather than a re-parse of the rewritten formula, and the
+   * two are equivalent by construction: `shiftFormulaRefs` derives the new
+   * reference text by calling `shiftSpan`/`shiftIndex` on exactly these numbers,
+   * so applying the same functions to the stored rectangle yields the same
+   * region. A rectangle that is entirely deleted disappears, matching the
+   * `#REF!` the text rewrite produces.
+   */
+  #shiftPrecedents(refs, shift, editedSheet) {
+    const out = [];
+    for (const r of refs) {
+      if (r.sheet !== editedSheet) {
+        out.push(r);
+        continue;
+      }
+      if (shift.dim === "row") {
+        const span = shiftSpan(r.startRow, r.endRow, shift);
+        if (!span) continue;
+        out.push({
+          sheet: r.sheet,
+          startRow: span.start,
+          endRow: Math.min(span.end, EXCEL_MAX_ROWS),
+          startCol: r.startCol,
+          endCol: r.endCol
+        });
+      } else {
+        const span = shiftSpan(r.startCol, r.endCol, shift);
+        if (!span) continue;
+        out.push({
+          sheet: r.sheet,
+          startRow: r.startRow,
+          endRow: r.endRow,
+          startCol: span.start,
+          endCol: Math.min(span.end, EXCEL_MAX_COLUMNS)
+        });
+      }
+    }
+    return out;
+  }
+  /** Translates spill ownership across a structural edit on `editedSheet`. */
+  #shiftSpillBookkeeping(shift, editedSheet) {
+    const shiftCellKey = (key) => {
+      const { sheet, row: row2, col } = parseKey(key);
+      if (sheet !== editedSheet) return key;
+      const r = shift.dim === "row" ? shiftIndex(row2, shift) : row2;
+      const c = shift.dim === "col" ? shiftIndex(col, shift) : col;
+      if (r === null || c === null) return null;
+      return keyOf(sheet, cellRefFromRowCol(r, c));
+    };
+    const newSpills = /* @__PURE__ */ new Map();
+    this.#spillOwner.clear();
+    for (const [anchor, members] of this.#spills) {
+      const newAnchor = shiftCellKey(anchor);
+      if (newAnchor === null) {
+        for (const m of members) {
+          const shifted = shiftCellKey(m);
+          if (!shifted) continue;
+          const cell = parseKey(shifted);
+          this.#writeCell(this.#sheetNames.get(cell.sheet) ?? cell.sheet, cell.ref, null, cell.row, cell.col);
+        }
+        continue;
+      }
+      const newMembers = /* @__PURE__ */ new Set();
       for (const m of members) {
         const shifted = shiftCellKey(m);
         if (!shifted) continue;
-        const cell = parseKey(shifted);
-        __privateMethod(this, _RecalcEngine_instances, writeCell_fn).call(this, __privateGet(this, _sheetNames).get(cell.sheet) ?? cell.sheet, cell.ref, null, cell.row, cell.col);
+        newMembers.add(shifted);
+        this.#spillOwner.set(shifted, newAnchor);
       }
-      continue;
+      newSpills.set(newAnchor, newMembers);
     }
-    const newMembers = /* @__PURE__ */ new Set();
-    for (const m of members) {
-      const shifted = shiftCellKey(m);
-      if (!shifted) continue;
-      newMembers.add(shifted);
-      __privateGet(this, _spillOwner).set(shifted, newAnchor);
+    this.#spills = newSpills;
+  }
+  // ── Internals ────────────────────────────────────────────────────────────────
+  /**
+   * Recomputes formulas affected by the given changed cells, to a fixpoint.
+   *
+   * A single topological pass is not enough once dynamic arrays exist: a
+   * formula that spills changes cells the graph could not know about until the
+   * array was computed, and those cells may have their own dependents. So we
+   * evaluate a pass, collect every cell whose value actually changed (formula
+   * outputs plus spilled/cleared cells), then recompute the dependents of those
+   * cells, repeating until nothing new is affected (bounded for safety).
+   */
+  #recalcFrom(seeds, includeKey) {
+    const results = [];
+    const evaluated = /* @__PURE__ */ new Set();
+    let pending = this.#dependentClosure(seeds, evaluated);
+    this.#addVolatiles(pending);
+    if (includeKey) {
+      const self = this.#formulas.get(includeKey);
+      if (self) pending.set(includeKey, self);
+    }
+    results.push(...this.#runFixpoint(pending, evaluated));
+    return results;
+  }
+  /** Evaluates `pending` entries to a fixpoint, following spill-induced changes. */
+  #runFixpoint(pending, evaluated) {
+    const results = [];
+    let guard = 0;
+    const maxIterations = this.#formulas.size + 8;
+    while (pending.size > 0 && guard++ <= maxIterations) {
+      const { results: passResults, changed } = this.#evaluatePass([...pending.values()]);
+      results.push(...passResults);
+      for (const k of pending.keys()) evaluated.add(k);
+      pending = this.#dependentClosure(changed, evaluated);
+    }
+    return results;
+  }
+  /** Adds every volatile formula to a pending set. */
+  #addVolatiles(pending) {
+    for (const key of this.#volatiles) {
+      const e = this.#formulas.get(key);
+      if (e) pending.set(key, e);
     }
-    newSpills.set(newAnchor, newMembers);
   }
-  __privateSet(this, _spills, newSpills);
-};
-// ── Internals ────────────────────────────────────────────────────────────────
-/**
- * Recomputes formulas affected by the given changed cells, to a fixpoint.
- *
- * A single topological pass is not enough once dynamic arrays exist: a
- * formula that spills changes cells the graph could not know about until the
- * array was computed, and those cells may have their own dependents. So we
- * evaluate a pass, collect every cell whose value actually changed (formula
- * outputs plus spilled/cleared cells), then recompute the dependents of those
- * cells, repeating until nothing new is affected (bounded for safety).
- */
-recalcFrom_fn = function(seeds, includeKey) {
-  const results = [];
-  const evaluated = /* @__PURE__ */ new Set();
-  let pending = __privateMethod(this, _RecalcEngine_instances, dependentClosure_fn).call(this, seeds, evaluated);
-  __privateMethod(this, _RecalcEngine_instances, addVolatiles_fn).call(this, pending);
-  if (includeKey) {
-    const self = __privateGet(this, _formulas).get(includeKey);
-    if (self) pending.set(includeKey, self);
-  }
-  results.push(...__privateMethod(this, _RecalcEngine_instances, runFixpoint_fn).call(this, pending, evaluated));
-  return results;
-};
-/** Evaluates `pending` entries to a fixpoint, following spill-induced changes. */
-runFixpoint_fn = function(pending, evaluated) {
-  const results = [];
-  let guard = 0;
-  const maxIterations = __privateGet(this, _formulas).size + 8;
-  while (pending.size > 0 && guard++ <= maxIterations) {
-    const { results: passResults, changed } = __privateMethod(this, _RecalcEngine_instances, evaluatePass_fn).call(this, [...pending.values()]);
-    results.push(...passResults);
-    for (const k of pending.keys()) evaluated.add(k);
-    pending = __privateMethod(this, _RecalcEngine_instances, dependentClosure_fn).call(this, changed, evaluated);
-  }
-  return results;
-};
-/** Adds every volatile formula to a pending set. */
-addVolatiles_fn = function(pending) {
-  for (const key of __privateGet(this, _volatiles)) {
-    const e = __privateGet(this, _formulas).get(key);
-    if (e) pending.set(key, e);
+  /**
+   * Formula entries (not yet evaluated) whose precedents include one of the
+   * cells, transitively. The queue is walked with a head index — Array.shift()
+   * is O(n) per dequeue, which turns a long dependency chain quadratic.
+   */
+  #dependentClosure(cells, evaluated) {
+    const out = /* @__PURE__ */ new Map();
+    const queue = [...cells];
+    for (let head = 0; head < queue.length; head++) {
+      const cell = queue[head];
+      this.#forEachDirectDependent(cell, (dep) => {
+        if (out.has(dep.key) || evaluated.has(dep.key)) return;
+        out.set(dep.key, dep);
+        queue.push({ sheet: dep.sheet, row: dep.row, col: dep.col });
+      });
+    }
+    return out;
   }
-};
-/**
- * Formula entries (not yet evaluated) whose precedents include one of the
- * cells, transitively. The queue is walked with a head index — Array.shift()
- * is O(n) per dequeue, which turns a long dependency chain quadratic.
- */
-dependentClosure_fn = function(cells, evaluated) {
-  const out = /* @__PURE__ */ new Map();
-  const queue = [...cells];
-  for (let head = 0; head < queue.length; head++) {
-    const cell = queue[head];
-    __privateMethod(this, _RecalcEngine_instances, forEachDirectDependent_fn).call(this, cell, (dep) => {
-      if (out.has(dep.key) || evaluated.has(dep.key)) return;
-      out.set(dep.key, dep);
-      queue.push({ sheet: dep.sheet, row: dep.row, col: dep.col });
+  /**
+   * Visits the formula entries whose precedents include the given cell, via the
+   * reverse index. The index over-approximates (it buckets rectangles into
+   * tiles), so each candidate is still confirmed against its real rectangles.
+   */
+  #forEachDirectDependent(cell, visit) {
+    this.#dependents.candidates(cell.sheet, cell.row, cell.col, (key) => {
+      const e = this.#formulas.get(key);
+      if (!e) return;
+      for (const ref of e.refs) {
+        if (refContains(ref, cell.sheet, cell.row, cell.col)) {
+          visit(e);
+          return;
+        }
+      }
     });
   }
-  return out;
-};
-/**
- * Visits the formula entries whose precedents include the given cell, via the
- * reverse index. The index over-approximates (it buckets rectangles into
- * tiles), so each candidate is still confirmed against its real rectangles.
- */
-forEachDirectDependent_fn = function(cell, visit) {
-  __privateGet(this, _dependents).candidates(cell.sheet, cell.row, cell.col, (key) => {
-    const e = __privateGet(this, _formulas).get(key);
-    if (!e) return;
-    for (const ref of e.refs) {
-      if (refContains(ref, cell.sheet, cell.row, cell.col)) {
-        visit(e);
-        return;
+  /**
+   * Topologically sorts the given entries and evaluates them, writing results
+   * (scalars or spilled arrays) back to the model. Returns the results and the
+   * flat list of cells whose value changed. Entries left in a cycle are #REF!.
+   */
+  #evaluatePass(entries) {
+    const inSet = /* @__PURE__ */ new Map();
+    for (const e of entries) inSet.set(e.key, e);
+    const indegree = /* @__PURE__ */ new Map();
+    const dependents = /* @__PURE__ */ new Map();
+    for (const k of inSet.keys()) {
+      indegree.set(k, 0);
+      dependents.set(k, []);
+    }
+    for (const pe of entries) {
+      const seen = /* @__PURE__ */ new Set();
+      this.#forEachDirectDependent({ sheet: pe.sheet, row: pe.row, col: pe.col }, (dep) => {
+        if (dep.key === pe.key || !inSet.has(dep.key) || seen.has(dep.key)) return;
+        seen.add(dep.key);
+        dependents.get(pe.key).push(dep.key);
+        indegree.set(dep.key, indegree.get(dep.key) + 1);
+      });
+    }
+    const ready = [];
+    for (const [k, d] of indegree) if (d === 0) ready.push(k);
+    const order = [];
+    for (let head = 0; head < ready.length; head++) {
+      const k = ready[head];
+      order.push(k);
+      for (const d of dependents.get(k)) {
+        const left2 = indegree.get(d) - 1;
+        indegree.set(d, left2);
+        if (left2 === 0) ready.push(d);
       }
     }
-  });
-};
-/**
- * Topologically sorts the given entries and evaluates them, writing results
- * (scalars or spilled arrays) back to the model. Returns the results and the
- * flat list of cells whose value changed. Entries left in a cycle are #REF!.
- */
-evaluatePass_fn = function(entries) {
-  const inSet = /* @__PURE__ */ new Map();
-  for (const e of entries) inSet.set(e.key, e);
-  const indegree = /* @__PURE__ */ new Map();
-  const dependents = /* @__PURE__ */ new Map();
-  for (const k of inSet.keys()) {
-    indegree.set(k, 0);
-    dependents.set(k, []);
-  }
-  for (const pe of entries) {
-    const seen = /* @__PURE__ */ new Set();
-    __privateMethod(this, _RecalcEngine_instances, forEachDirectDependent_fn).call(this, { sheet: pe.sheet, row: pe.row, col: pe.col }, (dep) => {
-      if (dep.key === pe.key || !inSet.has(dep.key) || seen.has(dep.key)) return;
-      seen.add(dep.key);
-      dependents.get(pe.key).push(dep.key);
-      indegree.set(dep.key, indegree.get(dep.key) + 1);
-    });
+    const results = [];
+    const changed = [];
+    const emitted = new Set(order);
+    for (const k of order) {
+      const e = inSet.get(k);
+      const { result, changed: c } = this.#writeResult(e);
+      results.push(result);
+      changed.push(...c);
+    }
+    for (const [k, e] of inSet) {
+      if (emitted.has(k)) continue;
+      this.#clearSpill(e.key, changed);
+      const value2 = FormulaValue.errorRef.toObject();
+      this.#writeCell(e.sheetName, e.ref, value2, e.row, e.col);
+      changed.push({ sheet: e.sheet, row: e.row, col: e.col });
+      results.push({ sheet: e.sheetName, ref: e.ref, value: value2, circular: true });
+    }
+    return { results, changed };
   }
-  const ready = [];
-  for (const [k, d] of indegree) if (d === 0) ready.push(k);
-  const order = [];
-  for (let head = 0; head < ready.length; head++) {
-    const k = ready[head];
-    order.push(k);
-    for (const d of dependents.get(k)) {
-      const left2 = indegree.get(d) - 1;
-      indegree.set(d, left2);
-      if (left2 === 0) ready.push(d);
-    }
-  }
-  const results = [];
-  const changed = [];
-  const emitted = new Set(order);
-  for (const k of order) {
-    const e = inSet.get(k);
-    const { result, changed: c } = __privateMethod(this, _RecalcEngine_instances, writeResult_fn).call(this, e);
-    results.push(result);
-    changed.push(...c);
-  }
-  for (const [k, e] of inSet) {
-    if (emitted.has(k)) continue;
-    __privateMethod(this, _RecalcEngine_instances, clearSpill_fn).call(this, e.key, changed);
-    const value2 = FormulaValue.errorRef.toObject();
-    __privateMethod(this, _RecalcEngine_instances, writeCell_fn).call(this, e.sheetName, e.ref, value2, e.row, e.col);
-    changed.push({ sheet: e.sheet, row: e.row, col: e.col });
-    results.push({ sheet: e.sheetName, ref: e.ref, value: value2, circular: true });
-  }
-  return { results, changed };
-};
-/**
- * Evaluates one formula and writes its result. Scalars go to the anchor cell.
- * Arrays spill across a block anchored at the formula cell: on a collision
- * with existing content the anchor becomes #SPILL! and nothing spills; when
- * an array shrinks, previously-spilled cells it no longer covers are cleared.
- */
-writeResult_fn = function(e) {
-  const anchorKey = e.key;
-  const fv2 = __privateMethod(this, _RecalcEngine_instances, evaluateFormulaValue_fn).call(this, e);
-  const changed = [];
-  const prevSpill = __privateGet(this, _spills).get(anchorKey) ?? /* @__PURE__ */ new Set();
-  if (!fv2.isArray) {
-    __privateMethod(this, _RecalcEngine_instances, clearSpill_fn).call(this, anchorKey, changed);
-    __privateGet(this, _model).setCellArrayRef?.(e.sheetName, e.ref, null);
-    const value2 = fv2.toObject();
-    __privateMethod(this, _RecalcEngine_instances, writeCell_fn).call(this, e.sheetName, e.ref, value2, e.row, e.col);
-    changed.push({ sheet: e.sheet, row: e.row, col: e.col });
-    return { result: { sheet: e.sheetName, ref: e.ref, value: value2 }, changed };
-  }
-  const arr = fv2.arrayVal;
-  const rows2 = arr.rows, cols = arr.columns;
-  let collides = false;
-  for (let dr = 0; dr < rows2 && !collides; dr++) {
-    for (let dc = 0; dc < cols && !collides; dc++) {
-      if (dr === 0 && dc === 0) continue;
-      const r = e.row + dr, c = e.col + dc;
-      const cellKey2 = keyOf(e.sheet, cellRefFromRowCol(r, c));
-      if (__privateMethod(this, _RecalcEngine_instances, isOccupied_fn).call(this, cellKey2, e.sheetName, cellRefFromRowCol(r, c), anchorKey, prevSpill)) {
-        collides = true;
+  /**
+   * Evaluates one formula and writes its result. Scalars go to the anchor cell.
+   * Arrays spill across a block anchored at the formula cell: on a collision
+   * with existing content the anchor becomes #SPILL! and nothing spills; when
+   * an array shrinks, previously-spilled cells it no longer covers are cleared.
+   */
+  #writeResult(e) {
+    const anchorKey = e.key;
+    const fv2 = this.#evaluateFormulaValue(e);
+    const changed = [];
+    const prevSpill = this.#spills.get(anchorKey) ?? /* @__PURE__ */ new Set();
+    if (!fv2.isArray) {
+      this.#clearSpill(anchorKey, changed);
+      this.#model.setCellArrayRef?.(e.sheetName, e.ref, null);
+      const value2 = resultOf(fv2);
+      this.#writeCell(e.sheetName, e.ref, value2, e.row, e.col);
+      changed.push({ sheet: e.sheet, row: e.row, col: e.col });
+      return { result: { sheet: e.sheetName, ref: e.ref, value: value2 }, changed };
+    }
+    const arr = fv2.arrayVal;
+    const rows2 = arr.rows, cols = arr.columns;
+    let collides = false;
+    for (let dr = 0; dr < rows2 && !collides; dr++) {
+      for (let dc = 0; dc < cols && !collides; dc++) {
+        if (dr === 0 && dc === 0) continue;
+        const r = e.row + dr, c = e.col + dc;
+        const cellKey2 = keyOf(e.sheet, cellRefFromRowCol(r, c));
+        if (this.#isOccupied(cellKey2, e.sheetName, cellRefFromRowCol(r, c), anchorKey, prevSpill)) {
+          collides = true;
+        }
       }
     }
-  }
-  if (collides) {
-    __privateMethod(this, _RecalcEngine_instances, clearSpill_fn).call(this, anchorKey, changed);
-    __privateGet(this, _model).setCellArrayRef?.(e.sheetName, e.ref, null);
-    const value2 = FormulaValue.error(9 /* Spill */).toObject();
-    __privateMethod(this, _RecalcEngine_instances, writeCell_fn).call(this, e.sheetName, e.ref, value2, e.row, e.col);
-    changed.push({ sheet: e.sheet, row: e.row, col: e.col });
-    return { result: { sheet: e.sheetName, ref: e.ref, value: value2 }, changed };
-  }
-  const newSpill = /* @__PURE__ */ new Set();
-  for (let dr = 0; dr < rows2; dr++) {
-    for (let dc = 0; dc < cols; dc++) {
-      const r = e.row + dr, c = e.col + dc;
-      const ref = cellRefFromRowCol(r, c);
-      __privateMethod(this, _RecalcEngine_instances, writeCell_fn).call(this, e.sheetName, ref, arr.get(dr, dc).toObject(), r, c);
-      changed.push({ sheet: e.sheet, row: r, col: c });
-      if (dr !== 0 || dc !== 0) {
-        const cellKey2 = keyOf(e.sheet, ref);
-        newSpill.add(cellKey2);
-        __privateGet(this, _spillOwner).set(cellKey2, anchorKey);
+    if (collides) {
+      this.#clearSpill(anchorKey, changed);
+      this.#model.setCellArrayRef?.(e.sheetName, e.ref, null);
+      const value2 = FormulaValue.error(9 /* Spill */).toObject();
+      this.#writeCell(e.sheetName, e.ref, value2, e.row, e.col);
+      changed.push({ sheet: e.sheet, row: e.row, col: e.col });
+      return { result: { sheet: e.sheetName, ref: e.ref, value: value2 }, changed };
+    }
+    const newSpill = /* @__PURE__ */ new Set();
+    for (let dr = 0; dr < rows2; dr++) {
+      for (let dc = 0; dc < cols; dc++) {
+        const r = e.row + dr, c = e.col + dc;
+        const ref = cellRefFromRowCol(r, c);
+        this.#writeCell(e.sheetName, ref, resultOf(arr.get(dr, dc)), r, c);
+        changed.push({ sheet: e.sheet, row: r, col: c });
+        if (dr !== 0 || dc !== 0) {
+          const cellKey2 = keyOf(e.sheet, ref);
+          newSpill.add(cellKey2);
+          this.#spillOwner.set(cellKey2, anchorKey);
+        }
       }
     }
+    for (const oldKey of prevSpill) {
+      if (newSpill.has(oldKey)) continue;
+      const cell = parseKey(oldKey);
+      this.#writeCell(this.#sheetNames.get(cell.sheet) ?? cell.sheet, cell.ref, null, cell.row, cell.col);
+      this.#spillOwner.delete(oldKey);
+      changed.push({ sheet: cell.sheet, row: cell.row, col: cell.col });
+    }
+    this.#spills.set(anchorKey, newSpill);
+    const spillRef = `${e.ref}:${cellRefFromRowCol(e.row + rows2 - 1, e.col + cols - 1)}`;
+    this.#model.setCellArrayRef?.(e.sheetName, e.ref, spillRef);
+    return {
+      result: { sheet: e.sheetName, ref: e.ref, value: resultOf(arr.get(0, 0)), spill: { rows: rows2, cols } },
+      changed
+    };
   }
-  for (const oldKey of prevSpill) {
-    if (newSpill.has(oldKey)) continue;
-    const cell = parseKey(oldKey);
-    __privateMethod(this, _RecalcEngine_instances, writeCell_fn).call(this, __privateGet(this, _sheetNames).get(cell.sheet) ?? cell.sheet, cell.ref, null, cell.row, cell.col);
-    __privateGet(this, _spillOwner).delete(oldKey);
-    changed.push({ sheet: cell.sheet, row: cell.row, col: cell.col });
+  /** Whether a target cell already holds content that blocks a spill. */
+  #isOccupied(cellKey2, sheetName, ref, anchorKey, prevSpill) {
+    if (this.#formulas.has(cellKey2) && cellKey2 !== anchorKey) return true;
+    const owner = this.#spillOwner.get(cellKey2);
+    if (owner && owner !== anchorKey) return true;
+    if (prevSpill.has(cellKey2)) return false;
+    const v = this.#model.getCellValue(sheetName, ref);
+    return v !== null && v !== void 0 && v !== "";
+  }
+  /** Clears an anchor's spilled cells (not the anchor itself) and forgets them. */
+  #clearSpill(anchorKey, changed) {
+    const spill = this.#spills.get(anchorKey);
+    if (!spill) return;
+    for (const cellKey2 of spill) {
+      const cell = parseKey(cellKey2);
+      this.#writeCell(this.#sheetNames.get(cell.sheet) ?? cell.sheet, cell.ref, null, cell.row, cell.col);
+      this.#spillOwner.delete(cellKey2);
+      changed.push({ sheet: cell.sheet, row: cell.row, col: cell.col });
+    }
+    this.#spills.delete(anchorKey);
+  }
+  #evaluateFormulaValue(e) {
+    if (!e.ast) {
+      try {
+        e.ast = parseFormulaUncached(e.formula);
+      } catch {
+        return FormulaValue.errorValue;
+      }
+    }
+    return evaluateAst(e.ast, this.#sheetLike(e.sheetName), {
+      workbook: this.#buildWorkbookLike(),
+      formulaRow: e.row,
+      formulaCol: e.col,
+      rangeCache: this.#rangeCache
+    });
   }
-  __privateGet(this, _spills).set(anchorKey, newSpill);
-  const spillRef = `${e.ref}:${cellRefFromRowCol(e.row + rows2 - 1, e.col + cols - 1)}`;
-  __privateGet(this, _model).setCellArrayRef?.(e.sheetName, e.ref, spillRef);
-  return {
-    result: { sheet: e.sheetName, ref: e.ref, value: arr.get(0, 0).toObject(), spill: { rows: rows2, cols } },
-    changed
-  };
-};
-/** Whether a target cell already holds content that blocks a spill. */
-isOccupied_fn = function(cellKey2, sheetName, ref, anchorKey, prevSpill) {
-  if (__privateGet(this, _formulas).has(cellKey2) && cellKey2 !== anchorKey) return true;
-  const owner = __privateGet(this, _spillOwner).get(cellKey2);
-  if (owner && owner !== anchorKey) return true;
-  if (prevSpill.has(cellKey2)) return false;
-  const v = __privateGet(this, _model).getCellValue(sheetName, ref);
-  return v !== null && v !== void 0 && v !== "";
-};
-/** Clears an anchor's spilled cells (not the anchor itself) and forgets them. */
-clearSpill_fn = function(anchorKey, changed) {
-  const spill = __privateGet(this, _spills).get(anchorKey);
-  if (!spill) return;
-  for (const cellKey2 of spill) {
-    const cell = parseKey(cellKey2);
-    __privateMethod(this, _RecalcEngine_instances, writeCell_fn).call(this, __privateGet(this, _sheetNames).get(cell.sheet) ?? cell.sheet, cell.ref, null, cell.row, cell.col);
-    __privateGet(this, _spillOwner).delete(cellKey2);
-    changed.push({ sheet: cell.sheet, row: cell.row, col: cell.col });
-  }
-  __privateGet(this, _spills).delete(anchorKey);
-};
-evaluateFormulaValue_fn = function(e) {
-  if (!e.ast) {
-    try {
-      e.ast = parseFormulaUncached(e.formula);
-    } catch {
-      return FormulaValue.errorValue;
+  /**
+   * Per-sheet evaluator adapter. Memoised: these hold no per-formula state, and
+   * rebuilding one (with its four closures) for every formula evaluated made a
+   * full recalc allocate several objects per cell.
+   */
+  #sheetLike(sheetName) {
+    let cached = this.#sheetLikes.get(sheetName);
+    if (!cached) {
+      cached = this.#buildSheetLike(sheetName);
+      this.#sheetLikes.set(sheetName, cached);
     }
+    return cached;
+  }
+  #buildSheetLike(sheetName) {
+    const model = this.#model;
+    return {
+      name: sheetName,
+      getCellValue: (ref) => this.#model.getCellValue(sheetName, ref),
+      getCellValueAt: model.getCellValueAt ? (row2, column2) => model.getCellValueAt(sheetName, row2, column2) : void 0,
+      // A getter, not a snapshot: the extent grows as formulas write results,
+      // and a whole-column reference read later in the same pass must see it.
+      get usedBounds() {
+        return model.getUsedBounds?.(sheetName);
+      },
+      isRowHidden: this.#model.isRowHidden ? (row2) => this.#model.isRowHidden(sheetName, row2) : void 0,
+      getCellFormula: this.#model.getCellFormula ? (ref) => this.#model.getCellFormula(sheetName, ref) : void 0,
+      getSpillRange: this.#model.getSpillRange ? (ref) => this.#model.getSpillRange(sheetName, ref) : void 0
+    };
+  }
+  #buildWorkbookLike() {
+    if (this.#workbookLike) return this.#workbookLike;
+    const self = this;
+    return this.#workbookLike = {
+      get worksheets() {
+        return [...self.#sheetNames.values()].map((n) => self.#sheetLike(n));
+      },
+      getWorksheet: (name) => self.#sheetLike(name),
+      getDefinedName: this.#model.getDefinedName ? (name, sheet) => this.#model.getDefinedName(name, sheet) : void 0
+    };
   }
-  return evaluateAst(e.ast, __privateMethod(this, _RecalcEngine_instances, sheetLike_fn).call(this, e.sheetName), {
-    workbook: __privateMethod(this, _RecalcEngine_instances, buildWorkbookLike_fn).call(this),
-    formulaRow: e.row,
-    formulaCol: e.col,
-    rangeCache: __privateGet(this, _rangeCache)
-  });
-};
-/**
- * Per-sheet evaluator adapter. Memoised: these hold no per-formula state, and
- * rebuilding one (with its four closures) for every formula evaluated made a
- * full recalc allocate several objects per cell.
- */
-sheetLike_fn = function(sheetName) {
-  let cached = __privateGet(this, _sheetLikes).get(sheetName);
-  if (!cached) {
-    cached = __privateMethod(this, _RecalcEngine_instances, buildSheetLike_fn).call(this, sheetName);
-    __privateGet(this, _sheetLikes).set(sheetName, cached);
-  }
-  return cached;
-};
-buildSheetLike_fn = function(sheetName) {
-  const model = __privateGet(this, _model);
-  return {
-    name: sheetName,
-    getCellValue: (ref) => __privateGet(this, _model).getCellValue(sheetName, ref),
-    getCellValueAt: model.getCellValueAt ? (row2, column2) => model.getCellValueAt(sheetName, row2, column2) : void 0,
-    // A getter, not a snapshot: the extent grows as formulas write results,
-    // and a whole-column reference read later in the same pass must see it.
-    get usedBounds() {
-      return model.getUsedBounds?.(sheetName);
-    },
-    isRowHidden: __privateGet(this, _model).isRowHidden ? (row2) => __privateGet(this, _model).isRowHidden(sheetName, row2) : void 0,
-    getCellFormula: __privateGet(this, _model).getCellFormula ? (ref) => __privateGet(this, _model).getCellFormula(sheetName, ref) : void 0,
-    getSpillRange: __privateGet(this, _model).getSpillRange ? (ref) => __privateGet(this, _model).getSpillRange(sheetName, ref) : void 0
-  };
-};
-buildWorkbookLike_fn = function() {
-  if (__privateGet(this, _workbookLike)) return __privateGet(this, _workbookLike);
-  const self = this;
-  return __privateSet(this, _workbookLike, {
-    get worksheets() {
-      return [...__privateGet(self, _sheetNames).values()].map((n) => {
-        var _a;
-        return __privateMethod(_a = self, _RecalcEngine_instances, sheetLike_fn).call(_a, n);
-      });
-    },
-    getWorksheet: (name) => {
-      var _a;
-      return __privateMethod(_a = self, _RecalcEngine_instances, sheetLike_fn).call(_a, name);
-    },
-    getDefinedName: __privateGet(this, _model).getDefinedName ? (name, sheet) => __privateGet(this, _model).getDefinedName(name, sheet) : void 0
-  });
 };
 
 export { ArrayValue, BinaryOpNode, BinaryOperator, BlankNode, BooleanNode, CallNode, CellReferenceNode, ErrorNode, FormulaContext, FormulaError, FormulaException, FormulaHelper, FormulaLexer, FormulaNode, FormulaParser, FormulaValue, FullRangeReferenceNode, FunctionCallNode, FunctionRegistry, ImplicitIntersectionNode, LruCache, NamedRangeNode, NumberNode, RangeCache, RangeReferenceNode, RecalcEngine, SheetCellReferenceNode, SheetRangeReferenceNode, SpillReferenceNode, StringNode, TokenType, UnaryOpNode, UnaryOperator, clearAstCache, createWorkbookRecalcModel, evaluateAst, evaluateFormula, extractReferences, getAstCacheStats, parseFormula, parseFormulaUncached, refContains, registerAggregate, registerArray, registerDate, registerFinance, registerInfo, registerLogical, registerLookup, registerMath, registerMeta, registerStatistical, registerText, setAstCacheCapacity };