@pixerate/editor 0.22.0 → 0.24.0

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

@@ -414,9 +414,7 @@ function toNumber(value) {
   if (isBlank(value)) return 0;
   if (typeof value === "boolean") return value ? 1 : 0;
   if (typeof value === "number") return value;
-  const trimmed = String(value).trim();
-  const num = trimmed === "" ? NaN : Number(trimmed);
-  return isNaN(num) ? "#VALUE!" : num;
+  return parseNumberText(String(value)) ?? "#VALUE!";
 }
 function toBoolean(value) {
   if (isFormulaError(value)) return value;
@@ -428,7 +426,26 @@ function toBoolean(value) {
   if (upper === "FALSE") return false;
   return "#VALUE!";
 }
-var toText = (value) => isBlank(value) ? "" : typeof value === "boolean" ? value ? "TRUE" : "FALSE" : String(value);
+var toText = (value) => isBlank(value) ? "" : typeof value === "boolean" ? value ? "TRUE" : "FALSE" : typeof value === "number" ? numberToText(value) : String(value);
+function numberToText(n) {
+  if (n === 0 || !Number.isFinite(n)) return "0";
+  const a = Math.abs(n);
+  if ((a < 1e-9 || a >= 1e15) && Math.round(a) !== a || a >= 1e15) return sciText(n, 15);
+  let mag = Math.floor(Math.log10(a));
+  if (a >= Math.pow(10, mag + 1)) mag++;
+  const decimals = Math.min(Math.max(14 - mag, 0), 30);
+  return trimDecimal(n.toFixed(decimals));
+}
+function trimDecimal(s) {
+  if (!s.includes(".")) return s;
+  const t = s.replace(/0+$/, "").replace(/\.$/, "");
+  return t === "-0" ? "0" : t;
+}
+function sciText(n, sig) {
+  const [mantissa, exp] = n.toExponential(Math.max(sig - 1, 0)).split("e");
+  const e = Number(exp);
+  return `${trimDecimal(mantissa)}E${e < 0 ? "-" : "+"}${String(Math.abs(e)).padStart(2, "0")}`;
+}
 function numericValue(value) {
   if (typeof value === "number") return Number.isFinite(value) ? value : null;
   if (typeof value !== "string" || FORMULA_ERRORS.has(value)) return null;
@@ -441,22 +458,68 @@ function normalizeValue(value) {
   const num = typeof value === "string" ? numericValue(value) : null;
   return num === null ? value : num;
 }
+var ERROR_ORDER = ["#NULL!", "#DIV/0!", "#VALUE!", "#REF!", "#NAME?", "#NUM!", "#N/A", "#SPILL!", "#CALC!", "#CYCLE!", "#ERROR!"];
+function valueRank(value) {
+  if (isBlank(value)) return 4;
+  if (typeof value === "number") return 0;
+  if (typeof value === "boolean") return 2;
+  if (typeof value === "string" && FORMULA_ERRORS.has(value)) return 3;
+  return 1;
+}
+function compareNumbers(a, b) {
+  if (a === b) return 0;
+  if (Math.abs(a - b) > Math.max(Math.abs(a), Math.abs(b)) * 1e-13) return a < b ? -1 : 1;
+  const round15 = (x2) => !Number.isFinite(x2) || x2 === 0 ? x2 : Number(x2.toExponential(14));
+  const x = round15(a);
+  const y = round15(b);
+  return x < y ? -1 : x > y ? 1 : 0;
+}
+function compareText(a, b) {
+  const x = a.toLowerCase();
+  const y = b.toLowerCase();
+  return x < y ? -1 : x > y ? 1 : 0;
+}
 function compareValues(left, right) {
-  if (typeof left === "string" && typeof right === "string") {
-    const a = isoDateTime(left);
-    const b = a === null ? null : isoDateTime(right);
-    if (a !== null && b !== null) return a - b;
-  }
-  const rank = (v) => typeof v === "boolean" ? 2 : typeof v === "string" ? 1 : 0;
-  const l = isBlank(left) ? typeof right === "string" ? "" : 0 : left;
-  const r = isBlank(right) ? typeof l === "string" ? "" : 0 : right;
-  if (rank(l) !== rank(r)) return rank(l) - rank(r);
-  if (typeof l === "string") {
-    const a = l.toLowerCase();
-    const b = r.toLowerCase();
-    return a < b ? -1 : a > b ? 1 : 0;
-  }
-  return Number(l) - Number(r);
+  const lRank = valueRank(left);
+  const rRank = valueRank(right);
+  if (lRank === 4 || rRank === 4) {
+    if (lRank === rRank) return 0;
+    const blankFirst = lRank === 4;
+    const other = blankFirst ? right : left;
+    const otherRank = blankFirst ? rRank : lRank;
+    let cmp;
+    if (otherRank === 0) cmp = compareNumbers(0, other);
+    else if (otherRank === 1) cmp = String(other) === "" ? 0 : -1;
+    else if (otherRank === 2) cmp = other ? -1 : 0;
+    else return lRank - rRank;
+    return blankFirst ? cmp : -cmp;
+  }
+  if (lRank === 1 && rRank === 1) {
+    const a = String(left);
+    const b = String(right);
+    const ta = isoDateTime(a);
+    const tb = ta === null ? null : isoDateTime(b);
+    if (ta !== null && tb !== null) return Math.sign(ta - tb);
+    return compareText(a, b);
+  }
+  if (lRank === 0 && rRank === 1 || lRank === 1 && rRank === 0) {
+    const date = parseIsoDate(lRank === 1 ? left : right);
+    if (date) {
+      const serial = dateToSerial(date);
+      return lRank === 0 ? compareNumbers(left, serial) : compareNumbers(serial, right);
+    }
+  }
+  if (lRank !== rRank) return lRank - rRank;
+  if (lRank === 0) return compareNumbers(left, right);
+  if (lRank === 2) return Number(left) - Number(right);
+  return Math.sign(ERROR_ORDER.indexOf(left) - ERROR_ORDER.indexOf(right));
+}
+function sortCompareValues(left, right) {
+  const lBlank = isBlank(left);
+  const rBlank = isBlank(right);
+  if (lBlank || rBlank) return lBlank === rBlank ? 0 : lBlank ? 1 : -1;
+  if (isFormulaError(left) && isFormulaError(right)) return 0;
+  return compareValues(left, right);
 }
 function roundHalfAwayFromZero(value, decimals) {
   const factor = Math.pow(10, decimals);
@@ -565,6 +628,282 @@ var daysBetween = (start, end) => Math.round(
   (Date.UTC(end.getFullYear(), end.getMonth(), end.getDate()) - Date.UTC(start.getFullYear(), start.getMonth(), start.getDate())) / MS_PER_DAY
 );
 
+// src/spreadsheet/formula/parse-input.ts
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function daysFromCivil(year, month, day) {
+  const y = month <= 2 ? year - 1 : year;
+  const era = Math.floor((y >= 0 ? y : y - 399) / 400);
+  const yoe = y - era * 400;
+  const doy = Math.floor((153 * (month > 2 ? month - 3 : month + 9) + 2) / 5) + day - 1;
+  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+  return era * 146097 + doe - 719468;
+}
+var isLeapYear = (y) => y % 4 === 0 && y % 100 !== 0 || y % 400 === 0;
+function daysInMonth(year, month) {
+  if (month === 2) return isLeapYear(year) ? 29 : 28;
+  if ([4, 6, 9, 11].includes(month)) return 30;
+  return month >= 1 && month <= 12 ? 31 : 0;
+}
+var daysInMonth1900 = (year, month) => year === 1900 && month === 2 ? 29 : daysInMonth(year, month);
+var UNIX_1899_12_30 = -25569;
+var MAX_SERIAL_1900 = 2958465;
+function serialFromYmd(year, month, day) {
+  if (![year, month, day].every(Number.isSafeInteger)) return null;
+  let y = year >= 0 && year < 1900 ? year + 1900 : year;
+  const m0 = month - 1;
+  y += Math.floor(m0 / 12);
+  const m = (m0 % 12 + 12) % 12 + 1;
+  if (y < 1900 || y > 9999) return null;
+  const first = daysFromCivil(y, m, 1) - UNIX_1899_12_30 - (y === 1900 && m <= 2 ? 1 : 0);
+  const serial = first + day - 1;
+  return serial >= 0 && serial <= MAX_SERIAL_1900 ? serial : null;
+}
+var timeFraction = (h, m, s) => (h * 3600 + m * 60 + s) / 86400;
+var currentYear = () => (/* @__PURE__ */ new Date()).getFullYear();
+function parseCellInput(input) {
+  if (input === "") return { value: "", type: "empty" };
+  if (input.startsWith("'")) return { value: input.slice(1), type: "text" };
+  const t = input.trim();
+  const upper = t.toUpperCase();
+  if (upper === "TRUE") return { value: true, type: "boolean" };
+  if (upper === "FALSE") return { value: false, type: "boolean" };
+  if (FORMULA_ERRORS.has(upper)) return { value: upper, type: "error" };
+  const numeric = parseNumeric(t);
+  if (numeric) {
+    if (numeric.kind === "date") {
+      const iso = isoText(numeric.date);
+      if (iso !== null) {
+        return { value: iso, type: "date", numberFormat: numeric.format, formatKind: "date", cellFormat: "date" };
+      }
+    } else {
+      const formatKind = numeric.kind === "time" ? "time" : formatKindOf(numeric.format);
+      return {
+        value: normalizeZero(numeric.value),
+        type: "number",
+        ...numeric.format ? { numberFormat: numeric.format } : {},
+        ...formatKind ? { formatKind } : {},
+        ...formatKind && formatKind !== "time" ? { cellFormat: formatKind } : {}
+      };
+    }
+  }
+  return { value: input, type: "text" };
+}
+function parseNumberText(text) {
+  const numeric = parseNumeric(text.trim());
+  if (!numeric) return null;
+  if (numeric.kind !== "date") return normalizeZero(numeric.value);
+  const { year, month, day, time = 0 } = numeric.date;
+  const serial = serialFromYmd(year, month, day);
+  return serial === null ? null : serial + time;
+}
+var normalizeZero = (n) => n === 0 ? 0 : n;
+function formatKindOf(format) {
+  if (!format) return void 0;
+  if (format.includes("$")) return "currency";
+  if (format.includes("%")) return "percentage";
+  return "number";
+}
+var pad2 = (n, width = 2) => String(n).padStart(width, "0");
+function isoText({ year, month, day, time }) {
+  if (day > daysInMonth(year, month)) return null;
+  const date = `${pad2(year, 4)}-${pad2(month)}-${pad2(day)}`;
+  if (time === void 0) return date;
+  let seconds = Math.round(time * 86400);
+  if (seconds >= 86400) seconds = 86399;
+  return `${date} ${pad2(Math.floor(seconds / 3600))}:${pad2(Math.floor(seconds / 60) % 60)}:${pad2(seconds % 60)}`;
+}
+function parseNumeric(t) {
+  if (t === "") return null;
+  if (t.startsWith("(") && t.endsWith(")") && t.length >= 2) {
+    const inner = parseNumeric(t.slice(1, -1).trim());
+    if (!inner || inner.kind === "date") return null;
+    return { ...inner, value: -inner.value };
+  }
+  const plain = parsePlain(t);
+  if (plain) return plain;
+  const fraction = parseFraction(t);
+  if (fraction !== null) return { kind: "number", value: fraction, format: "# ?/?" };
+  return parseDateTime(t);
+}
+var startsWithDigitOrDot = (s) => /^[0-9.]/.test(s);
+function parsePlain(t) {
+  let s = t;
+  let neg = false;
+  let currency = false;
+  let percent = false;
+  if (s.startsWith("-")) {
+    neg = true;
+    s = s.slice(1).trimStart();
+  } else if (s.startsWith("+")) {
+    s = s.slice(1).trimStart();
+  }
+  if (s.startsWith("$")) {
+    currency = true;
+    s = s.slice(1).trimStart();
+    if (!neg && s.startsWith("-")) {
+      neg = true;
+      s = s.slice(1);
+    }
+  }
+  if (s.endsWith("%")) {
+    percent = true;
+    s = s.slice(0, -1).trimEnd();
+  }
+  if (s === "") return null;
+  const hasSep = s.includes(",");
+  let digits;
+  if (hasSep) {
+    const dot = s.indexOf(".");
+    const int = dot === -1 ? s : s.slice(0, dot);
+    const frac = dot === -1 ? null : s.slice(dot + 1);
+    const groups = int.split(",");
+    const first = groups[0];
+    if (first === "" || first.length > 3 || groups.slice(1).some((g) => g.length !== 3)) return null;
+    digits = groups.join("") + (frac !== null ? `.${frac}` : "");
+  } else {
+    digits = s;
+  }
+  if (!/^[0-9.eE+-]+$/.test(digits) || !startsWithDigitOrDot(digits)) return null;
+  if (!/^(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(digits)) return null;
+  let n = Number(digits);
+  if (!Number.isFinite(n)) return null;
+  const sci = /[eE]/.test(digits);
+  if (percent) n /= 100;
+  if (neg) n = -n;
+  const hasDot = digits.includes(".");
+  const format = currency ? hasDot ? '"$"#,##0.00' : '"$"#,##0' : percent ? hasDot ? "0.00%" : "0%" : sci ? "0.00E+00" : hasSep ? hasDot ? "#,##0.00" : "#,##0" : void 0;
+  return { kind: "number", value: n, ...format ? { format } : {} };
+}
+var parseDecimal = (s) => /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(s) ? Number(s) : null;
+function parseFraction(t) {
+  const space = t.indexOf(" ");
+  if (space === -1) return null;
+  const whole = t.slice(0, space);
+  const frac = t.slice(space + 1).trim();
+  const neg = whole.startsWith("-");
+  const w = parseDecimal(whole.replace(/^-+/, ""));
+  const slash = frac.indexOf("/");
+  if (w === null || slash === -1) return null;
+  const a = parseDecimal(frac.slice(0, slash));
+  const b = parseDecimal(frac.slice(slash + 1));
+  if (a === null || b === null || b === 0 || !Number.isFinite(w)) return null;
+  const v = w + a / b;
+  return neg ? -v : v;
+}
+function monthFromName(s) {
+  const l = s.toLowerCase();
+  if (l.length < 3) return null;
+  const index = MONTH_NAMES.findIndex((m) => m.toLowerCase().startsWith(l));
+  return index === -1 ? null : index + 1;
+}
+function parseTime(input) {
+  const lower = input.trim().toLowerCase();
+  let body = lower;
+  let pm = null;
+  for (const [suffix, isPm] of [["am", false], ["a", false], ["pm", true], ["p", true]]) {
+    if (lower.endsWith(suffix)) {
+      body = lower.slice(0, -suffix.length).trim();
+      pm = isPm;
+      break;
+    }
+  }
+  const parts = body.split(":");
+  if (parts.length === 1 && pm === null) return null;
+  if (parts.length > 3 || parts.some((p) => p === "")) return null;
+  const num = (p) => p === void 0 ? 0 : parseDecimal(p);
+  let h = num(parts[0]);
+  const m = num(parts[1]);
+  const s = num(parts[2]);
+  if (h === null || m === null || s === null) return null;
+  if (m >= 60 || s >= 60 || h < 0 || m < 0 || s < 0) return null;
+  if (pm !== null) {
+    if (h > 12) return null;
+    if (h === 12) h = 0;
+    if (pm) h += 12;
+  } else if (h >= 1e4) {
+    return null;
+  }
+  return { fraction: timeFraction(h, m, s), seconds: parts.length === 3, ampm: pm !== null };
+}
+var expandYear = (text, y) => text.length <= 2 ? y < 30 ? 2e3 + y : 1900 + y : y;
+function validYmd(year, month, day) {
+  if (month < 1 || month > 12 || day < 1 || year < 1900 || year > 9999) return null;
+  if (day > daysInMonth1900(year, month)) return null;
+  return { year, month, day };
+}
+function parseDate(input) {
+  const t = input.trim().replace(/,+$/, "");
+  const num = (s) => /^[+-]?\d+$/.test(s.trim()) ? Number(s.trim()) : null;
+  const withFormat = (date, format) => date ? { date, format } : null;
+  const parts = t.split(/[/.-]/);
+  if (parts.length === 3) {
+    const [a, b, c] = parts.map((p) => p.trim());
+    if (a.length === 4) {
+      const [y2, m2, d2] = [num(a), num(b), num(c)];
+      if (y2 !== null && m2 !== null && d2 !== null) return withFormat(validYmd(y2, m2, d2), "yyyy-mm-dd");
+    }
+    {
+      const [m2, d2, y2] = [num(a), num(b), num(c)];
+      if (m2 !== null && d2 !== null && y2 !== null) return withFormat(validYmd(expandYear(c, y2), m2, d2), "m/d/yyyy");
+    }
+    const [d, m, y] = [num(a), monthFromName(b), num(c)];
+    if (d !== null && m !== null && y !== null) return withFormat(validYmd(expandYear(c, y), m, d), "d-mmm-yy");
+  }
+  if (parts.length === 2) {
+    const [a, b] = parts.map((p) => p.trim());
+    const [x, y] = [num(a), num(b)];
+    if (x !== null && y !== null) {
+      if (x >= 1 && x <= 12 && y >= 1 && y <= 31) return withFormat(validYmd(currentYear(), x, y), "d-mmm");
+      if (x >= 1 && x <= 12 && b.length === 4) return withFormat(validYmd(y, x, 1), "mmm-yy");
+    }
+    const dayA = num(a);
+    const monthB = monthFromName(b);
+    if (dayA !== null && monthB !== null) return withFormat(validYmd(currentYear(), monthB, dayA), "d-mmm");
+    const monthA = monthFromName(a);
+    const yearB = num(b);
+    if (monthA !== null && yearB !== null) return withFormat(validYmd(expandYear(b, yearB), monthA, 1), "mmm-yy");
+  }
+  const words = t.split(/[ ,]/).filter((w) => w !== "");
+  if (words.length === 3) {
+    const [w0, w1, w2] = words;
+    let [m, d, y] = [monthFromName(w0), num(w1), num(w2)];
+    if (m !== null && d !== null && y !== null) return withFormat(validYmd(expandYear(w2, y), m, d), "d-mmm-yy");
+    [d, m, y] = [num(w0), monthFromName(w1), num(w2)];
+    if (d !== null && m !== null && y !== null) return withFormat(validYmd(expandYear(w2, y), m, d), "d-mmm-yy");
+  }
+  return null;
+}
+function parseDateTime(t) {
+  const time = parseTime(t);
+  if (time) {
+    const format = time.fraction >= 1 ? "[h]:mm:ss" : time.seconds ? time.ampm ? "h:mm:ss AM/PM" : "h:mm:ss" : time.ampm ? "h:mm AM/PM" : "h:mm";
+    return { kind: "time", value: time.fraction, format };
+  }
+  const date = parseDate(t);
+  if (date) return { kind: "date", date: date.date, format: date.format };
+  for (let i = t.indexOf(" "); i !== -1; i = t.indexOf(" ", i + 1)) {
+    const d = parseDate(t.slice(0, i));
+    const tm = d ? parseTime(t.slice(i + 1)) : null;
+    if (d && tm && tm.fraction < 1) {
+      return { kind: "date", date: { ...d.date, time: tm.fraction }, format: "m/d/yyyy h:mm" };
+    }
+  }
+  return null;
+}
+
 // src/spreadsheet/formula/criteria.ts
 function wildcardToRegExp(pattern) {
   let source = "";
@@ -601,12 +940,17 @@ function parseCriteria(criterion) {
     if (op === "<>") return (value) => !isBlank(value);
     return () => false;
   }
-  const operandNumber = numericValue(operand);
+  const parsed = parseCellInput(operand.trim());
+  const operandNumber = numericValue(operand) ?? (parsed.type === "number" ? parsed.value : null);
+  const operandDate = parsed.type === "date" ? parsed.value : null;
+  const isDateValue = (value) => typeof value === "number" || parseIsoDate(value) !== null;
   const operandUpper = operand.trim().toUpperCase();
   const operandBoolean = operandUpper === "TRUE" ? true : operandUpper === "FALSE" ? false : null;
   if (op === "=" || op === "<>") {
     let equals;
-    if (operandNumber !== null) {
+    if (operandDate !== null) {
+      equals = (value) => isDateValue(value) && compareValues(value, operandDate) === 0;
+    } else if (operandNumber !== null) {
       equals = (value) => numericValue(value) === operandNumber;
     } else if (operandBoolean !== null) {
       equals = (value) => value === operandBoolean || typeof value === "string" && value.trim().toUpperCase() === operandUpper;
@@ -619,6 +963,9 @@ function parseCriteria(criterion) {
     return op === "=" ? (value) => !isFormulaError(value) && equals(value) : (value) => !isFormulaError(value) && !equals(value);
   }
   const test = (cmp) => op === "<" ? cmp < 0 : op === "<=" ? cmp <= 0 : op === ">" ? cmp > 0 : cmp >= 0;
+  if (operandDate !== null) {
+    return (value) => isDateValue(value) && test(compareValues(value, operandDate));
+  }
   if (operandNumber !== null) {
     return (value) => {
       const num = numericValue(value);
@@ -635,173 +982,1343 @@ function parseCriteria(criterion) {
   };
 }
 
-// src/spreadsheet/formula/format.ts
-function formatValueWithCode(value, format) {
-  if (isDateFormat(format)) {
-    const date = toDate(value);
-    return date ? formatDate(date, format) : null;
+// 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);
   }
-  const num = typeof value === "boolean" ? null : numericValue(value);
-  return num === null ? toText(value) : formatNumber(num, format);
+  return { digits, exp: Number(s.slice(e + 1)) };
 }
-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]);
+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 {
+      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 {
-      push(false, char);
+      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;
     }
-    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 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;
+    }
+    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 pad2 = (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 ? pad2(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 ? pad2(date.getDate()) : String(date.getDate());
-    }
-    if (lower.startsWith("h")) {
-      let hours = date.getHours();
-      if (twelveHour) hours = hours % 12 || 12;
-      return lower.length >= 2 ? pad2(hours) : String(hours);
-    }
-    if (lower.startsWith("s")) {
-      return lower.length >= 2 ? pad2(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 ? pad2(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 ? pad2(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
@@ -1806,7 +3323,7 @@ var TEXT_FUNCTIONS = [
       if (isFormulaError(value)) return value;
       if (typeof value === "number") return value;
       if (isBlank(value)) return 0;
-      const num = parseNumericText(toText(value));
+      const num = parseNumericText(toText(value)) ?? parseNumberText(toText(value));
       if (num === null) return ctx.argError(0, "#VALUE!", `("${toText(value)}") can't be converted to a number.`);
       return num;
     }
@@ -1814,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 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;
     }
   }
 ];
@@ -1887,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);
 }
@@ -2661,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) {
@@ -2682,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.`;
@@ -2694,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) {
@@ -2708,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) => {
@@ -3207,13 +4728,33 @@ export {
   parseRange,
   FormulaParser,
   parseFormula,
+  serialFromYmd,
+  parseCellInput,
+  parseNumberText,
   FORMULA_ERRORS,
   isFormulaError,
+  isBlank,
+  toText,
+  numberToText,
+  numericValue,
+  compareNumbers,
+  compareValues,
+  sortCompareValues,
   colNameToIndex,
   indexToColName,
+  parseIsoDate,
   wildcardToRegExp,
   parseCriteria,
-  formatValueWithCode,
+  formatGeneralFit,
+  builtinNumberFormat,
+  builtinNumberFormatId,
+  MAX_NUMBER_FORMAT_CODE_CHARS,
+  NumberFormat,
+  clearNumberFormatCache,
+  dateValueToSerial,
+  formatNumberFormatValue,
+  formatTextFunction,
+  numberFormatColorToCss,
   registerFormulaFunction,
   unregisterFormulaFunction,
   getFormulaFunction,
@@ -3227,4 +4768,4 @@ export {
   MAX_FORMULA_ARRAY_SIZE,
   FormulaEvaluator
 };
-//# sourceMappingURL=chunk-DENSCKFC.js.map
+//# sourceMappingURL=chunk-3CN2WD3X.js.map