@pixerate/editor 0.23.0 → 0.25.0

package/dist/{chunk-QBJ22YZR.js → chunk-FH6F67DN.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!",
@@ -982,209 +1097,1343 @@ function parseCriteria(criterion) {
   };
 }
 
-// src/spreadsheet/formula/format.ts
-function formatCellDisplay(cell) {
-  if (!cell) return "";
-  if (cell.error) return cell.error;
-  const { value, numberFormat } = cell;
-  if (numberFormat && value !== "" && value !== null && value !== void 0 && typeof value !== "boolean") {
-    if (/^\[h\]/i.test(numberFormat) && typeof value === "number") return formatElapsedHours(value);
-    if (numberFormat === "# ?/?" && typeof value === "number") return formatFraction(value);
-    const formatted = formatValueWithCode(value, numberFormat);
-    if (formatted !== null) return formatted;
-  }
-  return toText(value);
-}
-function formatFraction(value) {
-  const sign = value < 0 ? "-" : "";
-  const abs = Math.abs(value);
-  let whole = Math.floor(abs);
-  const frac = abs - whole;
-  let best = { num: 0, den: 1, err: frac };
-  for (let den = 2; den <= 9; den++) {
-    const num = Math.round(frac * den);
-    const err = Math.abs(frac - num / den);
-    if (err < best.err - 1e-12) best = { num, den, err };
-  }
-  if (best.num === best.den) {
-    whole += 1;
-    best = { num: 0, den: 1, err: 0 };
-  }
-  if (best.num === 0) return `${sign}${whole}`;
-  return `${sign}${whole === 0 ? "" : `${whole} `}${best.num}/${best.den}`;
-}
-function formatElapsedHours(days) {
-  const total = Math.round(Math.abs(days) * 86400);
-  const p = (n) => String(n).padStart(2, "0");
-  const text = `${Math.floor(total / 3600)}:${p(Math.floor(total / 60) % 60)}:${p(total % 60)}`;
-  return days < 0 ? `-${text}` : text;
-}
-function formatValueWithCode(value, format) {
-  if (isDateFormat(format)) {
-    const date = toDate(value);
-    return date ? formatDate(date, format) : null;
-  }
-  const num = typeof value === "boolean" ? null : numericValue(value);
-  return num === null ? toText(value) : formatNumber(num, format);
-}
-function tokenize(format) {
-  const out = [];
-  const push = (literal, text) => {
-    const last = out[out.length - 1];
-    if (last && last.literal === literal) last.text += text;
-    else out.push({ literal, text });
-  };
-  for (let i = 0; i < format.length; i++) {
-    const char = format[i];
-    if (char === '"') {
-      const end = format.indexOf('"', i + 1);
-      const stop = end === -1 ? format.length : end;
-      push(true, format.slice(i + 1, stop));
-      i = stop;
-    } else if (char === "\\" && i + 1 < format.length) {
-      push(true, format[++i]);
+// src/spreadsheet/numfmt/decimal.ts
+var MAX_DECIMALS = 400;
+function significantDigits(a, n) {
+  const s = a.toExponential(Math.max(0, Math.min(100, n - 1)));
+  const e = s.indexOf("e");
+  const digits = [];
+  for (let i = 0; i < e; i++) {
+    const c = s.charCodeAt(i);
+    if (c >= 48 && c <= 57) digits.push(c - 48);
+  }
+  return { digits, exp: Number(s.slice(e + 1)) };
+}
+function exactDigits(a) {
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, a);
+  const hi = view.getUint32(0);
+  const lo = view.getUint32(4);
+  const biased = hi >>> 20 & 2047;
+  let mantissa = BigInt(hi & 1048575) << 32n | BigInt(lo);
+  let exp2;
+  if (biased === 0) {
+    exp2 = -1074;
+  } else {
+    mantissa |= 1n << 52n;
+    exp2 = biased - 1075;
+  }
+  const digits = exp2 >= 0 ? (mantissa << BigInt(exp2)).toString() : (mantissa * 5n ** BigInt(-exp2)).toString();
+  return digits.replace(/0+$/, "");
+}
+function isExactTie(a) {
+  const isTie = (ds) => ds.length >= 16 && ds[15] === "5" && /^0*$/.test(ds.slice(16));
+  return isTie(significantDigits(a, 30).digits.join("")) && isTie(exactDigits(a).padEnd(16, "0"));
+}
+function decimalDigits(a) {
+  if (!Number.isFinite(a) || a <= 0) return { digits: new Array(15).fill(0), exp: 0 };
+  const { digits: d16, exp } = significantDigits(a, 16);
+  const digits = d16.slice(0, 15);
+  while (digits.length < 15) digits.push(0);
+  const sixteenth = d16[15] ?? 0;
+  if (sixteenth <= 4) return { digits, exp };
+  if (sixteenth === 5) {
+    if (isExactTie(a)) return { digits, exp };
+    const r = significantDigits(a, 15);
+    while (r.digits.length < 15) r.digits.push(0);
+    return r;
+  }
+  let e = exp;
+  let carry = true;
+  for (let i = 14; i >= 0; i--) {
+    if (digits[i] === 9) {
+      digits[i] = 0;
     } else {
-      push(false, char);
+      digits[i] += 1;
+      carry = false;
+      break;
+    }
+  }
+  if (carry) {
+    digits.fill(0);
+    digits[0] = 1;
+    e += 1;
+  }
+  return { digits, exp: e };
+}
+function fixedFromDigits(digits, exp, decimals) {
+  const decimalsCalc = Math.min(decimals, MAX_DECIMALS);
+  const keep = exp + decimalsCalc + 1;
+  let m;
+  if (keep <= 0) {
+    m = keep === 0 && (digits[0] ?? 0) >= 5 ? [1] : [];
+  } else if (keep >= digits.length) {
+    m = digits.slice();
+    while (m.length < keep) m.push(0);
+  } else {
+    m = digits.slice(0, keep);
+    if ((digits[keep] ?? 0) >= 5) {
+      let carry = true;
+      for (let i = m.length - 1; i >= 0; i--) {
+        if (m[i] === 9) {
+          m[i] = 0;
+        } else {
+          m[i] += 1;
+          carry = false;
+          break;
+        }
+      }
+      if (carry) m.unshift(1);
+    }
+  }
+  let lead = 0;
+  while (lead < m.length && m[lead] === 0) lead++;
+  m = m.slice(lead);
+  const toS = (ds) => ds.join("");
+  let int;
+  let frac;
+  if (m.length <= decimalsCalc) {
+    int = "";
+    frac = "0".repeat(decimalsCalc - m.length) + toS(m);
+  } else {
+    const split = m.length - decimalsCalc;
+    int = toS(m.slice(0, split));
+    frac = toS(m.slice(split));
+  }
+  if (decimals > decimalsCalc) frac += "0".repeat(decimals - decimalsCalc);
+  return [int, frac];
+}
+function fixed(a, decimals) {
+  if (!Number.isFinite(a) || a <= 0) return ["", "0".repeat(Math.min(decimals, MAX_DECIMALS * 4))];
+  const { digits, exp } = decimalDigits(a);
+  return fixedFromDigits(digits, exp, decimals);
+}
+var charCount = (s) => Array.from(s).length;
+function formatGeneralFit(n, maxChars) {
+  if (!Number.isFinite(n)) return null;
+  if (n === 0) return maxChars >= 1 ? "0" : null;
+  const sign = n < 0 ? "-" : "";
+  const { digits, exp: x } = decimalDigits(Math.abs(n));
+  const intLen = sign.length + Math.max(x, 0) + 1;
+  if (x >= -4 && intLen <= maxChars) {
+    const avail = maxChars - intLen;
+    let decimals = avail >= 2 ? avail - 1 : 0;
+    for (; ; ) {
+      const [i, f0] = fixedFromDigits(digits, x, decimals);
+      const f = f0.replace(/0+$/, "");
+      if (i === "" && f === "") break;
+      let s = sign + (i === "" ? "0" : i);
+      if (f !== "") s += `.${f}`;
+      if (charCount(s) <= maxChars) return s;
+      if (decimals === 0) break;
+      decimals -= 1;
+    }
+  }
+  for (let md = Math.min(maxChars, 14); md >= 0; md--) {
+    let e = x;
+    let [mi, mf] = fixedFromDigits(digits, 0, md);
+    if (mi.length > 1) {
+      e += 1;
+      [mi, mf] = fixedFromDigits(digits, -1, md);
+    }
+    mf = mf.replace(/0+$/, "");
+    let s = sign + (mi === "" ? "0" : mi);
+    if (mf !== "") s += `.${mf}`;
+    s += `E${e < 0 ? "-" : "+"}${String(Math.abs(e)).padStart(2, "0")}`;
+    if (charCount(s) <= maxChars) return s;
+  }
+  return null;
+}
+
+// src/spreadsheet/numfmt/builtin.ts
+var BUILTINS = [
+  [0, "General"],
+  [1, "0"],
+  [2, "0.00"],
+  [3, "#,##0"],
+  [4, "#,##0.00"],
+  [5, '"$"#,##0_);\\("$"#,##0\\)'],
+  [6, '"$"#,##0_);[Red]\\("$"#,##0\\)'],
+  [7, '"$"#,##0.00_);\\("$"#,##0.00\\)'],
+  [8, '"$"#,##0.00_);[Red]\\("$"#,##0.00\\)'],
+  [9, "0%"],
+  [10, "0.00%"],
+  [11, "0.00E+00"],
+  [12, "# ?/?"],
+  [13, "# ??/??"],
+  [14, "m/d/yyyy"],
+  [15, "d-mmm-yy"],
+  [16, "d-mmm"],
+  [17, "mmm-yy"],
+  [18, "h:mm AM/PM"],
+  [19, "h:mm:ss AM/PM"],
+  [20, "h:mm"],
+  [21, "h:mm:ss"],
+  [22, "m/d/yyyy h:mm"],
+  [37, "#,##0 ;(#,##0)"],
+  [38, "#,##0 ;[Red](#,##0)"],
+  [39, "#,##0.00;(#,##0.00)"],
+  [40, "#,##0.00;[Red](#,##0.00)"],
+  [41, '_(* #,##0_);_(* \\(#,##0\\);_(* "-"_);_(@_)'],
+  [42, '_("$"* #,##0_);_("$"* \\(#,##0\\);_("$"* "-"_);_(@_)'],
+  [43, '_(* #,##0.00_);_(* \\(#,##0.00\\);_(* "-"??_);_(@_)'],
+  [44, '_("$"* #,##0.00_);_("$"* \\(#,##0.00\\);_("$"* "-"??_);_(@_)'],
+  [45, "mm:ss"],
+  [46, "[h]:mm:ss"],
+  [47, "mmss.0"],
+  [48, "##0.0E+0"],
+  [49, "@"]
+];
+function builtinNumberFormat(id) {
+  return BUILTINS.find(([i]) => i === id)?.[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 BUILTINS.find(([, c]) => norm(c) === n)?.[0];
+}
+
+// src/spreadsheet/numfmt/parse.ts
+var MAX_SECTIONS = 4;
+var isCalendarPart = (d) => d.k === "year" || d.k === "month" || d.k === "day";
+function literalText(tok) {
+  switch (tok.t) {
+    case "lit":
+    case "denom":
+      return tok.s;
+    case "digit":
+      return tok.c;
+    case "point":
+      return ".";
+    case "comma":
+      return ",";
+    case "percent":
+      return "%";
+    case "exp":
+      return `${tok.upper ? "E" : "e"}${tok.plus ? "+" : "-"}`;
+    case "slash":
+      return "/";
+    default:
+      return "";
+  }
+}
+function testCond(c, v) {
+  switch (c.op) {
+    case "=":
+      return v === c.value;
+    case "<>":
+      return v !== c.value;
+    case "<":
+      return v < c.value;
+    case "<=":
+      return v <= c.value;
+    case ">":
+      return v > c.value;
+    case ">=":
+      return v >= c.value;
+  }
+}
+var isDigitTok = (t, c) => t?.t === "digit" && (c === void 0 || t.c === c);
+function splitSections(code) {
+  const cs = Array.from(code);
+  const lastClose = cs.lastIndexOf("]");
+  const out = [""];
+  let quoted = false;
+  let escape = false;
+  let i = 0;
+  while (i < cs.length) {
+    const c = cs[i];
+    i += 1;
+    const cur = out.length - 1;
+    if (escape) {
+      out[cur] += c;
+      escape = false;
+      continue;
+    }
+    if (c === '"') {
+      quoted = !quoted;
+      out[cur] += c;
+    } else if ((c === "\\" || c === "_" || c === "*") && !quoted) {
+      escape = true;
+      out[cur] += c;
+    } else if (c === "[" && !quoted && lastClose >= i) {
+      let s = c;
+      while (i < cs.length) {
+        const d = cs[i];
+        i += 1;
+        s += d;
+        if (d === "]") break;
+      }
+      out[cur] += s;
+    } else if (c === ";" && !quoted) {
+      if (out.length >= MAX_SECTIONS) break;
+      out.push("");
+    } else {
+      out[cur] += c;
     }
   }
   return out;
 }
-var codeText = (format) => tokenize(format).filter((t) => !t.literal).map((t) => t.text).join("");
-function isDateFormat(format) {
-  const code = codeText(format);
-  if (/[0#?]/.test(code)) return false;
-  return /[ydhs]|m/i.test(code);
-}
-function formatNumber(num, format) {
-  const sections = splitSections(format);
-  let section = sections[0];
-  let value = num;
-  let sign = num < 0 ? "-" : "";
-  if (num < 0 && sections.length > 1) {
-    section = sections[1];
-    value = Math.abs(num);
-    sign = "";
-  } else if (num === 0 && sections.length > 2) {
-    section = sections[2];
-  }
-  let prefix = "";
-  let suffix = "";
-  let pattern = "";
-  for (const token of tokenize(section)) {
-    if (token.literal) {
-      if (pattern) suffix += token.text;
-      else prefix += token.text;
+var lowerAscii = (c) => c >= "A" && c <= "Z" ? c.toLowerCase() : c;
+function startsWithCi(cs, i, pat) {
+  for (let k = 0; k < pat.length; k++) {
+    const c = cs[i + k];
+    if (c === void 0 || lowerAscii(c) !== pat[k]) return false;
+  }
+  return true;
+}
+function pushLit(toks, s) {
+  if (s === "") return;
+  const last = toks[toks.length - 1];
+  if (last?.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"]);
+var isCurrencyChar = (c) => CURRENCY_CHARS.has(c);
+var NAMED_COLORS = /* @__PURE__ */ new Set(["black", "blue", "cyan", "green", "magenta", "red", "white", "yellow"]);
+function parseColor(lc) {
+  if (NAMED_COLORS.has(lc)) return lc;
+  if (!lc.startsWith("color")) return void 0;
+  const rest = lc.slice(5).trim();
+  if (!/^\+?\d{1,3}$/.test(rest)) return void 0;
+  const n = Number(rest);
+  return n >= 1 && n <= 56 ? `color${n}` : void 0;
+}
+function parseCond(s) {
+  const t = s.trim();
+  let op;
+  let rest;
+  if (t.startsWith("<=")) [op, rest] = ["<=", t.slice(2)];
+  else if (t.startsWith(">=")) [op, rest] = [">=", t.slice(2)];
+  else if (t.startsWith("<>")) [op, rest] = ["<>", t.slice(2)];
+  else if (t.startsWith("<")) [op, rest] = ["<", t.slice(1)];
+  else if (t.startsWith(">")) [op, rest] = [">", t.slice(1)];
+  else if (t.startsWith("=")) [op, rest] = ["=", t.slice(1)];
+  else return void 0;
+  const r = rest.trim();
+  if (!/^[+-]?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?$/i.test(r)) return void 0;
+  const value = Number(r);
+  return Number.isFinite(value) ? { op, value } : void 0;
+}
+function bracket(raw, content) {
+  const lc = content.trim().toLowerCase();
+  const color = parseColor(lc);
+  if (color) {
+    raw.color = color;
+    return;
+  }
+  if (lc.startsWith("<") || lc.startsWith(">") || lc.startsWith("=")) {
+    const c = parseCond(lc);
+    if (c) raw.cond = c;
+    return;
+  }
+  if (content.startsWith("$")) {
+    const sym = content.slice(1).split("-")[0];
+    if (sym !== "") {
+      raw.currency = true;
+      pushLit(raw.toks, sym);
+    }
+    return;
+  }
+  const first = lc[0];
+  if ((first === "h" || first === "m" || first === "s") && Array.from(lc).every((c) => c === first)) {
+    const n = Math.min(Array.from(lc).length, 255);
+    raw.toks.push({ t: "date", d: { k: first === "h" ? "eh" : first === "m" ? "em" : "es", n } });
+  }
+}
+function tokenize(src) {
+  const cs = Array.from(src);
+  const raw = { toks: [], currency: false };
+  const toks = raw.toks;
+  const lastClose = cs.lastIndexOf("]");
+  let i = 0;
+  while (i < cs.length) {
+    const c = cs[i];
+    if (c === '"') {
+      let s = "";
+      i += 1;
+      while (i < cs.length) {
+        const d = cs[i];
+        i += 1;
+        if (d === '"') break;
+        s += d;
+      }
+      if (Array.from(s).some(isCurrencyChar)) raw.currency = true;
+      pushLit(toks, s);
+      continue;
+    }
+    if (c === "\\") {
+      const d = cs[i + 1];
+      if (d !== void 0) {
+        if (isCurrencyChar(d)) raw.currency = true;
+        pushLit(toks, d);
+      }
+      i += 2;
+      continue;
+    }
+    if (c === "_") {
+      if (cs[i + 1] !== void 0) pushLit(toks, " ");
+      i += 2;
+      continue;
+    }
+    if (c === "*") {
+      const d = cs[i + 1];
+      if (d !== void 0) toks.push({ t: "fill", c: d });
+      i += 2;
       continue;
     }
-    for (let i = 0; i < token.text.length; i++) {
-      const char = token.text[i];
-      const isExponent = /e/i.test(char) && /[+-]/.test(token.text[i + 1] ?? "");
-      const isExponentSign = /[+-]/.test(char) && /e$/i.test(pattern);
-      if (/[0#?.,]/.test(char) || pattern && (isExponent || isExponentSign)) {
-        pattern += char;
-      } else if (pattern) {
-        suffix += char;
+    if (c === "[") {
+      const close = lastClose > i ? cs.indexOf("]", i + 1) : -1;
+      if (close !== -1) {
+        bracket(raw, cs.slice(i + 1, close).join(""));
+        i = close + 1;
       } else {
-        prefix += char;
-      }
-    }
-  }
-  const percents = (prefix + suffix).split("%").length - 1;
-  value = Math.abs(value) * Math.pow(100, percents);
-  if (!pattern) return `${sign}${prefix}${suffix}`;
-  const expMatch = /^([^Ee]*)[Ee]([+-])(0+)$/.exec(pattern);
-  if (expMatch) {
-    const [, mantissa, expSign, expDigits] = expMatch;
-    const decimals = (mantissa.split(".")[1] ?? "").length;
-    const [m, e] = value.toExponential(decimals).split("e");
-    const exponent = Number(e);
-    const expText = String(Math.abs(exponent)).padStart(expDigits.length, "0");
-    const shownSign = exponent < 0 ? "-" : expSign === "+" ? "+" : "";
-    return `${sign}${prefix}${m}E${shownSign}${expText}${suffix}`;
-  }
-  const [intPattern, decPattern = ""] = pattern.split(".");
-  const maxDecimals = (decPattern.match(/[0#?]/g) ?? []).length;
-  const minDecimals = (decPattern.match(/0/g) ?? []).length;
-  const minInt = (intPattern.match(/0/g) ?? []).length;
-  const grouping = intPattern.includes(",");
-  const rounded = roundHalfAwayFromZero(value, maxDecimals);
-  let [intPart, decPart = ""] = rounded.toFixed(maxDecimals).split(".");
-  while (decPart.length > minDecimals && decPart.endsWith("0")) decPart = decPart.slice(0, -1);
-  if (intPart === "0" && minInt === 0) intPart = "";
-  intPart = intPart.padStart(minInt, "0");
-  if (grouping) intPart = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-  const showSign = sign && /[1-9]/.test(intPart + decPart) ? sign : "";
-  return `${showSign}${prefix}${intPart}${decPart ? `.${decPart}` : ""}${suffix}`;
-}
-function splitSections(format) {
-  const sections = [""];
-  let quoted = false;
-  for (let i = 0; i < format.length; i++) {
-    const char = format[i];
-    if (char === '"') quoted = !quoted;
-    if (char === "\\" && i + 1 < format.length) {
-      sections[sections.length - 1] += char + format[++i];
+        pushLit(toks, "[");
+        i += 1;
+      }
+      continue;
+    }
+    if (c === "0" || c === "#" || c === "?") toks.push({ t: "digit", c });
+    else if (c === ".") toks.push({ t: "point" });
+    else if (c === ",") toks.push({ t: "comma" });
+    else if (c === "%") toks.push({ t: "percent" });
+    else if (c === "@") toks.push({ t: "at" });
+    else if (c === "/") {
+      toks.push({ t: "slash" });
+      i += 1;
+      if (cs[i] !== void 0 && cs[i] >= "1" && cs[i] <= "9") {
+        let s = "";
+        while (i < cs.length && cs[i] >= "0" && cs[i] <= "9") {
+          s += cs[i];
+          i += 1;
+        }
+        toks.push({ t: "denom", s });
+      }
+      continue;
+    } else if ((c === "e" || c === "E") && (cs[i + 1] === "+" || cs[i + 1] === "-")) {
+      toks.push({ t: "exp", upper: c === "E", plus: cs[i + 1] === "+" });
+      i += 2;
+      continue;
+    } else if ((c === "G" || c === "g") && startsWithCi(cs, i, "general")) {
+      toks.push({ t: "general" });
+      i += 7;
+      continue;
+    } else if ((c === "A" || c === "a") && startsWithCi(cs, i, "am/pm")) {
+      toks.push({ t: "date", d: { k: "ampm" } });
+      i += 5;
       continue;
+    } else if ((c === "A" || c === "a") && startsWithCi(cs, i, "a/p")) {
+      toks.push({ t: "date", d: { k: "ap", a: c, p: cs[i + 2] ?? "P" } });
+      i += 3;
+      continue;
+    } else if ("yYmMdDhHsSeE".includes(c)) {
+      const lc = lowerAscii(c);
+      let n = 0;
+      while (cs[i + n] !== void 0 && lowerAscii(cs[i + n]) === lc) n += 1;
+      const n8 = Math.min(n, 255);
+      const d = lc === "y" ? { k: "year", n: n8 } : lc === "e" ? { k: "year", n: 4 } : lc === "m" ? { k: "month", n: n8 } : lc === "d" ? { k: "day", n: n8 } : lc === "h" ? { k: "hour", n: n8 } : { k: "second", n: n8 };
+      toks.push({ t: "date", d });
+      i += Math.max(n, 1);
+      continue;
+    } else {
+      if (isCurrencyChar(c)) raw.currency = true;
+      pushLit(toks, c);
     }
-    if (char === ";" && !quoted) sections.push("");
-    else sections[sections.length - 1] += char;
+    i += 1;
   }
-  return sections;
+  return raw;
 }
+var datePartOf = (t) => t?.t === "date" ? t.d : void 0;
+function analyze(raw) {
+  const toks = raw.toks;
+  const isDate = toks.some((t) => t.t === "date");
+  const hasGeneral = toks.some((t) => t.t === "general");
+  const sec = {
+    toks: [],
+    color: raw.color,
+    cond: raw.cond,
+    kind: "number",
+    thousands: false,
+    scale: 0,
+    percent: 0,
+    hasAt: toks.some((t) => t.t === "at"),
+    hasDigits: false,
+    exp: false,
+    fraction: false,
+    currency: raw.currency,
+    fill: toks.some((t) => t.t === "fill")
+  };
+  if (isDate) {
+    sec.kind = "date";
+    const prevPart = [];
+    let last;
+    for (let i2 = 0; i2 < toks.length; i2++) {
+      prevPart.push(last);
+      const d = datePartOf(toks[i2]);
+      if (d) last = d;
+    }
+    const nextPart = new Array(toks.length);
+    let next;
+    for (let i2 = toks.length - 1; i2 >= 0; i2--) {
+      nextPart[i2] = next;
+      const d = datePartOf(toks[i2]);
+      if (d) next = d;
+    }
+    for (let i2 = 0; i2 < toks.length; i2++) {
+      const t = toks[i2];
+      if (t.t !== "date" || t.d.k !== "month" || t.d.n > 2) continue;
+      const prev = prevPart[i2];
+      const nxt = nextPart[i2];
+      const afterH = prev?.k === "hour" || prev?.k === "eh";
+      const beforeS = nxt?.k === "second" || nxt?.k === "es";
+      if (afterH || beforeS) toks[i2] = { t: "date", d: { k: "minute", n: t.d.n } };
+    }
+    const out2 = [];
+    let i = 0;
+    while (i < toks.length) {
+      const t = toks[i];
+      if (t.t === "point" && isDigitTok(toks[i + 1], "0")) {
+        let n = 0;
+        while (isDigitTok(toks[i + 1 + n], "0")) n += 1;
+        out2.push({ t: "date", d: { k: "subsec", n: Math.min(n, 255) } });
+        i += 1 + n;
+        continue;
+      }
+      if (t.t === "date" || t.t === "fill") out2.push(t);
+      else pushLit(out2, literalText(t));
+      i += 1;
+    }
+    sec.toks = out2;
+    return sec;
+  }
+  if (hasGeneral) {
+    sec.kind = "general";
+    const out2 = [];
+    for (const t of toks) {
+      if (t.t === "general" || t.t === "fill") out2.push(t);
+      else pushLit(out2, literalText(t));
+    }
+    sec.toks = out2;
+    return sec;
+  }
+  sec.hasDigits = toks.some((t) => t.t === "digit");
+  if (sec.hasAt && !sec.hasDigits) {
+    sec.kind = "text";
+    const out2 = [];
+    for (const t of toks) {
+      if (t.t === "at" || t.t === "fill") out2.push(t);
+      else pushLit(out2, literalText(t));
+    }
+    sec.toks = out2;
+    return sec;
+  }
+  let seenPoint = false;
+  let seenExp = false;
+  let seenDigit = false;
+  let fractionSlash = false;
+  const digitAfterCommas = new Array(toks.length).fill(false);
+  const firstNonLitAfter = new Array(toks.length);
+  let after = false;
+  let nonLit;
+  for (let j = toks.length - 1; j >= 0; j--) {
+    digitAfterCommas[j] = after;
+    firstNonLitAfter[j] = nonLit;
+    const t = toks[j];
+    if (t.t !== "comma") after = t.t === "digit";
+    if (t.t !== "lit") nonLit = t;
+  }
+  let lastExp = -1;
+  for (let j = toks.length - 1; j >= 0; j--) {
+    if (toks[j].t === "exp") {
+      lastExp = j;
+      break;
+    }
+  }
+  const firstDigit = toks.findIndex((t) => t.t === "digit");
+  const scientific = firstDigit !== -1 && toks.slice(firstDigit).some((t) => t.t === "exp");
+  for (let i = 0; i < toks.length; i++) {
+    const t = toks[i];
+    let replace;
+    switch (t.t) {
+      case "digit":
+        seenDigit = true;
+        break;
+      case "point":
+        if (seenPoint || seenExp) replace = { t: "lit", s: "." };
+        else seenPoint = true;
+        break;
+      case "percent":
+        sec.percent += 1;
+        break;
+      case "exp":
+        if (seenExp || !seenDigit) replace = { t: "lit", s: literalText(t) };
+        else {
+          seenExp = true;
+          sec.exp = true;
+        }
+        break;
+      case "comma": {
+        const nextDigit = digitAfterCommas[i];
+        if (seenDigit && nextDigit && !seenPoint && !seenExp) {
+          sec.thousands = true;
+          replace = { t: "lit", s: "" };
+        } else if (seenDigit && scientific) {
+          replace = { t: "lit", s: "" };
+        } else if (seenDigit && !nextDigit) {
+          sec.scale += 1;
+          replace = { t: "lit", s: "" };
+        } else {
+          replace = { t: "lit", s: "," };
+        }
+        break;
+      }
+      case "slash": {
+        const nextOk = toks[i + 1]?.t === "denom" || firstNonLitAfter[i]?.t === "digit";
+        const hasExp = seenExp || lastExp > i;
+        if (!fractionSlash && seenDigit && nextOk && !seenPoint && !hasExp) {
+          fractionSlash = true;
+          sec.fraction = true;
+        } else {
+          replace = { t: "lit", s: "/" };
+        }
+        break;
+      }
+      case "denom":
+        if (!(toks[i - 1]?.t === "slash" && sec.fraction)) replace = { t: "lit", s: t.s };
+        break;
+      default:
+        break;
+    }
+    if (replace) toks[i] = replace;
+  }
+  if (sec.fraction) {
+    for (let i = 0; i < toks.length; i++) if (toks[i].t === "point") toks[i] = { t: "lit", s: "." };
+  }
+  const out = [];
+  for (const t of toks) {
+    if (t.t === "lit") pushLit(out, t.s);
+    else out.push(t);
+  }
+  sec.toks = out;
+  return sec;
+}
+function parseSections(code) {
+  return splitSections(code).map((s) => analyze(tokenize(s)));
+}
+
+// src/spreadsheet/numfmt/render.ts
+var MAX_DATE_SERIAL = 2958465;
 var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
-var DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
-var pad3 = (n) => String(n).padStart(2, "0");
-function formatDate(date, format) {
-  const parts = [];
-  for (const token of tokenize(format)) {
-    if (token.literal) {
-      parts.push(token);
+var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var UNIX_1899_12_302 = -25569;
+function civilFromDays(z0) {
+  const z = z0 + 719468;
+  const era = Math.floor(z / 146097);
+  const doe = z - era * 146097;
+  const yoe = Math.floor((doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365);
+  const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));
+  const mp = Math.floor((5 * doy + 2) / 153);
+  const d = doy - Math.floor((153 * mp + 2) / 5) + 1;
+  const m = mp < 10 ? mp + 3 : mp - 9;
+  return { y: yoe + era * 400 + (m <= 2 ? 1 : 0), m, d };
+}
+function dateFromSerial(day) {
+  const weekday = ((day + 6) % 7 + 7) % 7;
+  if (day === 60) return { year: 1900, month: 2, day: 29, weekday };
+  if (day === 0) return { year: 1900, month: 1, day: 0, weekday };
+  const real = day < 60 ? day + 1 : day;
+  const { y, m, d } = civilFromDays(real + UNIX_1899_12_302);
+  return { year: y, month: m, day: d, weekday };
+}
+var Out = class {
+  text = "";
+  fill;
+  /** True when every digit shown is zero (a number section that rounded to zero). */
+  zero = false;
+  push(s) {
+    this.text += s;
+  }
+  setFill(c) {
+    if (!this.fill) this.fill = { char: c, index: this.text.length };
+  }
+  prepend(s) {
+    this.text = s + this.text;
+    if (this.fill) this.fill.index += s.length;
+  }
+};
+function renderText(sec, text) {
+  const out = new Out();
+  for (const t of sec.toks) {
+    if (t.t === "at") out.push(text);
+    else if (t.t === "fill") out.setFill(t.c);
+    else out.push(literalText(t));
+  }
+  return out;
+}
+function renderGeneral(sec, v, width) {
+  const out = new Out();
+  for (const t of sec.toks) {
+    if (t.t === "general") out.push(formatGeneralFit(v, width) ?? "#".repeat(Math.min(Math.max(width, 1), 11)));
+    else if (t.t === "fill") out.setFill(t.c);
+    else out.push(literalText(t));
+  }
+  return out;
+}
+var padNum = (n, w) => w >= 2 ? String(n).padStart(Math.min(w, 20), "0") : String(n);
+function renderDate(sec, v) {
+  if (!Number.isFinite(v) || v < 0 || v >= MAX_DATE_SERIAL + 1) return null;
+  let subDigits = 0;
+  for (const t of sec.toks) if (t.t === "date" && t.d.k === "subsec") subDigits = Math.max(subDigits, t.d.n);
+  subDigits = Math.min(subDigits, 3);
+  const unit = 10 ** (3 - subDigits);
+  let day = Math.floor(v);
+  let ms = Math.round((v - Math.floor(v)) * 864e5 / unit) * unit;
+  if (ms >= 864e5) {
+    ms -= 864e5;
+    day += 1;
+  }
+  const totalMs = day * 864e5 + ms;
+  const needsDate = sec.toks.some((t) => t.t === "date" && isCalendarPart(t.d));
+  if (needsDate && day > MAX_DATE_SERIAL) return null;
+  const dt = needsDate ? dateFromSerial(day) : dateFromSerial(0);
+  const ampm = sec.toks.some((t) => t.t === "date" && (t.d.k === "ampm" || t.d.k === "ap"));
+  const hour = Math.floor(ms / 36e5);
+  const minute = Math.floor(ms / 6e4) % 60;
+  const second = Math.floor(ms / 1e3) % 60;
+  const milli = ms % 1e3;
+  const monthName = MONTHS[dt.month - 1] ?? "";
+  const dayName = WEEKDAYS[dt.weekday] ?? "";
+  const out = new Out();
+  for (const t of sec.toks) {
+    if (t.t === "fill") {
+      out.setFill(t.c);
+      continue;
+    }
+    if (t.t !== "date") {
+      out.push(literalText(t));
       continue;
     }
-    const re = /AM\/PM|am\/pm|A\/P|a\/p|y+|m+|d+|h+|s+|[^ymdhsaA]+|./gi;
-    for (const match of token.text.match(re) ?? []) {
-      const isCode = /^(AM\/PM|A\/P|y+|m+|d+|h+|s+)$/i.test(match);
-      parts.push({ literal: !isCode, text: match });
-    }
-  }
-  const codes = parts.map((p, i) => ({ ...p, i })).filter((p) => !p.literal);
-  const twelveHour = codes.some((p) => /^(AM\/PM|A\/P)$/i.test(p.text));
-  return parts.map((part, index) => {
-    if (part.literal) return part.text;
-    const code = part.text;
-    const lower = code.toLowerCase();
-    if (/^(am\/pm|a\/p)$/.test(lower)) {
-      const pm = date.getHours() >= 12;
-      const full = pm ? "PM" : "AM";
-      const text = lower === "a/p" ? full[0] : full;
-      return code[0] === code[0].toLowerCase() ? text.toLowerCase() : text;
-    }
-    if (lower.startsWith("y")) {
-      return lower.length <= 2 ? pad3(date.getFullYear() % 100) : String(date.getFullYear());
-    }
-    if (lower.startsWith("d")) {
-      if (lower.length >= 4) return DAYS[date.getDay()];
-      if (lower.length === 3) return DAYS[date.getDay()].slice(0, 3);
-      return lower.length === 2 ? pad3(date.getDate()) : String(date.getDate());
-    }
-    if (lower.startsWith("h")) {
-      let hours = date.getHours();
-      if (twelveHour) hours = hours % 12 || 12;
-      return lower.length >= 2 ? pad3(hours) : String(hours);
-    }
-    if (lower.startsWith("s")) {
-      return lower.length >= 2 ? pad3(date.getSeconds()) : String(date.getSeconds());
-    }
-    const position = codes.findIndex((c) => c.i === index);
-    const prev = codes[position - 1]?.text.toLowerCase() ?? "";
-    const next = codes[position + 1]?.text.toLowerCase() ?? "";
-    if (lower.length <= 2 && (prev.startsWith("h") || next.startsWith("s"))) {
-      return lower.length === 2 ? pad3(date.getMinutes()) : String(date.getMinutes());
-    }
-    if (lower.length >= 4) return MONTHS[date.getMonth()];
-    if (lower.length === 3) return MONTHS[date.getMonth()].slice(0, 3);
-    return lower.length === 2 ? pad3(date.getMonth() + 1) : String(date.getMonth() + 1);
-  }).join("");
+    const d = t.d;
+    let s;
+    switch (d.k) {
+      case "year":
+        s = d.n <= 2 ? String((dt.year % 100 + 100) % 100).padStart(2, "0") : String(dt.year).padStart(4, "0");
+        break;
+      case "month":
+        s = d.n <= 2 ? padNum(dt.month, d.n) : d.n === 3 ? monthName.slice(0, 3) : d.n === 5 ? monthName.slice(0, 1) : monthName;
+        break;
+      case "day":
+        s = d.n <= 2 ? padNum(dt.day, d.n) : d.n === 3 ? dayName.slice(0, 3) : dayName;
+        break;
+      case "hour":
+        s = padNum(ampm ? hour % 12 || 12 : hour, d.n);
+        break;
+      case "minute":
+        s = padNum(minute, d.n);
+        break;
+      case "second":
+        s = padNum(second, d.n);
+        break;
+      case "subsec": {
+        s = `.${String(milli).padStart(3, "0")}`.slice(0, 1 + Math.min(d.n, 3));
+        if (d.n > 3) s += "0".repeat(d.n - 3);
+        break;
+      }
+      case "eh":
+        s = padNum(Math.floor(totalMs / 36e5), d.n);
+        break;
+      case "em":
+        s = padNum(Math.floor(totalMs / 6e4), d.n);
+        break;
+      case "es":
+        s = padNum(Math.floor(totalMs / 1e3), d.n);
+        break;
+      case "ampm":
+        s = hour >= 12 ? "PM" : "AM";
+        break;
+      case "ap":
+        s = hour >= 12 ? d.p : d.a;
+        break;
+    }
+    out.push(s);
+  }
+  return out;
+}
+var digitChar = (toks, i) => {
+  const t = toks[i];
+  return t?.t === "digit" ? t.c : "0";
+};
+function fillInt(toks, idxs, digits, thousands, forceZero, pieces) {
+  let rem = digits.length;
+  let pos = 0;
+  const count = idxs.length;
+  for (let k = 0; k < count; k++) {
+    const ti = idxs[count - 1 - k];
+    const leftmost = k + 1 === count;
+    const ph = digitChar(toks, ti);
+    const rev = [];
+    const pushDigit = (c) => {
+      if (thousands && pos > 0 && pos % 3 === 0) rev.push(",");
+      rev.push(c);
+      pos += 1;
+    };
+    const take = leftmost ? rem : Math.min(rem, 1);
+    if (take === 0) {
+      if (ph === "0") pushDigit("0");
+      else if (forceZero && k === 0) pushDigit("0");
+      else if (ph === "?") {
+        if (thousands && pos > 0 && pos % 3 === 0) rev.push(" ");
+        rev.push(" ");
+        pos += 1;
+      }
+    } else {
+      for (let n = 0; n < take; n++) {
+        rem -= 1;
+        pushDigit(digits[rem] ?? "0");
+      }
+    }
+    pieces[ti] = rev.reverse().join("");
+  }
+}
+function withCommas(digits, thousands) {
+  if (!thousands) return digits;
+  const n = digits.length;
+  let s = "";
+  for (let i = 0; i < n; i++) {
+    if (i > 0 && (n - i) % 3 === 0) s += ",";
+    s += digits[i];
+  }
+  return s;
+}
+function fillFrac(toks, idxs, frac, pieces) {
+  let lastSig = -1;
+  for (let i = frac.length - 1; i >= 0; i--) {
+    if (frac[i] !== "0") {
+      lastSig = i;
+      break;
+    }
+  }
+  idxs.forEach((ti, i) => {
+    const ph = digitChar(toks, ti);
+    pieces[ti] = i <= lastSig ? frac[i] ?? "0" : ph === "0" ? "0" : ph === "?" ? " " : "";
+  });
+}
+function digitIndices(toks, start, end) {
+  const out = [];
+  for (let i = start; i < end; i++) if (toks[i]?.t === "digit") out.push(i);
+  return out;
+}
+function renderNumber(sec, v) {
+  let x = Math.abs(v);
+  if (sec.percent > 0 && !sec.exp) x *= 100 ** Math.min(sec.percent, 20);
+  if (sec.scale > 0) x /= 1e3 ** Math.min(sec.scale, 110);
+  if (!Number.isFinite(x)) x = Number.MAX_VALUE;
+  const toks = sec.toks;
+  const n = toks.length;
+  const pieces = new Array(n).fill("");
+  const before = new Array(n + 1).fill("");
+  const lits = new Array(n);
+  let zero = false;
+  if (sec.fraction) {
+    renderFraction(sec, x, pieces, lits);
+  } else {
+    const pointIdx = toks.findIndex((t) => t.t === "point");
+    const expIdx = toks.findIndex((t) => t.t === "exp");
+    const point = pointIdx === -1 ? void 0 : pointIdx;
+    const exp = expIdx === -1 ? void 0 : expIdx;
+    const intEnd = point ?? exp ?? n;
+    const fracEnd = exp ?? n;
+    const intIdx = digitIndices(toks, 0, intEnd);
+    const fracIdx = point === void 0 ? [] : digitIndices(toks, point + 1, fracEnd);
+    let intS;
+    let fracS;
+    if (exp !== void 0) {
+      const expDigitIdx = digitIndices(toks, exp + 1, n);
+      const step = Math.max(intIdx.length, 1);
+      let e;
+      if (x === 0) {
+        e = 0;
+        intS = "0".repeat(intIdx.length);
+        fracS = "0".repeat(fracIdx.length);
+      } else {
+        const { digits, exp: xe } = decimalDigits(x);
+        e = xe - (xe % step + step) % step;
+        [intS, fracS] = fixedFromDigits(digits, xe - e, fracIdx.length);
+        if (intS.length > step) {
+          e += step;
+          [intS, fracS] = fixedFromDigits(digits, xe - e, fracIdx.length);
+        }
+      }
+      const et = toks[exp];
+      const upper = et.t === "exp" ? et.upper : true;
+      const plus = et.t === "exp" ? et.plus : true;
+      if (intS === "" && /^0*$/.test(fracS)) e = 0;
+      const head = upper ? "E" : "e";
+      const sign = e < 0 ? "-" : plus ? "+" : "";
+      const expDigits = String(Math.abs(e));
+      if (expDigitIdx.length > 0) {
+        pieces[exp] = head;
+        before[expDigitIdx[0]] = sign;
+        fillInt(toks, expDigitIdx, expDigits, false, false, pieces);
+      } else {
+        pieces[exp] = `${head}${sign}${expDigits}`;
+      }
+    } else {
+      [intS, fracS] = fixed(x, fracIdx.length);
+    }
+    zero = /^0*$/.test(intS + fracS);
+    fillInt(toks, intIdx, intS, sec.thousands, false, pieces);
+    const anchor = point ?? exp;
+    if (intIdx.length === 0 && intS !== "" && anchor !== void 0) before[anchor] = withCommas(intS, sec.thousands);
+    fillFrac(toks, fracIdx, fracS, pieces);
+    if (point !== void 0) pieces[point] = ".";
+  }
+  const out = new Out();
+  for (let i = 0; i < n; i++) {
+    out.push(before[i]);
+    const t = toks[i];
+    if (t.t === "lit") out.push(lits[i] ?? t.s);
+    else if (t.t === "percent") out.push("%");
+    else if (t.t === "fill") out.setFill(t.c);
+    else if (t.t === "at" || t.t === "general" || t.t === "date" || t.t === "comma") continue;
+    else out.push(pieces[i]);
+  }
+  out.zero = zero;
+  return out;
+}
+function approximate(x, maxDen) {
+  if (Number.isNaN(x) || x <= 0 || !Number.isFinite(x)) return [0, 1];
+  if (x >= 1e15) return [Math.round(x), 1];
+  let [p0, q0, p1, q1] = [0, 1, 1, 0];
+  let r = x;
+  for (let iter = 0; iter < 64; iter++) {
+    const aF = Math.floor(r);
+    if (aF > 1e15) break;
+    const q2 = aF * q1 + q0;
+    if (q2 > maxDen) break;
+    const p2 = aF * p1 + p0;
+    [p0, q0, p1, q1] = [p1, q1, p2, q2];
+    const frac = r - aF;
+    if (frac < 1e-12) break;
+    r = 1 / frac;
+  }
+  if (q1 === 0) return [Math.round(x), 1];
+  const k = Math.floor((maxDen - q0) / q1);
+  const pb = p0 + k * p1;
+  const qb = q0 + k * q1;
+  const errA = Math.abs(p1 / q1 - x);
+  const errB = qb > 0 ? Math.abs(pb / qb - x) : Infinity;
+  return errB < errA ? [pb, qb] : [p1, q1];
+}
+function shownWidth(t) {
+  if (t.t === "lit" || t.t === "denom") return Array.from(t.s).length;
+  return t.t === "digit" || t.t === "slash" ? 1 : 0;
+}
+function blankRange(toks, start, end, spaces, pieces, lits) {
+  for (let i = start; i < end && i < toks.length; i++) {
+    const t = toks[i];
+    const s = spaces ? " ".repeat(shownWidth(t)) : "";
+    if (t.t === "lit") lits[i] = s;
+    else if (t.t === "digit" || t.t === "slash" || t.t === "denom") pieces[i] = s;
+  }
+}
+function renderFraction(sec, x, pieces, lits) {
+  const toks = sec.toks;
+  const isDigit = (i) => toks[i]?.t === "digit";
+  const slash = toks.findIndex((t) => t.t === "slash");
+  if (slash === -1) return;
+  let numLast = -1;
+  for (let i = slash - 1; i >= 0; i--) {
+    if (isDigit(i)) {
+      numLast = i;
+      break;
+    }
+  }
+  if (numLast === -1) return;
+  let numStart = numLast;
+  while (numStart > 0 && isDigit(numStart - 1)) numStart -= 1;
+  const wholeIdx = digitIndices(toks, 0, numStart);
+  const numIdx = digitIndices(toks, numStart, numLast + 1);
+  const sepStart = wholeIdx.length > 0 ? wholeIdx[wholeIdx.length - 1] + 1 : numStart;
+  let fixedDen;
+  let denStart;
+  const afterSlash = toks[slash + 1];
+  if (afterSlash?.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 (toks[denStart]?.t === "lit") denStart += 1;
+  }
+  let denEnd = denStart;
+  if (fixedDen !== void 0) denEnd += 1;
+  else while (isDigit(denEnd)) denEnd += 1;
+  const denIdx = digitIndices(toks, denStart, denEnd);
+  const hasQ = (idx) => idx.some((i) => isDigitTok2(toks[i], "?"));
+  const hasWhole = wholeIdx.length > 0;
+  let whole = hasWhole ? Math.floor(x) : 0;
+  const f = hasWhole ? x - Math.floor(x) : x;
+  let num;
+  let den;
+  if (fixedDen !== void 0) {
+    num = Math.round(f * fixedDen);
+    den = fixedDen;
+  } else {
+    const digits = Math.min(Math.max(denIdx.length, 1), 7);
+    [num, den] = approximate(f, 10 ** digits - 1);
+  }
+  if (hasWhole && num >= den && den > 0) {
+    whole += Math.floor(num / den);
+    num %= den;
+  }
+  const wholeS = whole >= 1 ? fixed(whole, 0)[0] : "";
+  const numZeroPh = numIdx.some((i) => isDigitTok2(toks[i], "0"));
+  if (hasWhole && num === 0 && !numZeroPh) {
+    fillInt(toks, wholeIdx, wholeS, sec.thousands, true, pieces);
+    const spaces = hasQ(wholeIdx) || hasQ(numIdx) || hasQ(denIdx);
+    blankRange(toks, sepStart, denEnd, spaces, pieces, lits);
+    return;
+  }
+  if (hasWhole) {
+    const unitsHash = isDigitTok2(toks[wholeIdx[wholeIdx.length - 1]], "#");
+    const force = wholeS === "" && num === 0 && !unitsHash;
+    fillInt(toks, wholeIdx, wholeS, sec.thousands, force, pieces);
+    const wholeShown = wholeIdx.some((i) => /[0-9]/.test(pieces[i] ?? ""));
+    if (!wholeShown) {
+      const spaces = hasQ(wholeIdx) || hasQ(numIdx);
+      blankRange(toks, sepStart, numStart, spaces, pieces, lits);
+    }
+  }
+  fillInt(toks, numIdx, fixed(num, 0)[0] || "0", false, true, pieces);
+  pieces[slash] = "/";
+  const denS = fixed(den, 0)[0] || "0";
+  if (fixedDen !== void 0) {
+    pieces[denStart] = denS;
+  } else {
+    const zeros = denIdx.filter((i) => isDigitTok2(toks[i], "0")).length;
+    const padded = "0".repeat(Math.max(zeros - denS.length, 0)) + denS;
+    const count = denIdx.length;
+    denIdx.forEach((ti, k) => {
+      let s = k + 1 === count ? padded.slice(k) : padded[k] ?? "";
+      if (s === "") s = isDigitTok2(toks[ti], "?") ? " " : isDigitTok2(toks[ti], "0") ? "0" : "";
+      pieces[ti] = s;
+    });
+  }
+}
+function isDigitTok2(t, c) {
+  return t?.t === "digit" && t.c === c;
+}
+
+// src/spreadsheet/numfmt/index.ts
+var GENERAL_WIDTH = 11;
+var OVERFLOW = "########";
+var MAX_NUMBER_FORMAT_CODE_CHARS = 255;
+function tooLong(code) {
+  return code.length > MAX_NUMBER_FORMAT_CODE_CHARS && Array.from(code).length > MAX_NUMBER_FORMAT_CODE_CHARS;
+}
+var SPECIAL_CODES = ["00000", "00000-0000", "[<=9999999]###-####;(###) ###-####", "000-00-0000"];
+var NumberFormat = class _NumberFormat {
+  code;
+  general;
+  sections;
+  /** Sections that apply to numbers (a trailing text section is excluded). */
+  numSections;
+  /** Index of the section that applies to text, if any. */
+  textSection;
+  constructor(code, uncapped) {
+    this.code = code;
+    const trimmed = code.trim();
+    if (trimmed === "" || trimmed.toLowerCase() === "general" || trimmed === "checkbox" || !uncapped && tooLong(code)) {
+      this.general = true;
+      this.sections = [];
+      this.numSections = 0;
+      this.textSection = void 0;
+      return;
+    }
+    this.general = false;
+    this.sections = parseSections(code);
+    const len = this.sections.length;
+    const lastIsText = this.sections[len - 1]?.kind === "text";
+    this.textSection = len >= 4 ? 3 : lastIsText ? len - 1 : void 0;
+    this.numSections = len >= 4 ? 3 : lastIsText ? len - 1 : len;
+  }
+  /**
+   * Parses a format code. Never throws: unknown or malformed parts degrade to
+   * literal text, and a code longer than 255 characters degrades to General.
+   */
+  static parse(code) {
+    return new _NumberFormat(code, false);
+  }
+  /** `parse` without the 255-character cap (for tests that reach renderer edge cases). */
+  static parseUncapped(code) {
+    return new _NumberFormat(code, true);
+  }
+  /** Like `parse`, but remembers recently parsed codes (bounded), so formatting many values parses a code once. */
+  static parseCached(code) {
+    if (code.length > CACHE_MAX_CODE_LENGTH) return _NumberFormat.parse(code);
+    let fmt = parseCache.get(code);
+    if (!fmt) {
+      fmt = _NumberFormat.parse(code);
+      if (parseCache.size >= CACHE_CAPACITY) parseCache.clear();
+      parseCache.set(code, fmt);
+    }
+    return fmt;
+  }
+  static general() {
+    return _NumberFormat.parse("General");
+  }
+  isGeneral() {
+    return this.general;
+  }
+  numberSections() {
+    return this.sections.slice(0, this.numSections);
+  }
+  /** True when the code contains date or time tokens. */
+  isDate() {
+    return this.numberSections().some((s) => s.kind === "date");
+  }
+  isPercent() {
+    return this.numberSections().some((s) => s.kind === "number" && s.percent > 0);
+  }
+  /** True for a pure text format such as `@`. */
+  isText() {
+    return this.numSections === 0 && this.textSection !== void 0;
+  }
+  /** Best guess at the format category. */
+  kind() {
+    if (this.general) return "general";
+    if (this.isText()) return "text";
+    if (SPECIAL_CODES.includes(this.code)) return "special";
+    const s = this.sections[0];
+    if (!s) return "custom";
+    if (s.kind === "general") return "general";
+    if (s.kind === "text") return "text";
+    if (s.kind === "date") {
+      const calendar = s.toks.some((t) => t.t === "date" && (t.d.k === "year" || t.d.k === "month" || t.d.k === "day"));
+      return calendar ? "date" : "time";
+    }
+    if (s.fraction) return "fraction";
+    if (s.exp) return "scientific";
+    if (s.percent > 0) return "percentage";
+    if (s.fill && s.hasDigits) return "accounting";
+    if (s.currency && s.hasDigits) return "currency";
+    if (s.hasDigits) return "number";
+    return "custom";
+  }
+  /**
+   * Picks the number section for `v`, and whether the minus sign is dropped
+   * (a negative section shows the absolute value). Null means General.
+   */
+  select(v) {
+    const secs = this.numberSections();
+    const k = secs.length;
+    const s0 = secs[0];
+    if (!s0) return null;
+    const c0 = s0.cond;
+    const c1 = secs[1]?.cond;
+    if (c0 || c1) {
+      let idx;
+      if (c0 && testCond(c0, v)) idx = 0;
+      else if (c1 && testCond(c1, v)) idx = 1;
+      else if (c0 && c1) idx = 2;
+      else if (!c0) idx = 0;
+      else idx = 1;
+      const sec = secs[idx];
+      return sec ? { sec, dropSign: k >= 2 } : null;
+    }
+    if (v < 0 && k >= 2) return { sec: secs[1], dropSign: true };
+    if (v === 0 && k >= 3) return { sec: secs[2], dropSign: false };
+    return { sec: s0, dropSign: false };
+  }
+  /**
+   * Formats a number. `overflow` is true when the value can't be shown (a
+   * date out of range, painted as `########`).
+   */
+  formatNumber(n) {
+    const general = () => ({
+      text: formatGeneralFit(n, GENERAL_WIDTH) ?? OVERFLOW,
+      numeric: true,
+      overflow: false
+    });
+    if (!Number.isFinite(n)) return { text: "#NUM!", numeric: false, overflow: true };
+    if (this.general) return general();
+    const picked = this.select(n);
+    if (!picked) return general();
+    const { sec, dropSign } = picked;
+    const minus = n < 0 && !dropSign;
+    let out;
+    switch (sec.kind) {
+      case "text":
+        out = renderText(sec, formatGeneralFit(n, GENERAL_WIDTH) ?? "");
+        break;
+      case "general":
+        out = renderGeneral(sec, Math.abs(n), minus ? GENERAL_WIDTH - 1 : GENERAL_WIDTH);
+        break;
+      case "date":
+        out = minus ? null : renderDate(sec, Math.abs(n));
+        break;
+      default:
+        out = renderNumber(sec, Math.abs(n));
+    }
+    if (!out) return withColor({ text: OVERFLOW, numeric: true, overflow: true }, sec.color);
+    if (minus && sec.kind !== "text" && !out.zero) out.prepend("-");
+    return withColor({ text: out.text, numeric: true, overflow: false, ...out.fill ? { fill: out.fill } : {} }, sec.color);
+  }
+  /** Formats text through the text section (`@`), or returns it unchanged. */
+  formatText(text) {
+    const sec = this.textSection === void 0 ? void 0 : this.sections[this.textSection];
+    if (!sec) return { text, numeric: false };
+    const out = renderText(sec, text);
+    return withColor({ text: out.text, numeric: false, ...out.fill ? { fill: out.fill } : {} }, sec.color);
+  }
+  /**
+   * Formats a cell value: numbers through the number sections, ISO date text
+   * (`2026-03-04`, `2026-03-04 18:00:00`) and `Date`s as serial numbers, other
+   * text through the text section; booleans show TRUE/FALSE and error values
+   * themselves.
+   */
+  format(value) {
+    if (value === "" || value === null || value === void 0) return { text: "", numeric: false };
+    if (typeof value === "boolean") return { text: value ? "TRUE" : "FALSE", numeric: false };
+    if (typeof value === "number") {
+      const { overflow: _overflow, ...rest } = this.formatNumber(value);
+      return rest;
+    }
+    if (typeof value === "string" && FORMULA_ERRORS.has(value)) return { text: value, numeric: false };
+    const serial = dateValueToSerial(value);
+    if (serial !== null) {
+      const { overflow: _overflow, ...rest } = this.formatNumber(serial);
+      return rest;
+    }
+    return this.formatText(String(value));
+  }
+};
+function withColor(value, color) {
+  if (color) value.color = color;
+  return value;
+}
+var CACHE_CAPACITY = 64;
+var CACHE_MAX_CODE_LENGTH = 256;
+var parseCache = /* @__PURE__ */ new Map();
+function clearNumberFormatCache() {
+  parseCache.clear();
+}
+var ISO_DATE_TIME = /^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{2})(?::(\d{2}(?:\.\d+)?))?)?$/;
+function dateValueToSerial(value) {
+  if (value instanceof Date) {
+    if (isNaN(value.getTime())) return null;
+    const serial2 = serialFromYmd(value.getFullYear(), value.getMonth() + 1, value.getDate());
+    return serial2 === null ? null : serial2 + timeFraction(value.getHours(), value.getMinutes(), value.getSeconds() + value.getMilliseconds() / 1e3);
+  }
+  if (typeof value !== "string" || value.length < 8 || value.length > 30) return null;
+  const m = ISO_DATE_TIME.exec(value.trim());
+  if (!m) return null;
+  const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  if (mo < 1 || mo > 12 || d < 1 || d > daysInMonth(y, mo)) return null;
+  const serial = serialFromYmd(y, mo, d);
+  if (serial === null) return null;
+  if (m[4] === void 0) return serial;
+  const [hh, mm, ss] = [Number(m[4]), Number(m[5]), Number(m[6] ?? 0)];
+  if (hh > 23 || mm > 59 || ss >= 60) return null;
+  return serial + timeFraction(hh, mm, ss);
+}
+function formatNumberFormatValue(value, code) {
+  return NumberFormat.parseCached(code).format(value);
+}
+function formatTextFunction(value, code) {
+  if (typeof value === "string" && FORMULA_ERRORS.has(value)) return { error: value };
+  if (code === "") return { text: "" };
+  if (tooLong(code)) return { error: "#VALUE!" };
+  const fmt = NumberFormat.parseCached(code);
+  let n;
+  if (value === "" || value === null || value === void 0) n = 0;
+  else if (typeof value === "number") n = value;
+  else if (typeof value === "boolean") return { text: fmt.formatText(value ? "TRUE" : "FALSE").text };
+  else {
+    const serial = dateValueToSerial(value);
+    const parsed = serial ?? (typeof value === "string" ? parseNumberText(value) : null);
+    if (parsed === null) return { text: fmt.formatText(String(value)).text };
+    n = parsed;
+  }
+  if (!Number.isFinite(n)) return { error: "#NUM!" };
+  const f = fmt.formatNumber(n);
+  return f.overflow ? { error: "#VALUE!" } : { text: f.text };
+}
+var INDEXED_COLORS = [
+  "#000000",
+  "#FFFFFF",
+  "#FF0000",
+  "#00FF00",
+  "#0000FF",
+  "#FFFF00",
+  "#FF00FF",
+  "#00FFFF",
+  "#800000",
+  "#008000",
+  "#000080",
+  "#808000",
+  "#800080",
+  "#008080",
+  "#C0C0C0",
+  "#808080",
+  "#9999FF",
+  "#993366",
+  "#FFFFCC",
+  "#CCFFFF",
+  "#660066",
+  "#FF8080",
+  "#0066CC",
+  "#CCCCFF",
+  "#000080",
+  "#FF00FF",
+  "#FFFF00",
+  "#00FFFF",
+  "#800080",
+  "#800000",
+  "#008080",
+  "#0000FF",
+  "#00CCFF",
+  "#CCFFFF",
+  "#CCFFCC",
+  "#FFFF99",
+  "#99CCFF",
+  "#FF99CC",
+  "#CC99FF",
+  "#FFCC99",
+  "#3366FF",
+  "#33CCCC",
+  "#99CC00",
+  "#FFCC00",
+  "#FF9900",
+  "#FF6600",
+  "#666699",
+  "#969696",
+  "#003366",
+  "#339966",
+  "#003300",
+  "#333300",
+  "#993300",
+  "#993366",
+  "#333399",
+  "#333333"
+];
+var NAMED_CSS = {
+  black: "#000000",
+  blue: "#0000FF",
+  cyan: "#00FFFF",
+  green: "#00FF00",
+  magenta: "#FF00FF",
+  red: "#FF0000",
+  white: "#FFFFFF",
+  yellow: "#FFFF00"
+};
+function numberFormatColorToCss(color) {
+  const named = NAMED_CSS[color];
+  if (named) return named;
+  return INDEXED_COLORS[Number(color.slice(5)) - 1] ?? "#000000";
 }
 
 // src/spreadsheet/formula/functions/helpers.ts
@@ -2197,15 +3446,19 @@ var TEXT_FUNCTIONS = [
   {
     name: "TEXT",
     category: "text",
-    description: 'Formats a number or date as text using a format code such as "0.00", "#,##0", "0%" or "yyyy-mm-dd".',
+    description: 'Formats a number or date as text using an Excel format code such as "0.00", "#,##0", "0%", "# ?/?" or "yyyy-mm-dd".',
     args: [arg("value", "The number or date to format."), arg("format_text", "The format code.", "text")],
     evaluate: (ctx) => {
       const value = ctx.scalar(0);
       if (isFormulaError(value)) return value;
       const format = ctx.text(1);
       if (failed(format)) return format;
-      const result = formatValueWithCode(value, format);
-      return result ?? ctx.argError(0, "#VALUE!", `isn't a date, so it can't use the format "${format}".`);
+      const result = formatTextFunction(value, format);
+      if ("text" in result) return result.text;
+      if (result.error === "#VALUE!") {
+        return Array.from(format).length > 255 ? ctx.argError(1, "#VALUE!", "is longer than 255 characters.") : ctx.argError(0, "#VALUE!", `is outside the date range, so it can't use the format "${format}".`);
+      }
+      return result.error;
     }
   }
 ];
@@ -2270,15 +3523,15 @@ function tableLookup(ctx, vertical) {
   if (failed(table)) return table;
   const index = ctx.integer(2);
   if (failed(index)) return index;
-  const approximate = ctx.boolean(3, true);
-  if (failed(approximate)) return approximate;
+  const approximate2 = ctx.boolean(3, true);
+  if (failed(approximate2)) return approximate2;
   const span = vertical ? table.cols : table.rows;
   if (index < 1) return ctx.argError(2, "#VALUE!", "must be 1 or more.");
   if (index > span) {
     return ctx.argError(2, "#REF!", `is larger than the number of ${vertical ? "columns" : "rows"} in the table (${span}).`);
   }
   const keys = vertical ? sliceRange(table, 0, table.rows, 0, 1) : sliceRange(table, 0, 1, 0, table.cols);
-  const position = lookupIndex(keys, target, approximate ? "sorted-asc" : "wildcard");
+  const position = lookupIndex(keys, target, approximate2 ? "sorted-asc" : "wildcard");
   if (position === -1) return notFound(ctx, target);
   return vertical ? rangeGet(table, position, index - 1) : rangeGet(table, index - 1, position);
 }
@@ -2984,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,
@@ -2994,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;
@@ -3044,17 +4380,17 @@ function layoutOf(def) {
   return { fixed: def.args.slice(0, groupStart), group: def.args.slice(groupStart), groupStart };
 }
 function getFormulaArgumentSpecIndex(def, argIndex) {
-  const { fixed, group, groupStart } = layoutOf(def);
-  if (argIndex < fixed.length) return argIndex;
+  const { fixed: fixed2, group, groupStart } = layoutOf(def);
+  if (argIndex < fixed2.length) return argIndex;
   if (group.length === 0) return -1;
   return groupStart + (argIndex - groupStart) % group.length;
 }
 function checkFormulaArgumentCount(def, count) {
-  const { fixed, group } = layoutOf(def);
-  const requiredFixed = fixed.filter((arg2) => !arg2.optional).length;
+  const { fixed: fixed2, group } = layoutOf(def);
+  const requiredFixed = fixed2.filter((arg2) => !arg2.optional).length;
   const groupRequired = group.length > 0 && !group[0].optional;
   const min2 = requiredFixed + (groupRequired ? group.length : 0);
-  const max2 = group.length > 0 ? Infinity : fixed.length;
+  const max2 = group.length > 0 ? Infinity : fixed2.length;
   const given = `${count} ${count === 1 ? "was" : "were"} given`;
   const plural = (n) => `${n} argument${n === 1 ? "" : "s"}`;
   if (count < min2) {
@@ -3065,8 +4401,8 @@ function checkFormulaArgumentCount(def, count) {
     const expected = min2 === max2 ? plural(max2) : `at most ${plural(max2)}`;
     return max2 === 0 ? `${def.name} takes no arguments, but ${given}.` : `${def.name} takes ${expected}, but ${given}.`;
   }
-  if (group.length > 1 && count > fixed.length) {
-    const extra = (count - fixed.length) % group.length;
+  if (group.length > 1 && count > fixed2.length) {
+    const extra = (count - fixed2.length) % group.length;
     if (extra !== 0 && !(def.allowTrailingArgument && extra === 1)) {
       const names = group.map((arg2) => arg2.name).join(", ");
       return `${def.name} expects its repeating arguments (${names}) in complete groups.`;
@@ -3077,7 +4413,7 @@ function checkFormulaArgumentCount(def, count) {
 function getFormulaSignatureParts(nameOrDef, activeArgIndex) {
   const def = typeof nameOrDef === "string" ? getFormulaFunction(nameOrDef) : nameOrDef;
   if (!def) return [];
-  const { fixed, group, groupStart } = layoutOf(def);
+  const { fixed: fixed2, group, groupStart } = layoutOf(def);
   let activeSpec = -1;
   let activeRepeat = 0;
   if (activeArgIndex !== void 0 && activeArgIndex !== null && activeArgIndex >= 0) {
@@ -3091,7 +4427,7 @@ function getFormulaSignatureParts(nameOrDef, activeArgIndex) {
     if (parts.length > 1) parts.push({ text: ", ", specIndex: null, active: false });
     parts.push({ text, specIndex, active: specIndex === activeSpec && repeat === activeRepeat });
   };
-  fixed.forEach((arg2, i) => pushArg(arg2.optional ? `[${arg2.name}]` : arg2.name, i));
+  fixed2.forEach((arg2, i) => pushArg(arg2.optional ? `[${arg2.name}]` : arg2.name, i));
   if (group.length > 0) {
     const groupOptional = !!group[0].optional;
     group.forEach((arg2, i) => {
@@ -3151,11 +4487,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;
   }
@@ -3165,7 +4520,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
@@ -3175,9 +4537,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;
@@ -3198,10 +4566,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. */
@@ -3219,11 +4593,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;
@@ -3232,11 +4611,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) {
@@ -3258,6 +4641,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);
@@ -3285,6 +4671,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)}).`);
@@ -3399,7 +4786,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(
@@ -3416,8 +4806,14 @@ var FormulaEvaluator = class {
     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 values = this.context.resolveRange(node.startCol, node.startRow, node.endCol, node.endRow, node.sheet ?? this.defaultSheet);
+    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);
@@ -3425,11 +4821,28 @@ 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);
+    if (SPECIAL_FORMS.has(def.name)) return this.evaluateSpecialForm(def.name, node);
     const args = this.lazyArguments(node.args);
     if (def.elementwise) {
       const lifted = this.liftOverArrays(def, args);
@@ -3482,25 +4895,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;
@@ -3590,11 +5297,17 @@ export {
   parseRange,
   FormulaParser,
   parseFormula,
+  FormulaLambda,
+  isFormulaLambda,
+  MAX_LAMBDA_DEPTH,
   serialFromYmd,
   parseCellInput,
   parseNumberText,
   FORMULA_ERRORS,
   isFormulaError,
+  isBlank,
+  toBoolean,
+  toText,
   numberToText,
   numericValue,
   compareNumbers,
@@ -3603,10 +5316,19 @@ export {
   colNameToIndex,
   indexToColName,
   parseIsoDate,
+  serialToDate,
   wildcardToRegExp,
   parseCriteria,
-  formatCellDisplay,
-  formatValueWithCode,
+  formatGeneralFit,
+  builtinNumberFormat,
+  builtinNumberFormatId,
+  MAX_NUMBER_FORMAT_CODE_CHARS,
+  NumberFormat,
+  clearNumberFormatCache,
+  dateValueToSerial,
+  formatNumberFormatValue,
+  formatTextFunction,
+  numberFormatColorToCss,
   registerFormulaFunction,
   unregisterFormulaFunction,
   getFormulaFunction,
@@ -3620,4 +5342,4 @@ export {
   MAX_FORMULA_ARRAY_SIZE,
   FormulaEvaluator
 };
-//# sourceMappingURL=chunk-QBJ22YZR.js.map
+//# sourceMappingURL=chunk-FH6F67DN.js.map