@devmm/puredocs-excel-formula 1.0.8 → 1.1.0

package/dist/index.cjs

@@ -31,6 +31,13 @@ var FormulaError = /* @__PURE__ */ ((FormulaError2) => {
   FormulaError2[FormulaError2["Spill"] = 9] = "Spill";
   return FormulaError2;
 })(FormulaError || {});
+var DECIMAL = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+function numericText(text) {
+  const trimmed = text.trim();
+  if (!DECIMAL.test(trimmed)) return null;
+  const n = Number(trimmed);
+  return Number.isFinite(n) ? n : null;
+}
 var TailCall = class {
   constructor(lambda, args) {
     this.lambda = lambda;
@@ -807,6 +814,16 @@ var ArrayLiteralNode = class extends FormulaNode {
   }
 };
 _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;
+  }
+  evaluate() {
+    return this.value;
+  }
+};
 var BlankNode = class extends FormulaNode {
   evaluate() {
     return FormulaValue.blank;
@@ -1433,6 +1450,7 @@ var indexes = /* @__PURE__ */ new WeakMap();
 function build(arr) {
   const byText = /* @__PURE__ */ new Map();
   const byNumber = /* @__PURE__ */ new Map();
+  const byTextNumber = /* @__PURE__ */ new Map();
   const classes = /* @__PURE__ */ new Map();
   const addToClass = (kind, v, i2) => {
     const group = classes.get(kind);
@@ -1452,6 +1470,14 @@ function build(arr) {
       else byNumber.set(n, [i]);
     } else {
       addToClass(v.kind, v, i);
+      if (v.isText) {
+        const n = numericText(v.textValue);
+        if (n !== null) {
+          const atText2 = byTextNumber.get(n);
+          if (atText2) atText2.push(i);
+          else byTextNumber.set(n, [i]);
+        }
+      }
     }
     i++;
   }
@@ -1460,7 +1486,15 @@ function build(arr) {
   for (let k = 0; k < sortedNumbers.length; k++) {
     cumulative[k + 1] = cumulative[k] + byNumber.get(sortedNumbers[k]).length;
   }
-  return { byText, byNumber, sortedNumbers, cumulative, classes: [...classes.values()] };
+  return {
+    byText,
+    byNumber,
+    sortedNumbers,
+    cumulative,
+    byTextNumber,
+    sortedTextNumbers: Float64Array.from(byTextNumber.keys()).sort(),
+    classes: [...classes.values()]
+  };
 }
 function indexOf(arr) {
   let idx = indexes.get(arr);
@@ -1498,19 +1532,25 @@ function matchingPositions(criteriaRange, criteria, minSize) {
   if (criteria.kind === "equalsNumber") {
     const target = criteria.number;
     const idx = indexOf(arr);
-    const exact2 = idx.byNumber.get(target);
-    let near;
-    const { sortedNumbers } = idx;
-    for (let k = lowerBound(sortedNumbers, target - EPSILON); k < sortedNumbers.length; k++) {
-      const value2 = sortedNumbers[k];
-      if (value2 > target + EPSILON) break;
-      if (value2 === target) continue;
-      if (!criteria.test(FormulaValue.number(value2))) continue;
-      (near ?? (near = [])).push(...idx.byNumber.get(value2));
-    }
+    const groups = [];
+    const collect = (byValue, sorted) => {
+      const exact2 = byValue.get(target);
+      if (exact2) groups.push(exact2);
+      for (let k = lowerBound(sorted, target - EPSILON); k < sorted.length; k++) {
+        const value2 = sorted[k];
+        if (value2 > target + EPSILON) break;
+        if (value2 === target) continue;
+        if (!criteria.test(FormulaValue.number(value2))) continue;
+        groups.push(byValue.get(value2));
+      }
+    };
+    collect(idx.byNumber, idx.sortedNumbers);
+    collect(idx.byTextNumber, idx.sortedTextNumbers);
     const blanks = criteria.test(FormulaValue.blank) ? blankPositions(idx) : void 0;
-    if (!near && !blanks?.length) return exact2 ?? EMPTY;
-    const merged = [...exact2 ?? EMPTY, ...near ?? EMPTY, ...blanks ?? EMPTY];
+    if (blanks?.length) groups.push(blanks);
+    if (groups.length === 0) return EMPTY;
+    if (groups.length === 1) return groups[0];
+    const merged = groups.flat();
     merged.sort((a, b) => a - b);
     return merged;
   }
@@ -1576,42 +1616,42 @@ function registerMath(r) {
   r.register("PRODUCT", product, 1);
   r.register("SUMPRODUCT", sumProduct, 1);
   r.register("SUMSQ", sumSq, 1);
-  r.register("ABS", abs, 1, 1);
-  r.register("ROUND", round, 2, 2);
-  r.register("ROUNDUP", roundUp, 2, 2);
-  r.register("ROUNDDOWN", roundDown, 2, 2);
-  r.register("CEILING", ceiling, 2, 2);
-  r.register("CEILING.MATH", ceiling, 2, 2);
-  r.register("FLOOR", floor, 2, 2);
-  r.register("FLOOR.MATH", floor, 2, 2);
-  r.register("INT", int_, 1, 1);
-  r.register("TRUNC", trunc, 1, 2);
-  r.register("MOD", mod, 2, 2);
-  r.register("QUOTIENT", quotient, 2, 2);
-  r.register("POWER", power, 2, 2);
-  r.register("SQRT", sqrt, 1, 1);
-  r.register("SIGN", sign, 1, 1);
+  r.registerElementwise("ABS", abs, 1, 1);
+  r.registerElementwise("ROUND", round, 2, 2);
+  r.registerElementwise("ROUNDUP", roundUp, 2, 2);
+  r.registerElementwise("ROUNDDOWN", roundDown, 2, 2);
+  r.registerElementwise("CEILING", ceiling, 2, 2);
+  r.registerElementwise("CEILING.MATH", ceiling, 2, 2);
+  r.registerElementwise("FLOOR", floor, 2, 2);
+  r.registerElementwise("FLOOR.MATH", floor, 2, 2);
+  r.registerElementwise("INT", int_, 1, 1);
+  r.registerElementwise("TRUNC", trunc, 1, 2);
+  r.registerElementwise("MOD", mod, 2, 2);
+  r.registerElementwise("QUOTIENT", quotient, 2, 2);
+  r.registerElementwise("POWER", power, 2, 2);
+  r.registerElementwise("SQRT", sqrt, 1, 1);
+  r.registerElementwise("SIGN", sign, 1, 1);
   r.register("PI", pi, 0, 0);
   r.register("RAND", rand, 0, 0, true);
   r.register("RANDBETWEEN", randBetween, 2, 2, true);
-  r.register("LOG", log, 1, 2);
-  r.register("LOG10", log10, 1, 1);
-  r.register("LN", ln, 1, 1);
-  r.register("EXP", exp, 1, 1);
-  r.register("FACT", fact, 1, 1);
-  r.register("COMBIN", combin, 2, 2);
-  r.register("SIN", unary(Math.sin), 1, 1);
-  r.register("COS", unary(Math.cos), 1, 1);
-  r.register("TAN", unary(Math.tan), 1, 1);
-  r.register("ASIN", asin, 1, 1);
-  r.register("ACOS", acos, 1, 1);
-  r.register("ATAN", unary(Math.atan), 1, 1);
-  r.register("ATAN2", atan2, 2, 2);
-  r.register("SINH", unary(Math.sinh), 1, 1);
-  r.register("COSH", unary(Math.cosh), 1, 1);
-  r.register("TANH", unary(Math.tanh), 1, 1);
-  r.register("DEGREES", unary((r2d) => r2d * 180 / Math.PI), 1, 1);
-  r.register("RADIANS", unary((d) => d * Math.PI / 180), 1, 1);
+  r.registerElementwise("LOG", log, 1, 2);
+  r.registerElementwise("LOG10", log10, 1, 1);
+  r.registerElementwise("LN", ln, 1, 1);
+  r.registerElementwise("EXP", exp, 1, 1);
+  r.registerElementwise("FACT", fact, 1, 1);
+  r.registerElementwise("COMBIN", combin, 2, 2);
+  r.registerElementwise("SIN", unary(Math.sin), 1, 1);
+  r.registerElementwise("COS", unary(Math.cos), 1, 1);
+  r.registerElementwise("TAN", unary(Math.tan), 1, 1);
+  r.registerElementwise("ASIN", asin, 1, 1);
+  r.registerElementwise("ACOS", acos, 1, 1);
+  r.registerElementwise("ATAN", unary(Math.atan), 1, 1);
+  r.registerElementwise("ATAN2", atan2, 2, 2);
+  r.registerElementwise("SINH", unary(Math.sinh), 1, 1);
+  r.registerElementwise("COSH", unary(Math.cosh), 1, 1);
+  r.registerElementwise("TANH", unary(Math.tanh), 1, 1);
+  r.registerElementwise("DEGREES", unary((r2d) => r2d * 180 / Math.PI), 1, 1);
+  r.registerElementwise("RADIANS", unary((d) => d * Math.PI / 180), 1, 1);
 }
 function valueAt(v, i) {
   return v.isArray ? v.arrayVal.getFlat(i) : v;
@@ -2043,31 +2083,31 @@ function combin(a, c) {
   return FormulaValue.number(Math.round(result));
 }
 function registerText(r) {
-  r.register("LEFT", left, 1, 2);
-  r.register("RIGHT", right, 1, 2);
-  r.register("MID", mid, 3, 3);
-  r.register("LEN", len, 1, 1);
-  r.register("UPPER", upper, 1, 1);
-  r.register("LOWER", lower, 1, 1);
-  r.register("PROPER", proper, 1, 1);
-  r.register("TRIM", trim, 1, 1);
-  r.register("CLEAN", clean, 1, 1);
-  r.register("SUBSTITUTE", substitute, 3, 4);
-  r.register("REPLACE", replace, 4, 4);
+  r.registerElementwise("LEFT", left, 1, 2);
+  r.registerElementwise("RIGHT", right, 1, 2);
+  r.registerElementwise("MID", mid, 3, 3);
+  r.registerElementwise("LEN", len, 1, 1);
+  r.registerElementwise("UPPER", upper, 1, 1);
+  r.registerElementwise("LOWER", lower, 1, 1);
+  r.registerElementwise("PROPER", proper, 1, 1);
+  r.registerElementwise("TRIM", trim, 1, 1);
+  r.registerElementwise("CLEAN", clean, 1, 1);
+  r.registerElementwise("SUBSTITUTE", substitute, 3, 4);
+  r.registerElementwise("REPLACE", replace, 4, 4);
   r.register("CONCATENATE", concatenate, 1);
   r.register("CONCAT", concatenate, 1);
   r.register("TEXTJOIN", textJoin, 3);
-  r.register("TEXT", text_, 2, 2);
-  r.register("VALUE", value, 1, 1);
-  r.register("FIND", find, 2, 3);
-  r.register("SEARCH", search, 2, 3);
-  r.register("REPT", rept, 2, 2);
-  r.register("EXACT", exact, 2, 2);
-  r.register("CHAR", char_, 1, 1);
-  r.register("CODE", code, 1, 1);
-  r.register("T", t_, 1, 1);
-  r.register("TEXTBEFORE", textBefore, 2, 3);
-  r.register("TEXTAFTER", textAfter, 2, 3);
+  r.registerElementwise("TEXT", text_, 2, 2);
+  r.registerElementwise("VALUE", value, 1, 1);
+  r.registerElementwise("FIND", find, 2, 3);
+  r.registerElementwise("SEARCH", search, 2, 3);
+  r.registerElementwise("REPT", rept, 2, 2);
+  r.registerElementwise("EXACT", exact, 2, 2);
+  r.registerElementwise("CHAR", char_, 1, 1);
+  r.registerElementwise("CODE", code, 1, 1);
+  r.registerElementwise("T", t_, 1, 1);
+  r.registerElementwise("TEXTBEFORE", textBefore, 2, 3);
+  r.registerElementwise("TEXTAFTER", textAfter, 2, 3);
 }
 function str(a, c, idx) {
   const r = exports.FormulaHelper.evalString(a[idx], c);
@@ -2381,6 +2421,7 @@ function registerLogical(r) {
 function if_(a, c) {
   const cond = a[0].evaluate(c);
   if (cond.isError) return cond;
+  if (cond.isArray) return ifArray(cond.arrayVal, a, c);
   const b = cond.coerceToBool();
   if (b.isError) return b;
   return b.booleanValue ? a[1].evaluate(c) : a.length > 2 ? a[2].evaluate(c) : FormulaValue.false_;
@@ -2457,13 +2498,63 @@ function xor(a, c) {
   }
   return FormulaValue.boolean(trueCount % 2 === 1);
 }
-function ifError(a, c) {
+function ifArray(mask, a, c) {
+  let wantTrue = false, wantFalse = false;
+  for (const item of mask.values()) {
+    const b = item.coerceToBool();
+    if (b.isError) return b;
+    if (b.booleanValue) wantTrue = true;
+    else wantFalse = true;
+    if (wantTrue && wantFalse) break;
+  }
+  const yes = wantTrue ? a[1].evaluate(c) : FormulaValue.blank;
+  const no = wantFalse ? a.length > 2 ? a[2].evaluate(c) : FormulaValue.false_ : FormulaValue.blank;
+  const pick = (v, r, col) => {
+    if (!v.isArray) return v;
+    const arr = v.arrayVal;
+    return r < arr.rows && col < arr.columns ? arr.get(r, col) : FormulaValue.errorNA;
+  };
+  const out = new ArrayValue(mask.rows, mask.columns);
+  for (let r = 0; r < mask.rows; r++) {
+    for (let col = 0; col < mask.columns; col++) {
+      const b = mask.get(r, col).coerceToBool();
+      out.set(r, col, b.booleanValue ? pick(yes, r, col) : pick(no, r, col));
+    }
+  }
+  return FormulaValue.array(out);
+}
+function ifCaught(a, c, caught) {
   const v = a[0].evaluate(c);
-  return v.isError ? a[1].evaluate(c) : v;
+  if (!v.isArray) return caught(v) ? a[1].evaluate(c) : v;
+  const arr = v.arrayVal;
+  let any = false;
+  for (const item of arr.values()) {
+    if (caught(item)) {
+      any = true;
+      break;
+    }
+  }
+  if (!any) return v;
+  const fb = a[1].evaluate(c);
+  const fbArr = fb.isArray ? fb.arrayVal : null;
+  const out = new ArrayValue(arr.rows, arr.columns);
+  for (let r = 0; r < arr.rows; r++) {
+    for (let col = 0; col < arr.columns; col++) {
+      const item = arr.get(r, col);
+      if (!caught(item)) {
+        out.set(r, col, item);
+        continue;
+      }
+      out.set(r, col, fbArr ? r < fbArr.rows && col < fbArr.columns ? fbArr.get(r, col) : FormulaValue.errorNA : fb);
+    }
+  }
+  return FormulaValue.array(out);
+}
+function ifError(a, c) {
+  return ifCaught(a, c, (v) => v.isError);
 }
 function ifNa(a, c) {
-  const v = a[0].evaluate(c);
-  return v.isError && v.errorCode === 7 /* NA */ ? a[1].evaluate(c) : v;
+  return ifCaught(a, c, (v) => v.isError && v.errorCode === 7 /* NA */);
 }
 function ifs(a, c) {
   for (let i = 0; i + 1 < a.length; i += 2) {
@@ -2520,21 +2611,21 @@ function fromOA(oa) {
 function registerDate(r) {
   r.register("NOW", now, 0, 0, true);
   r.register("TODAY", today, 0, 0, true);
-  r.register("DATE", date_, 3, 3);
-  r.register("YEAR", year, 1, 1);
-  r.register("MONTH", month, 1, 1);
-  r.register("DAY", day, 1, 1);
-  r.register("HOUR", hour, 1, 1);
-  r.register("MINUTE", minute, 1, 1);
-  r.register("SECOND", second, 1, 1);
-  r.register("DATEVALUE", dateValue, 1, 1);
-  r.register("DAYS", days, 2, 2);
-  r.register("EDATE", edate, 2, 2);
-  r.register("EOMONTH", eomonth, 2, 2);
-  r.register("WEEKDAY", weekday, 1, 2);
-  r.register("WEEKNUM", weeknum, 1, 2);
+  r.registerElementwise("DATE", date_, 3, 3);
+  r.registerElementwise("YEAR", year, 1, 1);
+  r.registerElementwise("MONTH", month, 1, 1);
+  r.registerElementwise("DAY", day, 1, 1);
+  r.registerElementwise("HOUR", hour, 1, 1);
+  r.registerElementwise("MINUTE", minute, 1, 1);
+  r.registerElementwise("SECOND", second, 1, 1);
+  r.registerElementwise("DATEVALUE", dateValue, 1, 1);
+  r.registerElementwise("DAYS", days, 2, 2);
+  r.registerElementwise("EDATE", edate, 2, 2);
+  r.registerElementwise("EOMONTH", eomonth, 2, 2);
+  r.registerElementwise("WEEKDAY", weekday, 1, 2);
+  r.registerElementwise("WEEKNUM", weeknum, 1, 2);
   r.register("NETWORKDAYS", networkdays, 2, 3);
-  r.register("DATEDIF", datedif, 3, 3);
+  r.registerElementwise("DATEDIF", datedif, 3, 3);
 }
 function evalDate(a, c, idx) {
   const r = exports.FormulaHelper.evalDouble(a[idx], c);
@@ -3347,20 +3438,20 @@ function ifsAggregate(a, c, mode2) {
 
 // src/functions/info-functions.ts
 function registerInfo(r) {
-  r.register("ISBLANK", isBlank, 1, 1);
-  r.register("ISNUMBER", isNumber, 1, 1);
-  r.register("ISTEXT", isText, 1, 1);
-  r.register("ISERROR", isError, 1, 1);
-  r.register("ISERR", isErr, 1, 1);
-  r.register("ISLOGICAL", isLogical, 1, 1);
-  r.register("ISNA", isNa, 1, 1);
-  r.register("ISNONTEXT", isNonText, 1, 1);
+  r.registerElementwise("ISBLANK", isBlank, 1, 1);
+  r.registerElementwise("ISNUMBER", isNumber, 1, 1);
+  r.registerElementwise("ISTEXT", isText, 1, 1);
+  r.registerElementwise("ISERROR", isError, 1, 1);
+  r.registerElementwise("ISERR", isErr, 1, 1);
+  r.registerElementwise("ISLOGICAL", isLogical, 1, 1);
+  r.registerElementwise("ISNA", isNa, 1, 1);
+  r.registerElementwise("ISNONTEXT", isNonText, 1, 1);
   r.register("NA", na, 0, 0);
-  r.register("TYPE", type_, 1, 1);
-  r.register("N", n_, 1, 1);
-  r.register("ISODD", isOdd, 1, 1);
-  r.register("ISEVEN", isEven, 1, 1);
-  r.register("ERROR.TYPE", errorType, 1, 1);
+  r.registerElementwise("TYPE", type_, 1, 1);
+  r.registerElementwise("N", n_, 1, 1);
+  r.registerElementwise("ISODD", isOdd, 1, 1);
+  r.registerElementwise("ISEVEN", isEven, 1, 1);
+  r.registerElementwise("ERROR.TYPE", errorType, 1, 1);
 }
 function isBlank(a, c) {
   return FormulaValue.boolean(a[0].evaluate(c).isBlank);
@@ -4448,7 +4539,8 @@ function toRow(a, c) {
 }
 
 // src/function-registry.ts
-var _default, _functions, _FunctionRegistry_instances, registerBuiltIns_fn;
+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);
@@ -4470,17 +4562,45 @@ var _FunctionRegistry = class _FunctionRegistry {
       minArgs,
       maxArgs,
       isVolatile,
-      handler
+      handler,
+      elementwise: false
+    });
+  }
+  /**
+   * Registers a **scalar** function — one whose arguments are single values —
+   * and lifts it over arrays automatically.
+   *
+   * `LEFT(A2:A100, 3)` is not a special form in Excel: LEFT takes one string, and
+   * the grid maps it over the range, giving a 99-row array. Without that lifting
+   * the range collapses to one value, so the dynamic array built on top of it —
+   * `FILTER(IFERROR(LEFT(A2:A100,3),""), …)` — filters a 1×1 input and returns
+   * `#CALC!`. Lifting belongs here rather than in each handler: the ~40 scalar
+   * text/math/date functions then get it for free and cannot each get it subtly
+   * wrong.
+   *
+   * Only mark functions that are genuinely per-cell. Anything that *consumes* an
+   * array (SUM, COUNTIF, FILTER, SORT, the lazy branch functions) must keep
+   * `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(), {
+      name: name.toUpperCase(),
+      minArgs,
+      maxArgs,
+      isVolatile: false,
+      handler,
+      elementwise: true
     });
   }
   /** Executes a function by name with argument validation. */
   execute(name, args, ctx) {
+    var _a;
     const def = __privateGet(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.handler(args, ctx);
+      return def.elementwise ? __privateMethod(_a = _FunctionRegistry, _FunctionRegistry_static, executeElementwise_fn).call(_a, def, args, ctx) : def.handler(args, ctx);
     } catch {
       return FormulaValue.errorValue;
     }
@@ -4496,6 +4616,42 @@ var _FunctionRegistry = class _FunctionRegistry {
 };
 _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 FormulaValue.array(out);
+};
 _FunctionRegistry_instances = new WeakSet();
 registerBuiltIns_fn = function() {
   registerMath(this);
@@ -4510,6 +4666,7 @@ registerBuiltIns_fn = function() {
   registerAggregate(this);
   registerArray(this);
 };
+__privateAdd(_FunctionRegistry, _FunctionRegistry_static);
 __privateAdd(_FunctionRegistry, _default);
 var FunctionRegistry = _FunctionRegistry;
 exports.FormulaHelper = void 0;
@@ -4575,7 +4732,8 @@ exports.FormulaHelper = void 0;
         return rhsNum !== null ? numberEquality(rhsNum) : textEquality(rhs);
       }
       if (op === "<>") {
-        return { kind: "other", test: (v) => !FormulaValue.areEqual(v, rhsValue) };
+        const equals = rhsNum !== null ? numberEquality(rhsNum) : textEquality(rhs);
+        return { kind: "other", test: (v) => !equals.test(v) };
       }
       const wanted = op === ">" ? (c) => c > 0 : op === ">=" ? (c) => c >= 0 : op === "<" ? (c) => c < 0 : (c) => c <= 0;
       const test = (v) => wanted(FormulaValue.compare(v, rhsValue));
@@ -4591,7 +4749,16 @@ exports.FormulaHelper = void 0;
   FormulaHelper2.compileCriteria = compileCriteria;
   function numberEquality(n) {
     const target = FormulaValue.number(n);
-    return { kind: "equalsNumber", number: n, test: (v) => FormulaValue.areEqual(v, target) };
+    return {
+      kind: "equalsNumber",
+      number: n,
+      test: (v) => {
+        if (FormulaValue.areEqual(v, target)) return true;
+        if (!v.isText) return false;
+        const asNumber = numericText(v.textValue);
+        return asNumber !== null && Math.abs(asNumber - n) < 1e-10;
+      }
+    };
   }
   function textEquality(s) {
     const upper2 = s.toUpperCase();
@@ -5371,6 +5538,7 @@ function createWorkbookRecalcModel(workbook) {
     getDefinedName: (name, sheet) => workbook.getDefinedName(name, sheet)
   };
 }
+var MAX_ADOPTED_SPILL_CELLS = 262144;
 var normSheet = (s) => s.toUpperCase();
 var normRef = (r) => r.replace(/\$/g, "").toUpperCase();
 var keyOf = (sheet, ref) => `${normSheet(sheet)}!${normRef(ref)}`;
@@ -5381,7 +5549,7 @@ function parseKey(key) {
   const { row: row2, column: column2 } = puredocsExcel.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, 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 _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 {
   constructor(model, registry = FunctionRegistry.default) {
     __privateAdd(this, _RecalcEngine_instances);
@@ -5489,11 +5657,12 @@ var RecalcEngine = class {
         const ast = parseFormulaUncached(text);
         const { refs, volatile } = extractReferences(ast, s, __privateGet(this, _registry), resolveName2);
         __privateMethod(this, _RecalcEngine_instances, rememberSheet_fn).call(this, sheet);
+        const key = keyOf(s, r);
         __privateMethod(this, _RecalcEngine_instances, register_fn).call(this, {
           sheet: s,
           sheetName: sheet,
           ref: r,
-          key: keyOf(s, r),
+          key,
           row: row2,
           col: column2,
           formula: text,
@@ -5501,6 +5670,7 @@ var RecalcEngine = class {
           refs,
           volatile
         });
+        __privateMethod(this, _RecalcEngine_instances, adoptDeclaredSpill_fn).call(this, s, sheet, r, key, row2, column2);
         registered++;
       } catch (err) {
         failed.push({ sheet, ref, error: err instanceof Error ? err.message : String(err) });
@@ -5668,6 +5838,51 @@ unregister_fn = function(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 = puredocsExcel.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, puredocsExcel.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.
  *