@pixerate/editor 0.24.0 → 0.26.0

package/dist/{chunk-MCSJFWAO.cjs → chunk-EWCOFSCQ.cjs}

@@ -1,4 +1,30 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// 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 = _nullishCoalesce(_optionalChain([qualified, 'optionalAccess', _2 => _2.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 = class {
   __init() {this.tokens = []}
   __init2() {this.current = 0}
@@ -275,7 +342,22 @@ var FormulaParser = (_class = 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 = 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 = 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;
+  }
+  
+  
+  
+  
+  
+  
+  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!",
@@ -597,7 +712,7 @@ function parseIsoDate(value) {
 var isoDateHasTime = (value) => /[ T]\d/.test(value.trim());
 function isoDateTime(value) {
   if (value.length < 8 || value.charCodeAt(4) !== 45) return null;
-  return _nullishCoalesce(_optionalChain([parseIsoDate, 'call', _2 => _2(value), 'optionalAccess', _3 => _3.getTime, 'call', _4 => _4()]), () => ( null));
+  return _nullishCoalesce(_optionalChain([parseIsoDate, 'call', _3 => _3(value), 'optionalAccess', _4 => _4.getTime, 'call', _5 => _5()]), () => ( null));
 }
 function dateToSerial(date) {
   const utc = Date.UTC(
@@ -1170,14 +1285,14 @@ var BUILTINS = [
   [49, "@"]
 ];
 function builtinNumberFormat(id) {
-  return _optionalChain([BUILTINS, 'access', _5 => _5.find, 'call', _6 => _6(([i]) => i === id), 'optionalAccess', _7 => _7[1]]);
+  return _optionalChain([BUILTINS, 'access', _6 => _6.find, 'call', _7 => _7(([i]) => i === id), 'optionalAccess', _8 => _8[1]]);
 }
 function builtinNumberFormatId(code) {
   const exact = BUILTINS.find(([, c]) => c === code);
   if (exact) return exact[0];
   const norm = (s) => s.replace(/\\/g, "").toLowerCase();
   const n = norm(code);
-  return _optionalChain([BUILTINS, 'access', _8 => _8.find, 'call', _9 => _9(([, c]) => norm(c) === n), 'optionalAccess', _10 => _10[0]]);
+  return _optionalChain([BUILTINS, 'access', _9 => _9.find, 'call', _10 => _10(([, c]) => norm(c) === n), 'optionalAccess', _11 => _11[0]]);
 }
 
 // src/spreadsheet/numfmt/parse.ts
@@ -1220,7 +1335,7 @@ function testCond(c, v) {
       return v >= c.value;
   }
 }
-var isDigitTok = (t, c) => _optionalChain([t, 'optionalAccess', _11 => _11.t]) === "digit" && (c === void 0 || t.c === c);
+var isDigitTok = (t, c) => _optionalChain([t, 'optionalAccess', _12 => _12.t]) === "digit" && (c === void 0 || t.c === c);
 function splitSections(code) {
   const cs = Array.from(code);
   const lastClose = cs.lastIndexOf("]");
@@ -1272,7 +1387,7 @@ function startsWithCi(cs, i, pat) {
 function pushLit(toks, s) {
   if (s === "") return;
   const last = toks[toks.length - 1];
-  if (_optionalChain([last, 'optionalAccess', _12 => _12.t]) === "lit") last.s += s;
+  if (_optionalChain([last, 'optionalAccess', _13 => _13.t]) === "lit") last.s += s;
   else toks.push({ t: "lit", s });
 }
 var CURRENCY_CHARS = /* @__PURE__ */ new Set(["$", "\u20AC", "\xA3", "\xA5", "\u20B9", "\u20A9", "\u20BD", "\xA2", "\u20AA", "\u20AB", "\u0E3F"]);
@@ -1430,7 +1545,7 @@ function tokenize(src) {
   }
   return raw;
 }
-var datePartOf = (t) => _optionalChain([t, 'optionalAccess', _13 => _13.t]) === "date" ? t.d : void 0;
+var datePartOf = (t) => _optionalChain([t, 'optionalAccess', _14 => _14.t]) === "date" ? t.d : void 0;
 function analyze(raw) {
   const toks = raw.toks;
   const isDate = toks.some((t) => t.t === "date");
@@ -1471,8 +1586,8 @@ function analyze(raw) {
       if (t.t !== "date" || t.d.k !== "month" || t.d.n > 2) continue;
       const prev = prevPart[i2];
       const nxt = nextPart[i2];
-      const afterH = _optionalChain([prev, 'optionalAccess', _14 => _14.k]) === "hour" || _optionalChain([prev, 'optionalAccess', _15 => _15.k]) === "eh";
-      const beforeS = _optionalChain([nxt, 'optionalAccess', _16 => _16.k]) === "second" || _optionalChain([nxt, 'optionalAccess', _17 => _17.k]) === "es";
+      const afterH = _optionalChain([prev, 'optionalAccess', _15 => _15.k]) === "hour" || _optionalChain([prev, 'optionalAccess', _16 => _16.k]) === "eh";
+      const beforeS = _optionalChain([nxt, 'optionalAccess', _17 => _17.k]) === "second" || _optionalChain([nxt, 'optionalAccess', _18 => _18.k]) === "es";
       if (afterH || beforeS) toks[i2] = { t: "date", d: { k: "minute", n: t.d.n } };
     }
     const out2 = [];
@@ -1575,7 +1690,7 @@ function analyze(raw) {
         break;
       }
       case "slash": {
-        const nextOk = _optionalChain([toks, 'access', _18 => _18[i + 1], 'optionalAccess', _19 => _19.t]) === "denom" || _optionalChain([firstNonLitAfter, 'access', _20 => _20[i], 'optionalAccess', _21 => _21.t]) === "digit";
+        const nextOk = _optionalChain([toks, 'access', _19 => _19[i + 1], 'optionalAccess', _20 => _20.t]) === "denom" || _optionalChain([firstNonLitAfter, 'access', _21 => _21[i], 'optionalAccess', _22 => _22.t]) === "digit";
         const hasExp = seenExp || lastExp > i;
         if (!fractionSlash && seenDigit && nextOk && !seenPoint && !hasExp) {
           fractionSlash = true;
@@ -1586,7 +1701,7 @@ function analyze(raw) {
         break;
       }
       case "denom":
-        if (!(_optionalChain([toks, 'access', _22 => _22[i - 1], 'optionalAccess', _23 => _23.t]) === "slash" && sec.fraction)) replace = { t: "lit", s: t.s };
+        if (!(_optionalChain([toks, 'access', _23 => _23[i - 1], 'optionalAccess', _24 => _24.t]) === "slash" && sec.fraction)) replace = { t: "lit", s: t.s };
         break;
       default:
         break;
@@ -1748,7 +1863,7 @@ function renderDate(sec, v) {
 }
 var digitChar = (toks, i) => {
   const t = toks[i];
-  return _optionalChain([t, 'optionalAccess', _24 => _24.t]) === "digit" ? t.c : "0";
+  return _optionalChain([t, 'optionalAccess', _25 => _25.t]) === "digit" ? t.c : "0";
 };
 function fillInt(toks, idxs, digits, thousands, forceZero, pieces) {
   let rem = digits.length;
@@ -1807,7 +1922,7 @@ function fillFrac(toks, idxs, frac, pieces) {
 }
 function digitIndices(toks, start, end) {
   const out = [];
-  for (let i = start; i < end; i++) if (_optionalChain([toks, 'access', _25 => _25[i], 'optionalAccess', _26 => _26.t]) === "digit") out.push(i);
+  for (let i = start; i < end; i++) if (_optionalChain([toks, 'access', _26 => _26[i], 'optionalAccess', _27 => _27.t]) === "digit") out.push(i);
   return out;
 }
 function renderNumber(sec, v) {
@@ -1926,7 +2041,7 @@ function blankRange(toks, start, end, spaces, pieces, lits) {
 }
 function renderFraction(sec, x, pieces, lits) {
   const toks = sec.toks;
-  const isDigit = (i) => _optionalChain([toks, 'access', _27 => _27[i], 'optionalAccess', _28 => _28.t]) === "digit";
+  const isDigit = (i) => _optionalChain([toks, 'access', _28 => _28[i], 'optionalAccess', _29 => _29.t]) === "digit";
   const slash = toks.findIndex((t) => t.t === "slash");
   if (slash === -1) return;
   let numLast = -1;
@@ -1945,13 +2060,13 @@ function renderFraction(sec, x, pieces, lits) {
   let fixedDen;
   let denStart;
   const afterSlash = toks[slash + 1];
-  if (_optionalChain([afterSlash, 'optionalAccess', _29 => _29.t]) === "denom") {
+  if (_optionalChain([afterSlash, 'optionalAccess', _30 => _30.t]) === "denom") {
     const parsed = Number(afterSlash.s);
     fixedDen = Math.min(Math.max(Number.isFinite(parsed) ? parsed : 1e9, 1), 1e9);
     denStart = slash + 1;
   } else {
     denStart = slash + 1;
-    while (_optionalChain([toks, 'access', _30 => _30[denStart], 'optionalAccess', _31 => _31.t]) === "lit") denStart += 1;
+    while (_optionalChain([toks, 'access', _31 => _31[denStart], 'optionalAccess', _32 => _32.t]) === "lit") denStart += 1;
   }
   let denEnd = denStart;
   if (fixedDen !== void 0) denEnd += 1;
@@ -2009,7 +2124,7 @@ function renderFraction(sec, x, pieces, lits) {
   }
 }
 function isDigitTok2(t, c) {
-  return _optionalChain([t, 'optionalAccess', _32 => _32.t]) === "digit" && t.c === c;
+  return _optionalChain([t, 'optionalAccess', _33 => _33.t]) === "digit" && t.c === c;
 }
 
 // src/spreadsheet/numfmt/index.ts
@@ -2041,7 +2156,7 @@ var NumberFormat = class _NumberFormat {
     this.general = false;
     this.sections = parseSections(code);
     const len = this.sections.length;
-    const lastIsText = _optionalChain([this, 'access', _33 => _33.sections, 'access', _34 => _34[len - 1], 'optionalAccess', _35 => _35.kind]) === "text";
+    const lastIsText = _optionalChain([this, 'access', _34 => _34.sections, 'access', _35 => _35[len - 1], 'optionalAccess', _36 => _36.kind]) === "text";
     this.textSection = len >= 4 ? 3 : lastIsText ? len - 1 : void 0;
     this.numSections = len >= 4 ? 3 : lastIsText ? len - 1 : len;
   }
@@ -2118,7 +2233,7 @@ var NumberFormat = class _NumberFormat {
     const s0 = secs[0];
     if (!s0) return null;
     const c0 = s0.cond;
-    const c1 = _optionalChain([secs, 'access', _36 => _36[1], 'optionalAccess', _37 => _37.cond]);
+    const c1 = _optionalChain([secs, 'access', _37 => _37[1], 'optionalAccess', _38 => _38.cond]);
     if (c0 || c1) {
       let idx;
       if (c0 && testCond(c0, v)) idx = 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,12 +4488,31 @@ 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 = (_class3 = class {
   
   __init5() {this.diagnostics = []}
-  // LET variables, innermost scope last.
-  __init6() {this.scopes = []}
-  constructor(context = {}) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);
+  // LET and LAMBDA variables (innermost first, chained to outer scopes).
+  __init6() {this.env = null}
+  // Sheet that unqualified references refer to while evaluating a
+  // sheet-scoped defined name (undefined: the formula's own sheet).
+  __init7() {this.defaultSheet = void 0}
+  __init8() {this.lambdaDepth = 0}
+  // Defined names being evaluated, to stop names that refer to themselves.
+  __init9() {this.nameStack = []}
+  __init10() {this.parsedNames = /* @__PURE__ */ new Map()}
+  constructor(context = {}) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
     this.context = context;
   }
   /**
@@ -4303,7 +4521,14 @@ var FormulaEvaluator = (_class3 = 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 = (_class3 = 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;
@@ -4329,17 +4560,23 @@ var FormulaEvaluator = (_class3 = class {
         const result = {
           value,
           error: code,
-          message: _nullishCoalesce(_optionalChain([diagnostic, 'optionalAccess', _38 => _38.message]), () => ( describeFormulaError(code)))
+          message: _nullishCoalesce(_optionalChain([diagnostic, 'optionalAccess', _39 => _39.message]), () => ( describeFormulaError(code)))
         };
         if (array) result.array = array;
         return result;
       }
       return array ? { value, array } : { value };
     } catch (err) {
-      return { value: "#ERROR!", error: "#ERROR!", message: _optionalChain([err, 'optionalAccess', _39 => _39.message]) || "Formula error" };
+      if (err instanceof RangeError) {
+        return { value: "#NUM!", error: "#NUM!", message: "The calculation is nested too deeply (recursion limit)." };
+      }
+      return { value: "#ERROR!", error: "#ERROR!", message: _optionalChain([err, 'optionalAccess', _40 => _40.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 = (_class3 = 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, _nullishCoalesce(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 = (_class3 = 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 = (_class3 = 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 = (_class3 = 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)}).`);
@@ -4517,7 +4767,7 @@ var FormulaEvaluator = (_class3 = class {
     const value = this.evaluateNode(argument);
     if (!Array.isArray(value)) return value;
     if (value.length <= 1) return firstValue(value);
-    const cell = _optionalChain([this, 'access', _40 => _40.context, 'access', _41 => _41.getFormulaCell, 'optionalCall', _42 => _42()]);
+    const cell = _optionalChain([this, 'access', _41 => _41.context, 'access', _42 => _42.getFormulaCell, 'optionalCall', _43 => _43()]);
     if (argument.type === "Range" && cell) {
       const range = toFormulaRange(value);
       const top = Math.min(argument.startRow, argument.endRow);
@@ -4537,7 +4787,10 @@ var FormulaEvaluator = (_class3 = 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, _nullishCoalesce(node.sheet, () => ( this.defaultSheet)));
     if (typeof spill === "string" || !spill) {
       const code = isFormulaError(spill) ? spill : "#REF!";
       return this.fail(
@@ -4550,12 +4803,19 @@ var FormulaEvaluator = (_class3 = 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 = _nullishCoalesce(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 = (_class3 = 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 = (_class3 = 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);
       }
     }));
@@ -4599,7 +4885,7 @@ var FormulaEvaluator = (_class3 = class {
    * multi-value array.
    */
   liftOverArrays(def, args) {
-    const liftable = (index) => _optionalChain([def, 'access', _43 => _43.args, 'access', _44 => _44[getFormulaArgumentSpecIndex(def, index)], 'optionalAccess', _45 => _45.type]) !== "range";
+    const liftable = (index) => _optionalChain([def, 'access', _44 => _44.args, 'access', _45 => _45[getFormulaArgumentSpecIndex(def, index)], 'optionalAccess', _46 => _46.type]) !== "range";
     const triggers = def.elementwise === true ? args.map((a) => a.index) : def.elementwise;
     if (!triggers.some((i) => i < args.length && liftable(i) && isMultiArray(args[i].value()))) return void 0;
     let rows = 1;
@@ -4620,25 +4906,319 @@ var FormulaEvaluator = (_class3 = 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 _nullishCoalesce(_optionalChain([this, 'access', _47 => _47.context, 'access', _48 => _48.resolveName, 'optionalCall', _49 => _49(name, _nullishCoalesce(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 = (_nullishCoalesce(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 (e2) {
+          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 = _optionalChain([this, 'access', _50 => _50.context, 'access', _51 => _51.resolveSheetSpan, 'optionalCall', _52 => _52(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(_nullishCoalesce(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, _nullishCoalesce(values[i], () => ( "")));
+      if (_optionalChain([omitted, 'optionalAccess', _53 => _53.has, 'call', _54 => _54(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 (_optionalChain([arg2, 'optionalAccess', _55 => _55.type]) !== "Name" || arg2.sheet !== void 0) return false;
+        const variables = lookupEnvironment(this.env, arg2.name);
+        return !!_optionalChain([variables, 'optionalAccess', _56 => _56.omitted, 'optionalAccess', _57 => _57.has, 'call', _58 => _58(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;
@@ -4767,5 +5347,10 @@ var FormulaEvaluator = (_class3 = class {
 
 
 
-exports.tokenizeFormula = tokenizeFormula; exports.WHOLE_COLUMN_END_ROW = WHOLE_COLUMN_END_ROW; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.serialFromYmd = serialFromYmd; exports.parseCellInput = parseCellInput; exports.parseNumberText = parseNumberText; exports.FORMULA_ERRORS = FORMULA_ERRORS; exports.isFormulaError = isFormulaError; exports.isBlank = isBlank; exports.toText = toText; exports.numberToText = numberToText; exports.numericValue = numericValue; exports.compareNumbers = compareNumbers; exports.compareValues = compareValues; exports.sortCompareValues = sortCompareValues; exports.colNameToIndex = colNameToIndex; exports.indexToColName = indexToColName; exports.parseIsoDate = parseIsoDate; exports.wildcardToRegExp = wildcardToRegExp; exports.parseCriteria = parseCriteria; exports.formatGeneralFit = formatGeneralFit; exports.builtinNumberFormat = builtinNumberFormat; exports.builtinNumberFormatId = builtinNumberFormatId; exports.MAX_NUMBER_FORMAT_CODE_CHARS = MAX_NUMBER_FORMAT_CODE_CHARS; exports.NumberFormat = NumberFormat; exports.clearNumberFormatCache = clearNumberFormatCache; exports.dateValueToSerial = dateValueToSerial; exports.formatNumberFormatValue = formatNumberFormatValue; exports.formatTextFunction = formatTextFunction; exports.numberFormatColorToCss = numberFormatColorToCss; exports.registerFormulaFunction = registerFormulaFunction; exports.unregisterFormulaFunction = unregisterFormulaFunction; exports.getFormulaFunction = getFormulaFunction; exports.listFormulaFunctions = listFormulaFunctions; exports.searchFormulaFunctions = searchFormulaFunctions; exports.getFormulaArgumentSpecIndex = getFormulaArgumentSpecIndex; exports.checkFormulaArgumentCount = checkFormulaArgumentCount; exports.getFormulaSignatureParts = getFormulaSignatureParts; exports.getFormulaSignature = getFormulaSignature; exports.describeFormulaError = describeFormulaError; exports.MAX_FORMULA_ARRAY_SIZE = MAX_FORMULA_ARRAY_SIZE; exports.FormulaEvaluator = FormulaEvaluator;
-//# sourceMappingURL=chunk-MCSJFWAO.cjs.map
+
+
+
+
+
+exports.tokenizeFormula = tokenizeFormula; exports.WHOLE_COLUMN_END_ROW = WHOLE_COLUMN_END_ROW; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.FormulaLambda = FormulaLambda; exports.isFormulaLambda = isFormulaLambda; exports.MAX_LAMBDA_DEPTH = MAX_LAMBDA_DEPTH; exports.serialFromYmd = serialFromYmd; exports.parseCellInput = parseCellInput; exports.parseNumberText = parseNumberText; exports.FORMULA_ERRORS = FORMULA_ERRORS; exports.isFormulaError = isFormulaError; exports.isBlank = isBlank; exports.toBoolean = toBoolean; exports.toText = toText; exports.numberToText = numberToText; exports.numericValue = numericValue; exports.compareNumbers = compareNumbers; exports.compareValues = compareValues; exports.sortCompareValues = sortCompareValues; exports.colNameToIndex = colNameToIndex; exports.indexToColName = indexToColName; exports.parseIsoDate = parseIsoDate; exports.serialToDate = serialToDate; exports.wildcardToRegExp = wildcardToRegExp; exports.parseCriteria = parseCriteria; exports.formatGeneralFit = formatGeneralFit; exports.builtinNumberFormat = builtinNumberFormat; exports.builtinNumberFormatId = builtinNumberFormatId; exports.MAX_NUMBER_FORMAT_CODE_CHARS = MAX_NUMBER_FORMAT_CODE_CHARS; exports.NumberFormat = NumberFormat; exports.clearNumberFormatCache = clearNumberFormatCache; exports.dateValueToSerial = dateValueToSerial; exports.formatNumberFormatValue = formatNumberFormatValue; exports.formatTextFunction = formatTextFunction; exports.numberFormatColorToCss = numberFormatColorToCss; exports.registerFormulaFunction = registerFormulaFunction; exports.unregisterFormulaFunction = unregisterFormulaFunction; exports.getFormulaFunction = getFormulaFunction; exports.listFormulaFunctions = listFormulaFunctions; exports.searchFormulaFunctions = searchFormulaFunctions; exports.getFormulaArgumentSpecIndex = getFormulaArgumentSpecIndex; exports.checkFormulaArgumentCount = checkFormulaArgumentCount; exports.getFormulaSignatureParts = getFormulaSignatureParts; exports.getFormulaSignature = getFormulaSignature; exports.describeFormulaError = describeFormulaError; exports.MAX_FORMULA_ARRAY_SIZE = MAX_FORMULA_ARRAY_SIZE; exports.FormulaEvaluator = FormulaEvaluator;
+//# sourceMappingURL=chunk-EWCOFSCQ.cjs.map