@pixerate/editor 0.24.0 → 0.26.0

package/dist/{chunk-3CN2WD3X.js → chunk-ZRNHGAQT.js}

@@ -1,4 +1,30 @@
 // src/spreadsheet/formula/lexer.ts
+var MAX_QUOTED_SHEET_LENGTH = 2 * 31 + 2;
+var isWordStart = (char) => /[A-Za-z_$\\]/.test(char) || char > "\x7F" && /\p{L}/u.test(char);
+var isWordChar = (char) => /[A-Za-z0-9_$.\\?]/.test(char) || char > "\x7F" && /[\p{L}\p{N}]/u.test(char);
+var CELL_WORD = /^\$?[A-Za-z]+\$?[0-9]+$/;
+function readQuotedSheet(input, start) {
+  let name = "";
+  let j = start + 1;
+  while (j < input.length && j - start <= MAX_QUOTED_SHEET_LENGTH) {
+    if (input[j] === "'") {
+      if (input[j + 1] === "'") {
+        name += "'";
+        j += 2;
+        continue;
+      }
+      if (input[j + 1] !== "!" || input[j + 2] === "=" || name === "") return null;
+      const colon = name.indexOf(":");
+      if (colon > 0 && colon < name.length - 1) {
+        return { sheet: name.slice(0, colon), sheetEnd: name.slice(colon + 1), next: j + 2 };
+      }
+      return { sheet: name, next: j + 2 };
+    }
+    name += input[j];
+    j++;
+  }
+  return null;
+}
 function tokenizeFormula(formula) {
   const tokens = [];
   let input = formula.trim();
@@ -29,6 +55,13 @@ function tokenizeFormula(formula) {
       });
       continue;
     }
+    if (char === "'") {
+      const prefix = readQuotedSheet(input, i);
+      if (prefix) {
+        i = readQualifiedReference(input, prefix.next, i, prefix.sheet, prefix.sheetEnd, offset, tokens);
+        continue;
+      }
+    }
     if (char === '"' || char === "'") {
       const quote2 = char;
       const start = i;
@@ -48,7 +81,8 @@ function tokenizeFormula(formula) {
       tokens.push({
         type: "STRING",
         value: str,
-        position: start + offset
+        position: start + offset,
+        end: i + offset
       });
       continue;
     }
@@ -75,7 +109,8 @@ function tokenizeFormula(formula) {
       tokens.push({
         type: "PROPERTY_REF",
         value: prop.trim(),
-        position: start + offset
+        position: start + offset,
+        end: i + offset
       });
       continue;
     }
@@ -109,65 +144,96 @@ function tokenizeFormula(formula) {
       i++;
       continue;
     }
-    if (/[a-zA-Z_$]/.test(char)) {
+    if (isWordStart(char)) {
       const start = i;
-      while (i < input.length && /[a-zA-Z0-9_$.]/.test(input[i])) {
+      while (i < input.length && isWordChar(input[i])) {
         i++;
       }
       const rawWord = input.slice(start, i);
+      if (input[i] === "!" && input[i + 1] !== "=") {
+        i = readQualifiedReference(input, i + 1, start, rawWord, void 0, offset, tokens);
+        continue;
+      }
       if (i < input.length && input[i] === ":") {
         const colonPos = i;
         i++;
         const secondStart = i;
-        while (i < input.length && /[a-zA-Z0-9_$.]/.test(input[i])) {
+        while (i < input.length && isWordChar(input[i])) {
           i++;
         }
         const secondWord = input.slice(secondStart, i);
+        if (secondWord.length > 0 && input[i] === "!" && input[i + 1] !== "=") {
+          i = readQualifiedReference(input, i + 1, start, rawWord, secondWord, offset, tokens);
+          continue;
+        }
         if (secondWord.length > 0) {
           tokens.push({
             type: "RANGE",
             value: `${rawWord}:${secondWord}`.toUpperCase(),
-            position: start + offset
+            position: start + offset,
+            end: i + offset
           });
           continue;
         } else {
           i = colonPos;
         }
       }
-      const upper = rawWord.toUpperCase();
-      if (upper === "TRUE" || upper === "FALSE") {
-        tokens.push({
-          type: "BOOLEAN",
-          value: upper,
-          position: start + offset
-        });
-        continue;
-      }
-      if (/^\$?[A-Za-z]+\$?[0-9]+$/.test(rawWord)) {
-        if (input[i] === "#") {
-          i++;
-          tokens.push({ type: "SPILL_REF", value: upper.replace(/\$/g, ""), position: start + offset });
-          continue;
-        }
-        tokens.push({
-          type: "CELL_REF",
-          value: upper.replace(/\$/g, ""),
-          position: start + offset
-        });
-        continue;
-      }
-      tokens.push({
-        type: "IDENTIFIER",
-        value: upper,
-        position: start + offset
-      });
+      pushWord(input, rawWord, start, i, offset, tokens);
+      if (tokens[tokens.length - 1].type === "SPILL_REF") i++;
       continue;
     }
     throw new Error(`Unexpected character '${char}' at position ${i + offset}`);
   }
-  tokens.push({ type: "EOF", value: "", position: input.length + offset });
+  tokens.push({ type: "EOF", value: "", position: input.length + offset, end: input.length + offset });
+  for (const token of tokens) {
+    if (token.end === void 0) token.end = token.position + Math.max(token.value.length, 1);
+  }
   return tokens;
 }
+function pushWord(input, rawWord, start, end, offset, tokens, qualified) {
+  const upper = rawWord.toUpperCase();
+  const position = qualified?.position ?? start + offset;
+  const extra = qualified ? { sheet: qualified.sheet, ...qualified.sheetEnd ? { sheetEnd: qualified.sheetEnd } : {}, refStart: qualified.refStart } : {};
+  if (!qualified && (upper === "TRUE" || upper === "FALSE")) {
+    tokens.push({ type: "BOOLEAN", value: upper, position, end: end + offset });
+    return;
+  }
+  if (CELL_WORD.test(rawWord)) {
+    if (input[end] === "#") {
+      tokens.push({ type: "SPILL_REF", value: upper.replace(/\$/g, ""), position, end: end + 1 + offset, ...extra });
+      return;
+    }
+    tokens.push({ type: "CELL_REF", value: upper.replace(/\$/g, ""), position, end: end + offset, ...extra });
+    return;
+  }
+  tokens.push({ type: "IDENTIFIER", value: upper, position, end: end + offset, ...extra });
+}
+function readQualifiedReference(input, from, prefixStart, sheet, sheetEnd, offset, tokens) {
+  let i = from;
+  while (i < input.length && isWordChar(input[i])) i++;
+  const word = input.slice(from, i);
+  if (!word) throw new Error(`Expected a reference after '!' at position ${from + offset}`);
+  const qualified = { sheet, sheetEnd, refStart: from + offset, position: prefixStart + offset };
+  if (input[i] === ":") {
+    let j = i + 1;
+    while (j < input.length && isWordChar(input[j])) j++;
+    const second = input.slice(i + 1, j);
+    if (second) {
+      tokens.push({
+        type: "RANGE",
+        value: `${word}:${second}`.toUpperCase(),
+        position: qualified.position,
+        end: j + offset,
+        sheet,
+        ...sheetEnd ? { sheetEnd } : {},
+        refStart: qualified.refStart
+      });
+      return j;
+    }
+  }
+  pushWord(input, word, from, i, offset, tokens, qualified);
+  return tokens[tokens.length - 1].type === "SPILL_REF" ? i + 1 : i;
+}
 
 // src/spreadsheet/formula/parser.ts
 var WHOLE_COLUMN_END_ROW = 1048576;
@@ -205,6 +271,7 @@ function parseRange(rangeStr) {
     endRow: endRef.row
   };
 }
+var qualifier = (token) => token.sheet === void 0 ? {} : token.sheetEnd === void 0 ? { sheet: token.sheet } : { sheet: token.sheet, sheetEnd: token.sheetEnd };
 var FormulaParser = class {
   tokens = [];
   current = 0;
@@ -275,7 +342,22 @@ var FormulaParser = class {
       const argument = this.unary();
       return { type: "UnaryOp", op, argument };
     }
-    return this.primary();
+    let expr = this.primary();
+    while (this.check("LPAREN") && (expr.type === "FunctionCall" || expr.type === "Invoke" || this.previous().type === "RPAREN")) {
+      this.advance();
+      expr = { type: "Invoke", callee: expr, args: this.argumentList() };
+    }
+    return expr;
+  }
+  /** Arguments after `(` up to and including `)`. Empty positions are `Missing`. */
+  argumentList() {
+    const args = [];
+    if (this.match("RPAREN")) return args;
+    do {
+      args.push(this.check("COMMA") || this.check("RPAREN") ? { type: "Missing" } : this.expression());
+    } while (this.match("COMMA"));
+    this.consume("RPAREN", `Expected ')' after function arguments`);
+    return args;
   }
   primary() {
     const token = this.peek();
@@ -297,22 +379,27 @@ var FormulaParser = class {
     }
     if (token.type === "CELL_REF") {
       this.advance();
+      if (token.sheet === void 0 && this.check("LPAREN")) {
+        this.advance();
+        return { type: "FunctionCall", name: token.value, args: this.argumentList() };
+      }
       const parsed = parseCellReference(token.value);
       return {
         type: "CellRef",
         ref: token.value,
         col: parsed.col,
-        row: parsed.row
+        row: parsed.row,
+        ...qualifier(token)
       };
     }
     if (token.type === "RANGE") {
       this.advance();
-      return parseRange(token.value);
+      return { ...parseRange(token.value), ...qualifier(token) };
     }
     if (token.type === "SPILL_REF") {
       this.advance();
       const parsed = parseCellReference(token.value);
-      return { type: "SpillRef", ref: token.value, col: parsed.col, row: parsed.row };
+      return { type: "SpillRef", ref: token.value, col: parsed.col, row: parsed.row, ...qualifier(token) };
     }
     if (token.type === "PROPERTY_REF") {
       this.advance();
@@ -325,21 +412,20 @@ var FormulaParser = class {
       const name = token.value;
       this.advance();
       if (this.check("LPAREN")) {
-        this.consume("LPAREN", `Expected '(' after function ${name}`);
-        const args = [];
-        if (!this.check("RPAREN")) {
-          do {
-            args.push(this.expression());
-          } while (this.match("COMMA"));
+        if (token.sheet !== void 0) {
+          throw new Error(`Unexpected '(' after ${token.sheet}!${name} at position ${this.peek().position}`);
         }
-        this.consume("RPAREN", `Expected ')' after function arguments`);
+        this.consume("LPAREN", `Expected '(' after function ${name}`);
         return {
           type: "FunctionCall",
           name,
-          args
+          args: this.argumentList()
         };
       }
-      return { type: "Name", name };
+      if (token.sheetEnd !== void 0) {
+        throw new Error(`A 3-D reference can't name ${name} at position ${token.position}`);
+      }
+      return token.sheet !== void 0 ? { type: "Name", name, sheet: token.sheet } : { type: "Name", name };
     }
     if (this.match("LPAREN")) {
       const expr = this.expression();
@@ -392,6 +478,35 @@ function parseFormula(formula) {
   return parser.parse();
 }
 
+// src/spreadsheet/formula/lambda.ts
+var FormulaLambda = class {
+  constructor(params, body, env, sheet, native, label = "LAMBDA") {
+    this.params = params;
+    this.body = body;
+    this.env = env;
+    this.sheet = sheet;
+    this.native = native;
+    this.label = label;
+  }
+  params;
+  body;
+  env;
+  sheet;
+  native;
+  label;
+  toString() {
+    return `[${this.label}]`;
+  }
+};
+var isFormulaLambda = (value) => value instanceof FormulaLambda;
+var MAX_LAMBDA_DEPTH = 1e3;
+function lookupEnvironment(env, name) {
+  for (let e = env; e; e = e.parent) {
+    if (e.vars.has(name)) return e;
+  }
+  return null;
+}
+
 // src/spreadsheet/formula/values.ts
 var FORMULA_ERRORS = /* @__PURE__ */ new Set([
   "#DIV/0!",
@@ -4122,6 +4237,88 @@ var ELEMENTWISE_BUILTINS = {
   IFNA: [0]
 };
 
+// src/spreadsheet/formula/functions/lambda.ts
+var special = (name) => (ctx) => ctx.error("#ERROR!", `${name} must be evaluated by the formula evaluator.`);
+var LAMBDA_ARG = arg("lambda", "A LAMBDA function, e.g. LAMBDA(x, x*2), or a function name such as SUM.");
+var LAMBDA_FUNCTIONS = [
+  {
+    name: "LAMBDA",
+    category: "logical",
+    description: "Creates a reusable function: LAMBDA(x, y, x+y). Call it directly, LAMBDA(x, x+1)(2), store it in LET or a defined name, or pass it to MAP, REDUCE, SCAN, BYROW, BYCOL or MAKEARRAY.",
+    args: [
+      repeating(
+        "parameter_or_calculation",
+        "Parameter names, then the calculation that uses them (always the last argument)."
+      )
+    ],
+    evaluate: special("LAMBDA")
+  },
+  {
+    name: "ISOMITTED",
+    category: "logical",
+    description: "Checks whether a LAMBDA parameter was left out of the call, e.g. LAMBDA(x, y, IF(ISOMITTED(y), x, x+y))(1,).",
+    args: [arg("argument", "A LAMBDA parameter name.")],
+    evaluate: special("ISOMITTED")
+  },
+  {
+    name: "MAP",
+    category: "logical",
+    description: "Applies a LAMBDA to each value of one or more arrays: MAP(A1:A3, LAMBDA(v, v*2)).",
+    args: [
+      arg("array1", "An array to map."),
+      repeating("array_or_lambda", "More arrays, then the LAMBDA taking one parameter per array.")
+    ],
+    evaluate: special("MAP")
+  },
+  {
+    name: "REDUCE",
+    category: "logical",
+    description: "Reduces an array to one value by applying LAMBDA(accumulator, value) to each value, row by row.",
+    args: [
+      arg("initial_value", "The starting accumulator (may be left empty)."),
+      arg("array", "The array to reduce."),
+      LAMBDA_ARG
+    ],
+    evaluate: special("REDUCE")
+  },
+  {
+    name: "SCAN",
+    category: "logical",
+    description: "Like REDUCE, but returns every intermediate accumulator value (running totals).",
+    args: [
+      arg("initial_value", "The starting accumulator (may be left empty)."),
+      arg("array", "The array to scan."),
+      LAMBDA_ARG
+    ],
+    evaluate: special("SCAN")
+  },
+  {
+    name: "BYROW",
+    category: "logical",
+    description: "Applies a LAMBDA to each row of an array and returns one value per row: BYROW(A1:C3, LAMBDA(r, SUM(r))).",
+    args: [arg("array", "The array whose rows are passed to the LAMBDA."), LAMBDA_ARG],
+    evaluate: special("BYROW")
+  },
+  {
+    name: "BYCOL",
+    category: "logical",
+    description: "Applies a LAMBDA to each column of an array and returns one value per column.",
+    args: [arg("array", "The array whose columns are passed to the LAMBDA."), LAMBDA_ARG],
+    evaluate: special("BYCOL")
+  },
+  {
+    name: "MAKEARRAY",
+    category: "logical",
+    description: "Builds an array of the given size from LAMBDA(row, column): MAKEARRAY(3, 3, LAMBDA(r, c, r*c)).",
+    args: [
+      arg("rows", "Number of rows.", "number"),
+      arg("columns", "Number of columns.", "number"),
+      LAMBDA_ARG
+    ],
+    evaluate: special("MAKEARRAY")
+  }
+];
+
 // src/spreadsheet/formula/functions/index.ts
 var BUILTIN_FORMULA_FUNCTIONS = [
   ...MATH_FUNCTIONS,
@@ -4132,7 +4329,8 @@ var BUILTIN_FORMULA_FUNCTIONS = [
   ...LOOKUP_FUNCTIONS,
   ...DATE_FUNCTIONS,
   ...INFORMATION_FUNCTIONS,
-  ...ARRAY_FUNCTIONS
+  ...ARRAY_FUNCTIONS,
+  ...LAMBDA_FUNCTIONS
 ].map((def) => {
   const elementwise = ELEMENTWISE_BUILTINS[def.name];
   return elementwise && def.elementwise === void 0 ? { ...def, elementwise } : def;
@@ -4250,6 +4448,7 @@ function getFormulaSignature(nameOrDef) {
 }
 
 // src/spreadsheet/formula/evaluator.ts
+var BLANK_IGNORING_FUNCTIONS = /* @__PURE__ */ new Set(["SUM", "PRODUCT", "AVERAGE", "COUNT", "COUNTA", "MIN", "MAX"]);
 var DEFAULT_MESSAGES = {
   "#DIV/0!": "The formula divides by zero.",
   "#VALUE!": "A value in the formula has the wrong type.",
@@ -4289,11 +4488,30 @@ function buildArray(rows, cols, fn) {
 }
 var isMultiArray = (value) => Array.isArray(value) && value.length > 1;
 var firstValue = (value) => Array.isArray(value) ? value.length ? value[0] : "" : value;
+var sheetLabel = (node) => node.sheet === void 0 ? "" : `${node.sheetEnd === void 0 ? node.sheet : `${node.sheet}:${node.sheetEnd}`}!`;
+var SPECIAL_FORMS = /* @__PURE__ */ new Set(["LET", "LAMBDA", "ISOMITTED", "MAP", "REDUCE", "SCAN", "BYROW", "BYCOL", "MAKEARRAY"]);
+function elementValue(value) {
+  if (isFormulaLambda(value)) return "#CALC!";
+  if (Array.isArray(value)) return value.length === 1 ? elementValue(value[0]) : "#CALC!";
+  return value;
+}
+function asRange(value) {
+  if (Array.isArray(value)) return toFormulaRange(value);
+  return { rows: 1, cols: 1, values: [value] };
+}
+var LITERAL_BLANK = { type: "Literal", value: "" };
 var FormulaEvaluator = class {
   context;
   diagnostics = [];
-  // LET variables, innermost scope last.
-  scopes = [];
+  // LET and LAMBDA variables (innermost first, chained to outer scopes).
+  env = null;
+  // Sheet that unqualified references refer to while evaluating a
+  // sheet-scoped defined name (undefined: the formula's own sheet).
+  defaultSheet = void 0;
+  lambdaDepth = 0;
+  // Defined names being evaluated, to stop names that refer to themselves.
+  nameStack = [];
+  parsedNames = /* @__PURE__ */ new Map();
   constructor(context = {}) {
     this.context = context;
   }
@@ -4303,7 +4521,14 @@ var FormulaEvaluator = class {
    */
   evaluate(astOrFormula) {
     const ast = typeof astOrFormula === "string" ? parseFormula(astOrFormula) : astOrFormula;
-    return this.evaluateNode(ast);
+    const value = this.evaluateNode(ast);
+    if (isFormulaLambda(value)) {
+      return this.fail(
+        "#CALC!",
+        "The formula returns a LAMBDA function without calling it. Add its arguments in parentheses, e.g. LAMBDA(x, x+1)(2)."
+      );
+    }
+    return value;
   }
   /**
    * Evaluates a formula and explains errors. Never throws: malformed formulas
@@ -4313,9 +4538,15 @@ var FormulaEvaluator = class {
    */
   evaluateWithDiagnostics(astOrFormula) {
     const saved = this.diagnostics;
-    const savedScopes = this.scopes;
+    const savedEnv = this.env;
+    const savedSheet = this.defaultSheet;
+    const savedDepth = this.lambdaDepth;
+    const savedNames = this.nameStack;
     this.diagnostics = [];
-    this.scopes = [];
+    this.env = null;
+    this.defaultSheet = void 0;
+    this.lambdaDepth = 0;
+    this.nameStack = [];
     try {
       let value = this.evaluate(astOrFormula);
       let array;
@@ -4336,10 +4567,16 @@ var FormulaEvaluator = class {
       }
       return array ? { value, array } : { value };
     } catch (err) {
+      if (err instanceof RangeError) {
+        return { value: "#NUM!", error: "#NUM!", message: "The calculation is nested too deeply (recursion limit)." };
+      }
       return { value: "#ERROR!", error: "#ERROR!", message: err?.message || "Formula error" };
     } finally {
       this.diagnostics = saved;
-      this.scopes = savedScopes;
+      this.env = savedEnv;
+      this.defaultSheet = savedSheet;
+      this.lambdaDepth = savedDepth;
+      this.nameStack = savedNames;
     }
   }
   /** Records why an error happened and returns the error code. */
@@ -4357,11 +4594,16 @@ var FormulaEvaluator = class {
         if (!this.context.resolveCell) {
           throw new Error(`Cannot resolve cell reference ${node.ref}: no cell resolver provided`);
         }
-        const value = this.context.resolveCell(node.col, node.row);
+        if (node.sheetEnd !== void 0) return this.evaluate3d(node);
+        const value = this.context.resolveCell(node.col, node.row, node.sheet ?? this.defaultSheet);
         if (isFormulaError(value)) {
+          const label = `${sheetLabel(node)}${node.ref}`;
+          if (value === "#REF!" && node.sheet !== void 0) {
+            return this.fail("#REF!", `${label} refers to a sheet that doesn't exist.`);
+          }
           this.fail(
             value,
-            value === "#CYCLE!" ? `Cell ${node.ref} is part of a circular reference.` : `Cell ${node.ref} contains an error (${value}).`
+            value === "#CYCLE!" ? `Cell ${label} is part of a circular reference.` : `Cell ${label} contains an error (${value}).`
           );
         }
         return value;
@@ -4370,11 +4612,15 @@ var FormulaEvaluator = class {
         return this.evaluateRange(node);
       case "SpillRef":
         return this.evaluateSpillRef(node);
-      case "Name": {
-        for (let i = this.scopes.length - 1; i >= 0; i--) {
-          if (this.scopes[i].has(node.name)) return this.scopes[i].get(node.name);
-        }
-        return this.fail("#NAME?", "This formula contains an unknown name.");
+      case "Name":
+        return this.evaluateName(node);
+      case "Missing":
+        return "";
+      case "Invoke": {
+        const callee = this.evaluateNode(node.callee);
+        if (isFormulaLambda(callee)) return this.invokeLambda(callee, node.args);
+        if (isFormulaError(callee)) return callee;
+        return this.fail("#VALUE!", "Only a LAMBDA function can be called with arguments in parentheses.");
       }
       case "PropertyRef": {
         if (!this.context.resolveProperty) {
@@ -4396,6 +4642,9 @@ var FormulaEvaluator = class {
         if (isFormulaError(left)) return left;
         const right = this.evaluateNode(node.right);
         if (isFormulaError(right)) return right;
+        if (isFormulaLambda(left) || isFormulaLambda(right)) {
+          return this.fail("#VALUE!", `The ${node.op} operator can't use a LAMBDA function; call it with arguments first.`);
+        }
         if (isMultiArray(left) || isMultiArray(right)) {
           const a = shapeOf(left);
           const b = shapeOf(right);
@@ -4423,6 +4672,7 @@ var FormulaEvaluator = class {
     }
   }
   unary(op, raw) {
+    if (isFormulaLambda(raw)) return this.fail("#VALUE!", `The ${op} operator can't use a LAMBDA function.`);
     const val = toNumber(raw);
     if (isFormulaError(val)) {
       return isFormulaError(raw) ? raw : this.fail("#VALUE!", `The ${op} operator can't use text (${quote(raw)}).`);
@@ -4537,7 +4787,10 @@ var FormulaEvaluator = class {
     if (!this.context.resolveSpill) {
       throw new Error(`Cannot resolve spill range ${node.ref}#: no spill resolver provided`);
     }
-    const spill = this.context.resolveSpill(node.col, node.row);
+    if (node.sheetEnd !== void 0) {
+      return this.fail("#REF!", `A 3-D reference can't use the spill operator (${sheetLabel(node)}${node.ref}#).`);
+    }
+    const spill = this.context.resolveSpill(node.col, node.row, node.sheet ?? this.defaultSheet);
     if (typeof spill === "string" || !spill) {
       const code = isFormulaError(spill) ? spill : "#REF!";
       return this.fail(
@@ -4550,12 +4803,19 @@ var FormulaEvaluator = class {
     if (error) this.fail(error, `The spill range ${node.ref}# contains an error (${error}).`);
     return values;
   }
-  evaluateRange(node) {
+  evaluateRange(node, options) {
     if (!this.context.resolveRange) {
       throw new Error(`Cannot resolve range ${node.raw}: no range resolver provided`);
     }
-    const values = this.context.resolveRange(node.startCol, node.startRow, node.endCol, node.endRow);
-    if (!Array.isArray(values)) return values;
+    if (node.sheetEnd !== void 0) return this.evaluate3d(node);
+    const sheet = node.sheet ?? this.defaultSheet;
+    const values = options ? this.context.resolveRange(node.startCol, node.startRow, node.endCol, node.endRow, sheet, options) : this.context.resolveRange(node.startCol, node.startRow, node.endCol, node.endRow, sheet);
+    if (!Array.isArray(values)) {
+      if (values === "#REF!" && node.sheet !== void 0) {
+        return this.fail("#REF!", `${sheetLabel(node)}${node.raw} refers to a sheet that doesn't exist.`);
+      }
+      return values;
+    }
     const cols = Math.abs(colNameToIndex(node.endCol) - colNameToIndex(node.startCol)) + 1;
     if (values.length % cols === 0) withRangeShape(values, values.length / cols, cols);
     const error = values.find(isFormulaError);
@@ -4563,12 +4823,29 @@ var FormulaEvaluator = class {
     return values;
   }
   callFunction(node) {
+    const variables = lookupEnvironment(this.env, node.name);
+    if (variables) {
+      const bound = variables.vars.get(node.name);
+      if (isFormulaLambda(bound)) return this.invokeLambda(bound, node.args);
+    }
     const def = getFormulaFunction(node.name);
-    if (!def) return this.fail("#NAME?", `Unknown function "${node.name.toUpperCase()}".`);
+    if (!def) {
+      const named = this.lookupDefinedName(node.name);
+      if (named) {
+        const value = this.evaluateDefinedName(named, node.name);
+        if (isFormulaLambda(value)) return this.invokeLambda(value, node.args);
+        if (isFormulaError(value)) return value;
+        return this.fail("#VALUE!", `The name ${node.name} doesn't refer to a LAMBDA function, so it can't be called.`);
+      }
+      if (variables) {
+        return this.fail("#VALUE!", `The variable ${node.name} doesn't hold a LAMBDA function, so it can't be called.`);
+      }
+      return this.fail("#NAME?", `Unknown function "${node.name.toUpperCase()}".`);
+    }
     const countError = checkFormulaArgumentCount(def, node.args.length);
     if (countError) return this.fail("#ERROR!", countError);
-    if (def.name === "LET") return this.evaluateLet(node);
-    const args = this.lazyArguments(node.args);
+    if (SPECIAL_FORMS.has(def.name)) return this.evaluateSpecialForm(def.name, node);
+    const args = this.lazyArguments(node.args, BLANK_IGNORING_FUNCTIONS.has(def.name));
     if (def.elementwise) {
       const lifted = this.liftOverArrays(def, args);
       if (lifted !== void 0) return lifted;
@@ -4581,13 +4858,22 @@ var FormulaEvaluator = class {
     }
     return result === void 0 || result === null ? "" : result;
   }
-  lazyArguments(nodes) {
+  /**
+   * Arguments evaluated on first use. With `skipBlanks` (the function ignores
+   * blank cells), range arguments may come back without their blanks.
+   */
+  lazyArguments(nodes, skipBlanks = false) {
     const cache = /* @__PURE__ */ new Map();
     return nodes.map((node, index) => ({
       index,
       node,
       value: () => {
-        if (!cache.has(index)) cache.set(index, this.evaluateNode(node));
+        if (!cache.has(index)) {
+          cache.set(
+            index,
+            skipBlanks && node.type === "Range" && node.sheetEnd === void 0 ? this.evaluateRange(node, { skipBlanks: true }) : this.evaluateNode(node)
+          );
+        }
         return cache.get(index);
       }
     }));
@@ -4620,25 +4906,319 @@ var FormulaEvaluator = class {
       return firstValue(this.finishCall(def, def.evaluate(this.createContext(def, elementArgs))));
     });
   }
+  // --- Names, LET and LAMBDA ---
+  /** A bare name: a variable, a defined name, or #NAME?. */
+  evaluateName(node) {
+    if (node.sheet === void 0) {
+      const variables = lookupEnvironment(this.env, node.name);
+      if (variables) return variables.vars.get(node.name);
+    }
+    const named = this.lookupDefinedName(node.name, node.sheet);
+    if (named) return this.evaluateDefinedName(named, `${sheetLabel(node)}${node.name}`);
+    if (node.sheet !== void 0) {
+      return this.fail("#NAME?", `There is no name ${node.name} on sheet ${node.sheet}.`);
+    }
+    return this.fail("#NAME?", `This formula contains an unknown name.`);
+  }
+  lookupDefinedName(name, sheet) {
+    return this.context.resolveName?.(name, sheet ?? this.defaultSheet) ?? null;
+  }
+  /**
+   * Evaluates a defined name's formula, outside any LET/LAMBDA variables, with
+   * unqualified references pointing at the name's sheet (for sheet-scoped
+   * names).
+   */
+  evaluateDefinedName(def, label) {
+    const key = (def.key ?? label).toUpperCase();
+    if (this.nameStack.includes(key)) {
+      return this.fail("#CYCLE!", `The name ${label} refers to itself.`);
+    }
+    let ast;
+    if (typeof def.formula === "string") {
+      const text = def.formula.startsWith("=") ? def.formula : `=${def.formula}`;
+      let cached = this.parsedNames.get(text);
+      if (!cached) {
+        try {
+          cached = parseFormula(text);
+        } catch {
+          return this.fail("#NAME?", `The name ${label} has a formula that can't be read.`);
+        }
+        if (this.parsedNames.size > 500) this.parsedNames.clear();
+        this.parsedNames.set(text, cached);
+      }
+      ast = cached;
+    } else {
+      ast = def.formula;
+    }
+    const savedEnv = this.env;
+    const savedSheet = this.defaultSheet;
+    this.nameStack.push(key);
+    this.env = null;
+    if (def.sheet !== void 0) this.defaultSheet = def.sheet;
+    try {
+      return this.evaluateNode(ast);
+    } finally {
+      this.env = savedEnv;
+      this.defaultSheet = savedSheet;
+      this.nameStack.pop();
+    }
+  }
+  /** A 3-D reference (`Sheet1:Sheet3!A1`, `Sheet1:Sheet3!A1:B2`): every sheet's values, in tab order. */
+  evaluate3d(node) {
+    const label = node.type === "CellRef" ? `${sheetLabel(node)}${node.ref}` : `${sheetLabel(node)}${node.raw}`;
+    const sheets = this.context.resolveSheetSpan?.(node.sheet, node.sheetEnd);
+    if (!Array.isArray(sheets)) {
+      return this.fail("#REF!", `${label} refers to a sheet that doesn't exist.`);
+    }
+    const values = [];
+    for (const sheet of sheets) {
+      const part = node.type === "CellRef" ? [this.context.resolveCell(node.col, node.row, sheet)] : this.context.resolveRange(node.startCol, node.startRow, node.endCol, node.endRow, sheet);
+      if (!Array.isArray(part)) return this.fail("#REF!", `${label} refers to a sheet that doesn't exist.`);
+      for (const value of part) values.push(value ?? "");
+    }
+    const error = values.find(isFormulaError);
+    if (error) this.fail(error, `The 3-D reference ${label} contains an error (${error}).`);
+    return withRangeShape(values, values.length, 1);
+  }
+  /** Calls a lambda with argument expressions, evaluated in the caller's scope. */
+  invokeLambda(lambda, argNodes) {
+    const params = lambda.params;
+    const positionsOk = argNodes.length === params.length || argNodes.length === 0 && params.length === 1;
+    if (!positionsOk) {
+      return this.fail(
+        "#VALUE!",
+        `${lambda.label} expects ${params.length} argument${params.length === 1 ? "" : "s"}, but ${argNodes.length} ${argNodes.length === 1 ? "was" : "were"} given.`
+      );
+    }
+    const values = [];
+    const omitted = /* @__PURE__ */ new Set();
+    for (let i = 0; i < params.length; i++) {
+      const node = argNodes[i];
+      if (!node || node.type === "Missing") {
+        omitted.add(i);
+        values.push("");
+      } else {
+        values.push(this.evaluateNode(node));
+      }
+    }
+    return this.invokeWithValues(lambda, values, omitted);
+  }
+  /** Calls a lambda with argument values (`omitted`: positions left out, for ISOMITTED). */
+  invokeWithValues(lambda, values, omitted) {
+    if (this.lambdaDepth >= MAX_LAMBDA_DEPTH) {
+      return this.fail("#NUM!", `LAMBDA calls are nested more than ${MAX_LAMBDA_DEPTH} deep (runaway recursion?).`);
+    }
+    if (lambda.native) return lambda.native(values);
+    const vars = /* @__PURE__ */ new Map();
+    let omittedNames;
+    lambda.params.forEach((param, i) => {
+      vars.set(param, values[i] ?? "");
+      if (omitted?.has(i)) (omittedNames ??= /* @__PURE__ */ new Set()).add(param);
+    });
+    const savedEnv = this.env;
+    const savedSheet = this.defaultSheet;
+    this.env = { vars, omitted: omittedNames, parent: lambda.env };
+    this.defaultSheet = lambda.sheet;
+    this.lambdaDepth++;
+    try {
+      return this.evaluateNode(lambda.body);
+    } finally {
+      this.lambdaDepth--;
+      this.env = savedEnv;
+      this.defaultSheet = savedSheet;
+    }
+  }
+  evaluateSpecialForm(name, node) {
+    switch (name) {
+      case "LET":
+        return this.evaluateLet(node);
+      case "LAMBDA":
+        return this.evaluateLambda(node);
+      case "ISOMITTED": {
+        const arg2 = node.args[0];
+        if (arg2?.type !== "Name" || arg2.sheet !== void 0) return false;
+        const variables = lookupEnvironment(this.env, arg2.name);
+        return !!variables?.omitted?.has(arg2.name);
+      }
+      case "MAP":
+        return this.evaluateMap(node);
+      case "REDUCE":
+      case "SCAN":
+        return this.evaluateReduce(node, name === "SCAN");
+      case "BYROW":
+      case "BYCOL":
+        return this.evaluateByLine(node, name === "BYROW");
+      default:
+        return this.evaluateMakeArray(node);
+    }
+  }
   /** LET(name1, value1, [name2, value2, ...], calculation). */
   evaluateLet(node) {
     if (node.args.length % 2 === 0) {
       return this.fail("#ERROR!", "LET needs name/value pairs followed by a calculation.");
     }
-    const scope = /* @__PURE__ */ new Map();
-    this.scopes.push(scope);
+    const vars = /* @__PURE__ */ new Map();
+    const savedEnv = this.env;
+    this.env = { vars, parent: savedEnv };
     try {
       for (let i = 0; i < node.args.length - 1; i += 2) {
         const nameNode = node.args[i];
-        if (nameNode.type !== "Name") {
+        if (nameNode.type !== "Name" || nameNode.sheet !== void 0) {
           return this.fail("#ERROR!", `Argument ${i + 1} of LET must be a name (names can't look like cell references).`);
         }
-        scope.set(nameNode.name, this.evaluateNode(node.args[i + 1]));
+        vars.set(nameNode.name, this.evaluateNode(node.args[i + 1]));
       }
       return this.evaluateNode(node.args[node.args.length - 1]);
     } finally {
-      this.scopes.pop();
+      this.env = savedEnv;
+    }
+  }
+  /** LAMBDA([parameter1, ...], calculation): a function value closing over the current variables. */
+  evaluateLambda(node) {
+    const params = [];
+    for (let i = 0; i < node.args.length - 1; i++) {
+      const param = node.args[i];
+      if (param.type !== "Name" || param.sheet !== void 0) {
+        return this.fail("#VALUE!", `Parameter ${i + 1} of LAMBDA must be a name (names can't look like cell references).`);
+      }
+      if (params.includes(param.name)) {
+        return this.fail("#VALUE!", `LAMBDA parameter ${param.name} is listed twice.`);
+      }
+      params.push(param.name);
+    }
+    const body = node.args[node.args.length - 1];
+    if (body.type === "Missing") return this.fail("#VALUE!", "LAMBDA needs a calculation as its last argument.");
+    return new FormulaLambda(params, body, this.env, this.defaultSheet);
+  }
+  /**
+   * The function argument of a LAMBDA helper: a lambda, or a built-in
+   * function given by name (`BYROW(A1:C3, SUM)`) unless a variable or defined
+   * name has that name. Returns an error string when it is neither.
+   */
+  lambdaArgument(fn, node, index) {
+    if (!node) return this.fail("#VALUE!", `${fn} needs a LAMBDA function.`);
+    if (node.type === "Name" && node.sheet === void 0 && !lookupEnvironment(this.env, node.name) && !this.lookupDefinedName(node.name)) {
+      const def = getFormulaFunction(node.name);
+      if (def && !SPECIAL_FORMS.has(def.name)) {
+        return new FormulaLambda([], null, null, void 0, (values) => this.callBuiltinWithValues(def, values), def.name);
+      }
+    }
+    const value = this.evaluateNode(node);
+    if (isFormulaLambda(value)) return value;
+    if (isFormulaError(value)) return value;
+    return this.fail("#VALUE!", `Argument ${index + 1} of ${fn} must be a LAMBDA function.`);
+  }
+  /** Calls a built-in function with already evaluated arguments. */
+  callBuiltinWithValues(def, values) {
+    const countError = checkFormulaArgumentCount(def, values.length);
+    if (countError) return this.fail("#VALUE!", countError);
+    const args = values.map((value, index) => ({ index, node: LITERAL_BLANK, value: () => value }));
+    if (def.elementwise) {
+      const lifted = this.liftOverArrays(def, args);
+      if (lifted !== void 0) return lifted;
+    }
+    return this.finishCall(def, def.evaluate(this.createContext(def, args)));
+  }
+  /** Checks a lambda takes `count` parameters (native functions take any count). */
+  checkArity(fn, lambda, count) {
+    if (lambda.native || lambda.params.length === count) return null;
+    return this.fail(
+      "#VALUE!",
+      `The LAMBDA passed to ${fn} must take ${count} parameter${count === 1 ? "" : "s"}, but it takes ${lambda.params.length}.`
+    );
+  }
+  /** MAP(array1, [array2, ...], lambda): calls the lambda with each element. */
+  evaluateMap(node) {
+    const lambda = this.lambdaArgument("MAP", node.args[node.args.length - 1], node.args.length - 1);
+    if (typeof lambda === "string") return lambda;
+    const arrays = [];
+    for (let i = 0; i < node.args.length - 1; i++) {
+      const value = this.evaluateNode(node.args[i]);
+      if (isFormulaError(value)) return value;
+      arrays.push(value);
+    }
+    const arity = this.checkArity("MAP", lambda, arrays.length);
+    if (arity) return arity;
+    let rows = 1;
+    let cols = 1;
+    for (const array of arrays) {
+      const shape = shapeOf(array);
+      rows = Math.max(rows, shape.rows);
+      cols = Math.max(cols, shape.cols);
     }
+    if (rows * cols > MAX_FORMULA_ARRAY_SIZE) return this.fail("#NUM!", "The array result is too large.");
+    return buildArray(
+      rows,
+      cols,
+      (r, c) => elementValue(this.invokeWithValues(lambda, arrays.map((array) => broadcastGet(array, r, c))))
+    );
+  }
+  /**
+   * REDUCE([initial_value], array, lambda) / SCAN(...): folds the array row
+   * by row with lambda(accumulator, value). SCAN returns every intermediate
+   * value, in the array's shape.
+   */
+  evaluateReduce(node, scan) {
+    const fn = scan ? "SCAN" : "REDUCE";
+    let acc = this.evaluateNode(node.args[0]);
+    const arrayValue = this.evaluateNode(node.args[1]);
+    if (isFormulaError(arrayValue)) return arrayValue;
+    const lambda = this.lambdaArgument(fn, node.args[2], 2);
+    if (typeof lambda === "string") return lambda;
+    const arity = this.checkArity(fn, lambda, 2);
+    if (arity) return arity;
+    const range = asRange(arrayValue);
+    const results = scan ? new Array(range.rows * range.cols) : [];
+    for (let r = 0; r < range.rows; r++) {
+      for (let c = 0; c < range.cols; c++) {
+        acc = this.invokeWithValues(lambda, [acc, rangeGet(range, r, c)]);
+        if (scan) results[c * range.rows + r] = elementValue(acc);
+      }
+    }
+    if (scan) return withRangeShape(results, range.rows, range.cols);
+    return acc;
+  }
+  /** BYROW(array, lambda) / BYCOL(array, lambda): one result per row (a column) or per column (a row). */
+  evaluateByLine(node, byRow) {
+    const fn = byRow ? "BYROW" : "BYCOL";
+    const arrayValue = this.evaluateNode(node.args[0]);
+    if (isFormulaError(arrayValue)) return arrayValue;
+    const lambda = this.lambdaArgument(fn, node.args[1], 1);
+    if (typeof lambda === "string") return lambda;
+    const arity = this.checkArity(fn, lambda, 1);
+    if (arity) return arity;
+    const range = asRange(arrayValue);
+    const count = byRow ? range.rows : range.cols;
+    const out = [];
+    for (let i = 0; i < count; i++) {
+      const line = [];
+      const length = byRow ? range.cols : range.rows;
+      for (let j = 0; j < length; j++) line.push(byRow ? rangeGet(range, i, j) : rangeGet(range, j, i));
+      const slice = byRow ? withRangeShape(line, 1, length) : withRangeShape(line, length, 1);
+      out.push(elementValue(this.invokeWithValues(lambda, [slice])));
+    }
+    return byRow ? withRangeShape(out, count, 1) : withRangeShape(out, 1, count);
+  }
+  /** MAKEARRAY(rows, columns, lambda): lambda(row, column) for every 1-based position. */
+  evaluateMakeArray(node) {
+    const size = (index) => {
+      const value = firstValue(this.evaluateNode(node.args[index]));
+      if (isFormulaError(value)) return value;
+      const num = toNumber(value);
+      if (isFormulaError(num)) return this.fail("#VALUE!", `Argument ${index + 1} of MAKEARRAY must be a number.`);
+      return Math.trunc(num);
+    };
+    const rows = size(0);
+    if (typeof rows === "string") return rows;
+    const cols = size(1);
+    if (typeof cols === "string") return cols;
+    if (rows < 1 || cols < 1) return this.fail("#VALUE!", "MAKEARRAY needs at least one row and one column.");
+    if (rows * cols > MAX_FORMULA_ARRAY_SIZE) return this.fail("#NUM!", "The array result is too large.");
+    const lambda = this.lambdaArgument("MAKEARRAY", node.args[2], 2);
+    if (typeof lambda === "string") return lambda;
+    const arity = this.checkArity("MAKEARRAY", lambda, 2);
+    if (arity) return arity;
+    return buildArray(rows, cols, (r, c) => elementValue(this.invokeWithValues(lambda, [r + 1, c + 1])));
   }
   createContext(def, args) {
     const has = (index) => index >= 0 && index < args.length;
@@ -4728,12 +5308,16 @@ export {
   parseRange,
   FormulaParser,
   parseFormula,
+  FormulaLambda,
+  isFormulaLambda,
+  MAX_LAMBDA_DEPTH,
   serialFromYmd,
   parseCellInput,
   parseNumberText,
   FORMULA_ERRORS,
   isFormulaError,
   isBlank,
+  toBoolean,
   toText,
   numberToText,
   numericValue,
@@ -4743,6 +5327,7 @@ export {
   colNameToIndex,
   indexToColName,
   parseIsoDate,
+  serialToDate,
   wildcardToRegExp,
   parseCriteria,
   formatGeneralFit,
@@ -4768,4 +5353,4 @@ export {
   MAX_FORMULA_ARRAY_SIZE,
   FormulaEvaluator
 };
-//# sourceMappingURL=chunk-3CN2WD3X.js.map
+//# sourceMappingURL=chunk-ZRNHGAQT.js.map