@pixerate/editor 0.23.0 → 0.24.0

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

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;// src/spreadsheet/formula/lexer.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// src/spreadsheet/formula/lexer.ts
 function tokenizeFormula(formula) {
   const tokens = [];
   let input = formula.trim();
@@ -982,209 +982,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 = _nullishCoalesce(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 && (_nullishCoalesce(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 ((_nullishCoalesce(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 _optionalChain([BUILTINS, 'access', _5 => _5.find, 'call', _6 => _6(([i]) => i === id), 'optionalAccess', _7 => _7[1]]);
+}
+function builtinNumberFormatId(code) {
+  const exact = BUILTINS.find(([, c]) => c === code);
+  if (exact) return exact[0];
+  const norm = (s) => s.replace(/\\/g, "").toLowerCase();
+  const n = norm(code);
+  return _optionalChain([BUILTINS, 'access', _8 => _8.find, 'call', _9 => _9(([, c]) => norm(c) === n), 'optionalAccess', _10 => _10[0]]);
+}
+
+// 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) => _optionalChain([t, 'optionalAccess', _11 => _11.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 (_optionalChain([last, 'optionalAccess', _12 => _12.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;
     }
-    for (let i = 0; i < token.text.length; i++) {
-      const char = token.text[i];
-      const isExponent = /e/i.test(char) && /[+-]/.test(_nullishCoalesce(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 === "_") {
+      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;
+    }
+    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 = (_nullishCoalesce(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 = (_nullishCoalesce(decPattern.match(/[0#?]/g), () => ( []))).length;
-  const minDecimals = (_nullishCoalesce(decPattern.match(/0/g), () => ( []))).length;
-  const minInt = (_nullishCoalesce(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 (char === ";" && !quoted) sections.push("");
-    else sections[sections.length - 1] += char;
+    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: _nullishCoalesce(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);
+    }
+    i += 1;
   }
-  return sections;
+  return raw;
 }
+var datePartOf = (t) => _optionalChain([t, 'optionalAccess', _13 => _13.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 = _optionalChain([prev, 'optionalAccess', _14 => _14.k]) === "hour" || _optionalChain([prev, 'optionalAccess', _15 => _15.k]) === "eh";
+      const beforeS = _optionalChain([nxt, 'optionalAccess', _16 => _16.k]) === "second" || _optionalChain([nxt, 'optionalAccess', _17 => _17.k]) === "es";
+      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 = _optionalChain([toks, 'access', _18 => _18[i + 1], 'optionalAccess', _19 => _19.t]) === "denom" || _optionalChain([firstNonLitAfter, 'access', _20 => _20[i], 'optionalAccess', _21 => _21.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 (!(_optionalChain([toks, 'access', _22 => _22[i - 1], 'optionalAccess', _23 => _23.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 = (_class2 = class {constructor() { _class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this); }
+  __init3() {this.text = ""}
+  
+  /** True when every digit shown is zero (a number section that rounded to zero). */
+  __init4() {this.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;
+  }
+}, _class2);
+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(_nullishCoalesce(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 = _nullishCoalesce(MONTHS[dt.month - 1], () => ( ""));
+  const dayName = _nullishCoalesce(WEEKDAYS[dt.weekday], () => ( ""));
+  const out = new Out();
+  for (const t of sec.toks) {
+    if (t.t === "fill") {
+      out.setFill(t.c);
       continue;
     }
-    const re = /AM\/PM|am\/pm|A\/P|a\/p|y+|m+|d+|h+|s+|[^ymdhsaA]+|./gi;
-    for (const match of _nullishCoalesce(token.text.match(re), () => ( []))) {
-      const isCode = /^(AM\/PM|A\/P|y+|m+|d+|h+|s+)$/i.test(match);
-      parts.push({ literal: !isCode, text: match });
+    if (t.t !== "date") {
+      out.push(literalText(t));
+      continue;
     }
+    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);
   }
-  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());
+  return out;
+}
+var digitChar = (toks, i) => {
+  const t = toks[i];
+  return _optionalChain([t, 'optionalAccess', _24 => _24.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(_nullishCoalesce(digits[rem], () => ( "0")));
+      }
     }
-    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());
+    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;
     }
-    if (lower.startsWith("h")) {
-      let hours = date.getHours();
-      if (twelveHour) hours = hours % 12 || 12;
-      return lower.length >= 2 ? pad3(hours) : String(hours);
+  }
+  idxs.forEach((ti, i) => {
+    const ph = digitChar(toks, ti);
+    pieces[ti] = i <= lastSig ? _nullishCoalesce(frac[i], () => ( "0")) : ph === "0" ? "0" : ph === "?" ? " " : "";
+  });
+}
+function digitIndices(toks, start, end) {
+  const out = [];
+  for (let i = start; i < end; i++) if (_optionalChain([toks, 'access', _25 => _25[i], 'optionalAccess', _26 => _26.t]) === "digit") out.push(i);
+  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 = _nullishCoalesce(_nullishCoalesce(point, () => ( exp)), () => ( n));
+    const fracEnd = _nullishCoalesce(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 = _nullishCoalesce(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(_nullishCoalesce(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) => _optionalChain([toks, 'access', _27 => _27[i], 'optionalAccess', _28 => _28.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 (lower.startsWith("s")) {
-      return lower.length >= 2 ? pad3(date.getSeconds()) : String(date.getSeconds());
+  }
+  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 (_optionalChain([afterSlash, 'optionalAccess', _29 => _29.t]) === "denom") {
+    const parsed = Number(afterSlash.s);
+    fixedDen = Math.min(Math.max(Number.isFinite(parsed) ? parsed : 1e9, 1), 1e9);
+    denStart = slash + 1;
+  } else {
+    denStart = slash + 1;
+    while (_optionalChain([toks, 'access', _30 => _30[denStart], 'optionalAccess', _31 => _31.t]) === "lit") denStart += 1;
+  }
+  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(_nullishCoalesce(pieces[i], () => ( ""))));
+    if (!wholeShown) {
+      const spaces = hasQ(wholeIdx) || hasQ(numIdx);
+      blankRange(toks, sepStart, numStart, spaces, pieces, lits);
     }
-    const position = codes.findIndex((c) => c.i === index);
-    const prev = _nullishCoalesce(_optionalChain([codes, 'access', _5 => _5[position - 1], 'optionalAccess', _6 => _6.text, 'access', _7 => _7.toLowerCase, 'call', _8 => _8()]), () => ( ""));
-    const next = _nullishCoalesce(_optionalChain([codes, 'access', _9 => _9[position + 1], 'optionalAccess', _10 => _10.text, 'access', _11 => _11.toLowerCase, 'call', _12 => _12()]), () => ( ""));
-    if (lower.length <= 2 && (prev.startsWith("h") || next.startsWith("s"))) {
-      return lower.length === 2 ? pad3(date.getMinutes()) : String(date.getMinutes());
+  }
+  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) : _nullishCoalesce(padded[k], () => ( ""));
+      if (s === "") s = isDigitTok2(toks[ti], "?") ? " " : isDigitTok2(toks[ti], "0") ? "0" : "";
+      pieces[ti] = s;
+    });
+  }
+}
+function isDigitTok2(t, c) {
+  return _optionalChain([t, 'optionalAccess', _32 => _32.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 {
+  
+  
+  
+  /** Sections that apply to numbers (a trailing text section is excluded). */
+  
+  /** Index of the section that applies to text, if any. */
+  
+  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 = _optionalChain([this, 'access', _33 => _33.sections, 'access', _34 => _34[len - 1], 'optionalAccess', _35 => _35.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 = _optionalChain([secs, 'access', _36 => _36[1], 'optionalAccess', _37 => _37.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: _nullishCoalesce(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, _nullishCoalesce(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 (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("");
+    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(_nullishCoalesce(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 = _nullishCoalesce(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 _nullishCoalesce(INDEXED_COLORS[Number(color.slice(5)) - 1], () => ( "#000000"));
 }
 
 // src/spreadsheet/formula/functions/helpers.ts
@@ -2197,15 +3331,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 _nullishCoalesce(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 +3408,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);
 }
@@ -3044,17 +4182,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 +4203,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 +4215,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 +4229,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,12 +4289,12 @@ 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 FormulaEvaluator = (_class2 = class {
+var FormulaEvaluator = (_class3 = class {
   
-  __init3() {this.diagnostics = []}
+  __init5() {this.diagnostics = []}
   // LET variables, innermost scope last.
-  __init4() {this.scopes = []}
-  constructor(context = {}) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
+  __init6() {this.scopes = []}
+  constructor(context = {}) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);
     this.context = context;
   }
   /**
@@ -3191,14 +4329,14 @@ var FormulaEvaluator = (_class2 = class {
         const result = {
           value,
           error: code,
-          message: _nullishCoalesce(_optionalChain([diagnostic, 'optionalAccess', _13 => _13.message]), () => ( describeFormulaError(code)))
+          message: _nullishCoalesce(_optionalChain([diagnostic, 'optionalAccess', _38 => _38.message]), () => ( describeFormulaError(code)))
         };
         if (array) result.array = array;
         return result;
       }
       return array ? { value, array } : { value };
     } catch (err) {
-      return { value: "#ERROR!", error: "#ERROR!", message: _optionalChain([err, 'optionalAccess', _14 => _14.message]) || "Formula error" };
+      return { value: "#ERROR!", error: "#ERROR!", message: _optionalChain([err, 'optionalAccess', _39 => _39.message]) || "Formula error" };
     } finally {
       this.diagnostics = saved;
       this.scopes = savedScopes;
@@ -3379,7 +4517,7 @@ var FormulaEvaluator = (_class2 = class {
     const value = this.evaluateNode(argument);
     if (!Array.isArray(value)) return value;
     if (value.length <= 1) return firstValue(value);
-    const cell = _optionalChain([this, 'access', _15 => _15.context, 'access', _16 => _16.getFormulaCell, 'optionalCall', _17 => _17()]);
+    const cell = _optionalChain([this, 'access', _40 => _40.context, 'access', _41 => _41.getFormulaCell, 'optionalCall', _42 => _42()]);
     if (argument.type === "Range" && cell) {
       const range = toFormulaRange(value);
       const top = Math.min(argument.startRow, argument.endRow);
@@ -3461,7 +4599,7 @@ var FormulaEvaluator = (_class2 = class {
    * multi-value array.
    */
   liftOverArrays(def, args) {
-    const liftable = (index) => _optionalChain([def, 'access', _18 => _18.args, 'access', _19 => _19[getFormulaArgumentSpecIndex(def, index)], 'optionalAccess', _20 => _20.type]) !== "range";
+    const liftable = (index) => _optionalChain([def, 'access', _43 => _43.args, 'access', _44 => _44[getFormulaArgumentSpecIndex(def, index)], 'optionalAccess', _45 => _45.type]) !== "range";
     const triggers = def.elementwise === true ? args.map((a) => a.index) : def.elementwise;
     if (!triggers.some((i) => i < args.length && liftable(i) && isMultiArray(args[i].value()))) return void 0;
     let rows = 1;
@@ -3581,7 +4719,17 @@ var FormulaEvaluator = (_class2 = class {
       }
     };
   }
-}, _class2);
+}, _class3);
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -3619,5 +4767,5 @@ var FormulaEvaluator = (_class2 = class {
 
 
 
-exports.tokenizeFormula = tokenizeFormula; exports.WHOLE_COLUMN_END_ROW = WHOLE_COLUMN_END_ROW; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.serialFromYmd = serialFromYmd; exports.parseCellInput = parseCellInput; exports.parseNumberText = parseNumberText; exports.FORMULA_ERRORS = FORMULA_ERRORS; exports.isFormulaError = isFormulaError; exports.numberToText = numberToText; exports.numericValue = numericValue; exports.compareNumbers = compareNumbers; exports.compareValues = compareValues; exports.sortCompareValues = sortCompareValues; exports.colNameToIndex = colNameToIndex; exports.indexToColName = indexToColName; exports.parseIsoDate = parseIsoDate; exports.wildcardToRegExp = wildcardToRegExp; exports.parseCriteria = parseCriteria; exports.formatCellDisplay = formatCellDisplay; exports.formatValueWithCode = formatValueWithCode; exports.registerFormulaFunction = registerFormulaFunction; exports.unregisterFormulaFunction = unregisterFormulaFunction; exports.getFormulaFunction = getFormulaFunction; exports.listFormulaFunctions = listFormulaFunctions; exports.searchFormulaFunctions = searchFormulaFunctions; exports.getFormulaArgumentSpecIndex = getFormulaArgumentSpecIndex; exports.checkFormulaArgumentCount = checkFormulaArgumentCount; exports.getFormulaSignatureParts = getFormulaSignatureParts; exports.getFormulaSignature = getFormulaSignature; exports.describeFormulaError = describeFormulaError; exports.MAX_FORMULA_ARRAY_SIZE = MAX_FORMULA_ARRAY_SIZE; exports.FormulaEvaluator = FormulaEvaluator;
-//# sourceMappingURL=chunk-RIKBJLS2.cjs.map
+exports.tokenizeFormula = tokenizeFormula; exports.WHOLE_COLUMN_END_ROW = WHOLE_COLUMN_END_ROW; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.serialFromYmd = serialFromYmd; exports.parseCellInput = parseCellInput; exports.parseNumberText = parseNumberText; exports.FORMULA_ERRORS = FORMULA_ERRORS; exports.isFormulaError = isFormulaError; exports.isBlank = isBlank; exports.toText = toText; exports.numberToText = numberToText; exports.numericValue = numericValue; exports.compareNumbers = compareNumbers; exports.compareValues = compareValues; exports.sortCompareValues = sortCompareValues; exports.colNameToIndex = colNameToIndex; exports.indexToColName = indexToColName; exports.parseIsoDate = parseIsoDate; exports.wildcardToRegExp = wildcardToRegExp; exports.parseCriteria = parseCriteria; exports.formatGeneralFit = formatGeneralFit; exports.builtinNumberFormat = builtinNumberFormat; exports.builtinNumberFormatId = builtinNumberFormatId; exports.MAX_NUMBER_FORMAT_CODE_CHARS = MAX_NUMBER_FORMAT_CODE_CHARS; exports.NumberFormat = NumberFormat; exports.clearNumberFormatCache = clearNumberFormatCache; exports.dateValueToSerial = dateValueToSerial; exports.formatNumberFormatValue = formatNumberFormatValue; exports.formatTextFunction = formatTextFunction; exports.numberFormatColorToCss = numberFormatColorToCss; exports.registerFormulaFunction = registerFormulaFunction; exports.unregisterFormulaFunction = unregisterFormulaFunction; exports.getFormulaFunction = getFormulaFunction; exports.listFormulaFunctions = listFormulaFunctions; exports.searchFormulaFunctions = searchFormulaFunctions; exports.getFormulaArgumentSpecIndex = getFormulaArgumentSpecIndex; exports.checkFormulaArgumentCount = checkFormulaArgumentCount; exports.getFormulaSignatureParts = getFormulaSignatureParts; exports.getFormulaSignature = getFormulaSignature; exports.describeFormulaError = describeFormulaError; exports.MAX_FORMULA_ARRAY_SIZE = MAX_FORMULA_ARRAY_SIZE; exports.FormulaEvaluator = FormulaEvaluator;
+//# sourceMappingURL=chunk-MCSJFWAO.cjs.map