@devmm/puredocs-excel-formula 1.0.8 → 1.0.9

package/dist/index.d.cts

@@ -202,6 +202,8 @@ interface FunctionDef {
     readonly maxArgs: number;
     readonly isVolatile: boolean;
     readonly handler: FormulaFunction;
+    /** Scalar function: an array argument maps it over the array. See {@link FunctionRegistry.registerElementwise}. */
+    readonly elementwise: boolean;
 }
 declare class FunctionRegistry {
     #private;
@@ -209,6 +211,23 @@ declare class FunctionRegistry {
     static get default(): FunctionRegistry;
     /** Registers a function. Name is normalised to UPPERCASE. */
     register(name: string, handler: FormulaFunction, minArgs?: number, maxArgs?: number, isVolatile?: boolean): void;
+    /**
+     * 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: string, handler: FormulaFunction, minArgs?: number, maxArgs?: number): void;
     /** Executes a function by name with argument validation. */
     execute(name: string, args: FormulaNode[], ctx: FormulaContext): FormulaValue;
     /** Returns true if the named function is volatile (NOW, RAND, etc.). */

package/dist/index.d.ts

@@ -202,6 +202,8 @@ interface FunctionDef {
     readonly maxArgs: number;
     readonly isVolatile: boolean;
     readonly handler: FormulaFunction;
+    /** Scalar function: an array argument maps it over the array. See {@link FunctionRegistry.registerElementwise}. */
+    readonly elementwise: boolean;
 }
 declare class FunctionRegistry {
     #private;
@@ -209,6 +211,23 @@ declare class FunctionRegistry {
     static get default(): FunctionRegistry;
     /** Registers a function. Name is normalised to UPPERCASE. */
     register(name: string, handler: FormulaFunction, minArgs?: number, maxArgs?: number, isVolatile?: boolean): void;
+    /**
+     * 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: string, handler: FormulaFunction, minArgs?: number, maxArgs?: number): void;
     /** Executes a function by name with argument validation. */
     execute(name: string, args: FormulaNode[], ctx: FormulaContext): FormulaValue;
     /** Returns true if the named function is volatile (NOW, RAND, etc.). */

package/dist/index.js

@@ -1,4 +1,4 @@
-import { toOADate, fromOADate, columnLetter, parseCellRef, cellRefFromRowCol, shiftIndex, shiftFormulaRefs, shiftSpan, EXCEL_MAX_ROWS, EXCEL_MAX_COLUMNS, columnNumber } from '@devmm/puredocs-excel';
+import { toOADate, fromOADate, columnLetter, parseCellRef, cellRefFromRowCol, parseRangeRef, shiftIndex, shiftFormulaRefs, shiftSpan, EXCEL_MAX_ROWS, EXCEL_MAX_COLUMNS, columnNumber } from '@devmm/puredocs-excel';
 
 var __typeError = (msg) => {
   throw TypeError(msg);
@@ -805,6 +805,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;
@@ -1574,42 +1584,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;
@@ -2041,31 +2051,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 = FormulaHelper.evalString(a[idx], c);
@@ -2379,6 +2389,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_;
@@ -2455,13 +2466,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) {
@@ -2518,21 +2579,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 = FormulaHelper.evalDouble(a[idx], c);
@@ -3345,20 +3406,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);
@@ -4446,7 +4507,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);
@@ -4468,17 +4530,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;
     }
@@ -4494,6 +4584,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);
@@ -4508,6 +4634,7 @@ registerBuiltIns_fn = function() {
   registerAggregate(this);
   registerArray(this);
 };
+__privateAdd(_FunctionRegistry, _FunctionRegistry_static);
 __privateAdd(_FunctionRegistry, _default);
 var FunctionRegistry = _FunctionRegistry;
 var FormulaHelper;
@@ -5369,6 +5496,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)}`;
@@ -5379,7 +5507,7 @@ 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, 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);
@@ -5487,11 +5615,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,
@@ -5499,6 +5628,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) });
@@ -5666,6 +5796,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 = 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.
  *