@devmm/puredocs-excel-formula 1.0.7 → 1.0.9

package/dist/index.cjs

@@ -448,8 +448,11 @@ var TokenType = /* @__PURE__ */ ((TokenType2) => {
   TokenType2[TokenType2["SpillReference"] = 24] = "SpillReference";
   TokenType2[TokenType2["Exclamation"] = 25] = "Exclamation";
   TokenType2[TokenType2["AtSign"] = 26] = "AtSign";
-  TokenType2[TokenType2["ErrorLiteral"] = 27] = "ErrorLiteral";
-  TokenType2[TokenType2["EOF"] = 28] = "EOF";
+  TokenType2[TokenType2["LeftBrace"] = 27] = "LeftBrace";
+  TokenType2[TokenType2["RightBrace"] = 28] = "RightBrace";
+  TokenType2[TokenType2["Semicolon"] = 29] = "Semicolon";
+  TokenType2[TokenType2["ErrorLiteral"] = 30] = "ErrorLiteral";
+  TokenType2[TokenType2["EOF"] = 31] = "EOF";
   return TokenType2;
 })(TokenType || {});
 function makeToken(type, value2, position) {
@@ -463,6 +466,8 @@ var FormulaException = class extends Error {
     this.name = "FormulaException";
   }
 };
+var UNDERSCORE = 95;
+var RESERVED_PREFIXES = ["_XLFN.", "_XLWS.", "_XLPM."];
 var KNOWN_ERRORS = /* @__PURE__ */ new Set([
   "#NULL!",
   "#DIV/0!",
@@ -474,7 +479,7 @@ 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, readCellRefChars_fn, readOperator_fn, skipWhitespace_fn;
+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 {
   constructor(formula) {
     __privateAdd(this, _FormulaLexer_instances);
@@ -492,7 +497,7 @@ var FormulaLexer = class {
       const token = __privateMethod(this, _FormulaLexer_instances, readNextToken_fn).call(this);
       if (token) tokens.push(token);
     }
-    tokens.push(makeToken(28 /* EOF */, "", __privateGet(this, _pos)));
+    tokens.push(makeToken(31 /* EOF */, "", __privateGet(this, _pos)));
     return tokens;
   }
 };
@@ -546,7 +551,7 @@ readErrorLiteral_fn = function() {
   if (!KNOWN_ERRORS.has(upper2)) {
     throw new FormulaException(`Unknown error literal "${raw}" at position ${start}.`);
   }
-  return makeToken(27 /* ErrorLiteral */, upper2, start);
+  return makeToken(30 /* ErrorLiteral */, upper2, start);
 };
 readQuotedSheetRef_fn = function() {
   const start = __privateWrapper(this, _pos)._++;
@@ -609,10 +614,8 @@ readIdentifier_fn = function() {
     } else break;
   }
   let upper2 = raw.toUpperCase();
-  if (upper2.startsWith("_XLFN.")) {
-    raw = raw.slice(6);
-    upper2 = upper2.slice(6);
-  }
+  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)] === "!") {
@@ -634,6 +637,30 @@ readIdentifier_fn = function() {
   }
   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;
+      }
+    }
+    break;
+  }
+  return cut > 0 && cut < raw.length ? raw.slice(cut) : raw;
+};
 readCellRefChars_fn = function() {
   let ref = "";
   while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
@@ -677,6 +704,14 @@ readOperator_fn = function() {
       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)._++;
@@ -759,6 +794,29 @@ var ErrorNode = class extends FormulaNode {
     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));
+  }
+  evaluate() {
+    return __privateGet(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;
+  }
+  evaluate() {
+    return this.value;
+  }
+};
 var BlankNode = class extends FormulaNode {
   evaluate() {
     return FormulaValue.blank;
@@ -1036,7 +1094,7 @@ 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, parseFunction_fn, parseArgList_fn;
+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 {
   constructor(tokens) {
     __privateAdd(this, _FormulaParser_instances);
@@ -1047,7 +1105,7 @@ var FormulaParser = class {
   parse() {
     __privateSet(this, _pos2, 0);
     const node = __privateMethod(this, _FormulaParser_instances, parseComparison_fn).call(this);
-    if (__privateGet(this, _FormulaParser_instances, current_get).type !== 28 /* EOF */) {
+    if (__privateGet(this, _FormulaParser_instances, current_get).type !== 31 /* EOF */) {
       throw new FormulaException(
         `Unexpected token '${__privateGet(this, _FormulaParser_instances, current_get).value}' at position ${__privateGet(this, _FormulaParser_instances, current_get).position}.`
       );
@@ -1059,7 +1117,7 @@ _tokens = new WeakMap();
 _pos2 = new WeakMap();
 _FormulaParser_instances = new WeakSet();
 current_get = function() {
-  return __privateGet(this, _tokens)[__privateGet(this, _pos2)] ?? { type: 28 /* EOF */, value: "", position: -1 };
+  return __privateGet(this, _tokens)[__privateGet(this, _pos2)] ?? { type: 31 /* EOF */, value: "", position: -1 };
 };
 advance_fn = function() {
   const t = __privateGet(this, _FormulaParser_instances, current_get);
@@ -1174,7 +1232,7 @@ parsePrimary_fn = function() {
     case 2 /* Boolean */:
       __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
       return new BooleanNode(token.value === "TRUE");
-    case 27 /* ErrorLiteral */:
+    case 30 /* ErrorLiteral */:
       __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
       return new ErrorNode(FormulaValue.error(FormulaValue.errorFromString(token.value)));
     case 3 /* CellReference */: {
@@ -1213,6 +1271,8 @@ parsePrimary_fn = function() {
       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);
@@ -1247,6 +1307,79 @@ tryParseFullRange_fn = function(startText, sheetName) {
   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)) {
+    throw new FormulaException(
+      `Array constant at position ${open.position} has rows of differing lengths.`
+    );
+  }
+  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_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 */);
@@ -1453,42 +1586,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;
@@ -1920,31 +2053,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);
@@ -2258,6 +2391,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_;
@@ -2334,13 +2468,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) {
@@ -2397,21 +2581,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);
@@ -3224,20 +3408,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);
@@ -4063,22 +4247,46 @@ function unique(a, c) {
   const out = fromRows(result);
   return byCol2 ? FormulaValue.array(out.arrayVal.transpose()) : out;
 }
+var numVector = (a, c, i, dflt) => {
+  if (i >= a.length) return { ok: true, v: [dflt] };
+  const val = a[i].evaluate(c);
+  if (val.isError) return { ok: false, e: val };
+  const out = [];
+  for (const item of val.isArray ? val.arrayVal.values() : [val]) {
+    if (item.isBlank) continue;
+    const d = item.tryAsDouble();
+    if (!d.ok) return { ok: false, e: FormulaValue.errorValue };
+    out.push(d.value);
+  }
+  return out.length > 0 ? { ok: true, v: out } : { ok: true, v: [dflt] };
+};
 function sort(a, c) {
   const v = a[0].evaluate(c);
   if (v.isError) return v;
-  const sortIndex = num4(a, c, 1, 1);
-  if (!sortIndex.ok) return sortIndex.e;
-  const sortOrder = num4(a, c, 2, 1);
-  if (!sortOrder.ok) return sortOrder.e;
+  const indices = numVector(a, c, 1, 1);
+  if (!indices.ok) return indices.e;
+  const orders = numVector(a, c, 2, 1);
+  if (!orders.ok) return orders.e;
   const byCol2 = a.length > 3 ? a[3].evaluate(c).coerceToBool().booleanValue : false;
+  if (orders.v.length !== 1 && orders.v.length !== indices.v.length) {
+    return FormulaValue.errorValue;
+  }
   const base = byCol2 ? asArray2(v).transpose() : asArray2(v);
   const rows2 = toRows(base);
-  const idx = Math.trunc(sortIndex.n) - 1;
-  const dir = sortOrder.n < 0 ? -1 : 1;
-  if (rows2.length > 0 && (idx < 0 || idx >= rows2[0].length)) return FormulaValue.errorValue;
+  const keys = indices.v.map((n, i) => ({
+    col: Math.trunc(n) - 1,
+    dir: (orders.v.length === 1 ? orders.v[0] : orders.v[i]) < 0 ? -1 : 1
+  }));
+  const width = rows2.length > 0 ? rows2[0].length : 0;
+  if (rows2.length > 0 && keys.some((k) => k.col < 0 || k.col >= width)) {
+    return FormulaValue.errorValue;
+  }
   const sorted = rows2.map((r, i) => ({ r, i })).sort((x, y) => {
-    const cmp = FormulaValue.compare(x.r[idx], y.r[idx]) * dir;
-    return cmp !== 0 ? cmp : x.i - y.i;
+    for (const k of keys) {
+      const cmp = FormulaValue.compare(x.r[k.col], y.r[k.col]) * k.dir;
+      if (cmp !== 0) return cmp;
+    }
+    return x.i - y.i;
   }).map((o) => o.r);
   const out = fromRows(sorted);
   return byCol2 ? FormulaValue.array(out.arrayVal.transpose()) : out;
@@ -4301,7 +4509,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);
@@ -4323,17 +4532,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;
     }
@@ -4349,6 +4586,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);
@@ -4363,6 +4636,7 @@ registerBuiltIns_fn = function() {
   registerAggregate(this);
   registerArray(this);
 };
+__privateAdd(_FunctionRegistry, _FunctionRegistry_static);
 __privateAdd(_FunctionRegistry, _default);
 var FunctionRegistry = _FunctionRegistry;
 exports.FormulaHelper = void 0;
@@ -5224,6 +5498,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)}`;
@@ -5234,7 +5509,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);
@@ -5342,11 +5617,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,
@@ -5354,6 +5630,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) });
@@ -5521,6 +5798,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.
  *