@lotics/xlsx 0.1.0

package/src/excel_numfmt.ts

@@ -0,0 +1,1033 @@
+// =============================================================================
+// Excel Number Format Engine
+// =============================================================================
+//
+// Full implementation of Excel custom number format codes:
+// - 4-section format codes (positive; negative; zero; text)
+// - Conditional colors ([Red], [Blue], [Color1]-[Color56])
+// - Conditional sections ([>100], [<=50])
+// - Date/time tokens (y, m, d, h, s, AM/PM)
+// - Elapsed time ([h]:mm:ss, [m]:ss, [s])
+// - Number formatting (0, #, ?, decimal, thousands, percentage)
+// - Scientific notation (0.00E+00)
+// - Fractions (# ?/?, # ??/??)
+// - Currency/locale codes ([$EUR-407])
+// - Fill characters (*x), underscore spacing (_x)
+// - Text format (@)
+// =============================================================================
+
+export interface FormattedValue {
+  text: string;
+  color?: string;
+}
+
+// =============================================================================
+// Color constants
+// =============================================================================
+
+const NAMED_COLORS: Record<string, string> = {
+  red: "#FF0000",
+  blue: "#0000FF",
+  green: "#008000",
+  yellow: "#FFFF00",
+  magenta: "#FF00FF",
+  cyan: "#00FFFF",
+  white: "#FFFFFF",
+  black: "#000000",
+};
+
+// =============================================================================
+// Date/time constants
+// =============================================================================
+
+const MONTH_NAMES = [
+  "January", "February", "March", "April", "May", "June",
+  "July", "August", "September", "October", "November", "December",
+];
+const MONTH_ABBREVS = [
+  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+];
+const DAY_NAMES = [
+  "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
+];
+const DAY_ABBREVS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+
+// =============================================================================
+// Excel epoch
+// =============================================================================
+
+// Days from Jan 1, 1900 (serial 1) to Jan 1, 1970 (Unix epoch) = 25567 real days.
+// After the Lotus bug correction (subtract 1 for serials > 60), the offset is 25568.
+const EXCEL_EPOCH_OFFSET = 25568;
+const MS_PER_DAY = 86400000;
+
+interface DateParts {
+  year: number;
+  month: number;
+  day: number;
+  dayOfWeek: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  milliseconds: number;
+}
+
+export function serialToDateParts(serial: number, date1904: boolean): DateParts {
+  const adjusted = date1904 ? serial + 1462 : serial;
+  const corrected = adjusted > 60 ? adjusted - 1 : adjusted;
+
+  const dayPart = Math.floor(corrected);
+  const timeFraction = corrected - dayPart;
+
+  const ms = (dayPart - EXCEL_EPOCH_OFFSET) * MS_PER_DAY;
+  const date = new Date(ms);
+
+  const totalMs = Math.round(timeFraction * MS_PER_DAY);
+  const hours = Math.floor(totalMs / 3600000);
+  const minutes = Math.floor((totalMs % 3600000) / 60000);
+  const seconds = Math.floor((totalMs % 60000) / 1000);
+  const milliseconds = totalMs % 1000;
+
+  return {
+    year: date.getUTCFullYear(),
+    month: date.getUTCMonth() + 1,
+    day: date.getUTCDate(),
+    dayOfWeek: date.getUTCDay(),
+    hours,
+    minutes,
+    seconds,
+    milliseconds,
+  };
+}
+
+// =============================================================================
+// Regex patterns
+// =============================================================================
+
+const COLOR_RE = /\[(Red|Blue|Green|Yellow|Magenta|Cyan|White|Black|Color\d{1,2})\]/i;
+const CONDITION_RE = /\[(>=?|<=?|=|<>)\s*(-?[\d.]+)\]/;
+const LOCALE_RE = /\[\$([^\]]*)\]/g;
+const ELAPSED_RE = /\[([hms])\]/i;
+
+// =============================================================================
+// Main entry point
+// =============================================================================
+
+export function formatNumFmt(
+  value: number | string,
+  formatCode: string,
+  date1904 = false,
+): FormattedValue {
+  if (!formatCode || formatCode === "General") {
+    return { text: typeof value === "string" ? value : formatGeneral(value) };
+  }
+
+  if (typeof value === "string") {
+    const sections = splitSections(formatCode);
+    const textSection = sections.length === 4 ? sections[3] : formatCode;
+    const { color, rest } = extractColor(textSection);
+    return { text: formatTextSection(value, rest), color };
+  }
+
+  const sections = splitSections(formatCode);
+  const { section, absValue, negative } = selectSection(sections, value);
+  const { color, rest } = extractColor(section);
+  const cleaned = stripBracketExpressions(rest);
+  const text = formatSection(absValue, cleaned, date1904);
+  return { text: negative ? `-${text}` : text, color };
+}
+
+// =============================================================================
+// Section splitting — respects quoted strings and brackets
+// =============================================================================
+
+function splitSections(code: string): string[] {
+  const sections: string[] = [];
+  let current = "";
+  let inQuote = false;
+  let inBracket = false;
+
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i];
+    if (ch === '"' && !inBracket) {
+      inQuote = !inQuote;
+      current += ch;
+    } else if (inQuote) {
+      current += ch;
+    } else if (ch === "[") {
+      inBracket = true;
+      current += ch;
+    } else if (ch === "]" && inBracket) {
+      inBracket = false;
+      current += ch;
+    } else if (ch === ";" && !inBracket) {
+      sections.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  sections.push(current);
+  return sections;
+}
+
+// =============================================================================
+// Section selection — picks correct section based on value sign
+// =============================================================================
+
+function selectSection(
+  sections: string[],
+  value: number,
+): { section: string; absValue: number; negative: boolean } {
+  // Check for conditional sections
+  if (sections.length === 2) {
+    const cond0 = extractCondition(sections[0]);
+    if (cond0.condition) {
+      if (evalCondition(value, cond0.condition)) {
+        return { section: sections[0], absValue: value, negative: false };
+      }
+      return { section: sections[1], absValue: value, negative: false };
+    }
+  }
+
+  switch (sections.length) {
+    case 1:
+      return {
+        section: sections[0],
+        absValue: Math.abs(value),
+        negative: value < 0,
+      };
+    case 2:
+      if (value >= 0) return { section: sections[0], absValue: value, negative: false };
+      return { section: sections[1], absValue: Math.abs(value), negative: false };
+    default: {
+      // 3 or 4 sections: positive; negative; zero [; text]
+      if (value > 0) return { section: sections[0], absValue: value, negative: false };
+      if (value < 0) return { section: sections[1], absValue: Math.abs(value), negative: false };
+      return { section: sections[2], absValue: 0, negative: false };
+    }
+  }
+}
+
+// =============================================================================
+// Bracket expression parsing
+// =============================================================================
+
+function extractColor(section: string): { color?: string; rest: string } {
+  const match = section.match(COLOR_RE);
+  if (!match || match.index === undefined) return { rest: section };
+  const name = match[1].toLowerCase();
+  const color = NAMED_COLORS[name];
+  const rest = section.slice(0, match.index) + section.slice(match.index + match[0].length);
+  return { color, rest };
+}
+
+function extractCondition(section: string): {
+  condition?: { op: string; val: number };
+  rest: string;
+} {
+  const match = section.match(CONDITION_RE);
+  if (!match || match.index === undefined) return { rest: section };
+  return {
+    condition: { op: match[1], val: parseFloat(match[2]) },
+    rest: section.slice(0, match.index) + section.slice(match.index + match[0].length),
+  };
+}
+
+function evalCondition(value: number, cond: { op: string; val: number }): boolean {
+  switch (cond.op) {
+    case ">": return value > cond.val;
+    case ">=": return value >= cond.val;
+    case "<": return value < cond.val;
+    case "<=": return value <= cond.val;
+    case "=": return value === cond.val;
+    case "<>": return value !== cond.val;
+    default: return false;
+  }
+}
+
+function stripBracketExpressions(section: string): string {
+  // Remove condition brackets and locale codes, but keep elapsed time brackets
+  let result = section.replace(CONDITION_RE, "");
+  // Replace locale codes: [$symbol-locale] → "symbol" as literal, [$-locale] → nothing
+  result = result.replace(LOCALE_RE, (_match, inner: string) => {
+    const dashIdx = inner.indexOf("-");
+    const symbol = dashIdx >= 0 ? inner.slice(0, dashIdx) : inner;
+    return symbol ? `"${symbol}"` : "";
+  });
+  return result;
+}
+
+// =============================================================================
+// Section type detection
+// =============================================================================
+
+function isDateSection(section: string): boolean {
+  let cleaned = section.replace(/"[^"]*"/g, "");
+  cleaned = cleaned.replace(/\[\$[^\]]*\]/g, "");
+  cleaned = cleaned.replace(COLOR_RE, "");
+  if (ELAPSED_RE.test(cleaned)) return true;
+  if (/[#0?]/.test(cleaned) && !ELAPSED_RE.test(cleaned)) return false;
+  if (cleaned.includes("%")) return false;
+  if (/E[+-]/i.test(cleaned)) return false;
+  return /[ymdhs]/i.test(cleaned);
+}
+
+// =============================================================================
+// Format dispatcher
+// =============================================================================
+
+function formatSection(value: number, section: string, date1904: boolean): string {
+  if (!section || section === "General") return formatGeneral(value);
+  if (section === "@") return String(value);
+  if (isDateSection(section)) return formatDateSection(value, section, date1904);
+  return formatNumberSection(value, section);
+}
+
+// =============================================================================
+// General format — Excel's default formatting
+// =============================================================================
+
+function formatGeneral(value: number): string {
+  if (value === 0) return "0";
+  const abs = Math.abs(value);
+  // Excel uses scientific notation for very large numbers
+  if (abs >= 1e11) {
+    let s = value.toPrecision(6);
+    s = s.replace(/\.?0+(e)/, "$1").replace("e+", "E+").replace("e-", "E-");
+    return s;
+  }
+  // Up to 11 significant digits, JS handles decimal/scientific notation switch
+  const s = parseFloat(value.toPrecision(11)).toString();
+  return s.replace("e+", "E+").replace("e-", "E-");
+}
+
+// =============================================================================
+// Text section formatter
+// =============================================================================
+
+function formatTextSection(value: string, section: string): string {
+  let result = "";
+  let i = 0;
+  while (i < section.length) {
+    const ch = section[i];
+    if (ch === "@") {
+      result += value;
+      i++;
+    } else if (ch === '"') {
+      i++;
+      while (i < section.length && section[i] !== '"') { result += section[i]; i++; }
+      i++;
+    } else if (ch === "\\") {
+      i++;
+      if (i < section.length) { result += section[i]; i++; }
+    } else if (ch === "_") {
+      result += " ";
+      i += 2;
+    } else if (ch === "*") {
+      i += 2;
+    } else if (ch === "[") {
+      while (i < section.length && section[i] !== "]") i++;
+      i++;
+    } else {
+      result += ch;
+      i++;
+    }
+  }
+  return result;
+}
+
+// =============================================================================
+// Date/time formatter
+// =============================================================================
+
+interface DateToken {
+  type: "literal" | "year" | "month" | "day" | "hour" | "minute" | "second" | "subsecond" | "ampm";
+  length: number;
+  value: string;
+  elapsed?: boolean;
+}
+
+function formatDateSection(serial: number, section: string, date1904: boolean): string {
+  const parts = serialToDateParts(serial, date1904);
+  const tokens = tokenizeDateFormat(section);
+
+  const hasElapsedH = tokens.some((t) => t.type === "hour" && t.elapsed);
+  const hasElapsedM = tokens.some((t) => t.type === "minute" && t.elapsed);
+  const hasElapsedS = tokens.some((t) => t.type === "second" && t.elapsed);
+  const use12h = tokens.some((t) => t.type === "ampm");
+
+  let displayHours = parts.hours;
+  let ampm = "";
+  if (use12h) {
+    ampm = parts.hours >= 12 ? "PM" : "AM";
+    displayHours = parts.hours % 12 || 12;
+  }
+
+  const totalSeconds = Math.floor(serial * 86400);
+  const totalMinutes = Math.floor(serial * 1440);
+  const totalHours = Math.floor(serial * 24);
+
+  let result = "";
+  for (const token of tokens) {
+    switch (token.type) {
+      case "literal":
+        result += token.value;
+        break;
+      case "year":
+        result += token.length <= 2
+          ? String(parts.year % 100).padStart(2, "0")
+          : String(parts.year);
+        break;
+      case "month":
+        switch (token.length) {
+          case 1: result += String(parts.month); break;
+          case 2: result += String(parts.month).padStart(2, "0"); break;
+          case 3: result += MONTH_ABBREVS[parts.month - 1]; break;
+          case 4: result += MONTH_NAMES[parts.month - 1]; break;
+          default: result += MONTH_NAMES[parts.month - 1][0]; break;
+        }
+        break;
+      case "day":
+        switch (token.length) {
+          case 1: result += String(parts.day); break;
+          case 2: result += String(parts.day).padStart(2, "0"); break;
+          case 3: result += DAY_ABBREVS[parts.dayOfWeek]; break;
+          default: result += DAY_NAMES[parts.dayOfWeek]; break;
+        }
+        break;
+      case "hour":
+        if (hasElapsedH && token.elapsed) {
+          result += String(totalHours);
+        } else {
+          result += token.length === 1 ? String(displayHours) : String(displayHours).padStart(2, "0");
+        }
+        break;
+      case "minute":
+        if (hasElapsedM && token.elapsed) {
+          result += String(totalMinutes);
+        } else {
+          result += token.length === 1 ? String(parts.minutes) : String(parts.minutes).padStart(2, "0");
+        }
+        break;
+      case "second":
+        if (hasElapsedS && token.elapsed) {
+          result += String(totalSeconds);
+        } else {
+          result += token.length === 1 ? String(parts.seconds) : String(parts.seconds).padStart(2, "0");
+        }
+        break;
+      case "subsecond": {
+        const frac = parts.milliseconds / 1000;
+        result += frac.toFixed(token.length).slice(1);
+        break;
+      }
+      case "ampm": {
+        const short = token.length === 3;
+        result += short ? ampm[0] : ampm;
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+function tokenizeDateFormat(section: string): DateToken[] {
+  const tokens: DateToken[] = [];
+  let i = 0;
+
+  while (i < section.length) {
+    const ch = section[i];
+    const lo = ch.toLowerCase();
+
+    // Quoted string
+    if (ch === '"') {
+      i++;
+      let lit = "";
+      while (i < section.length && section[i] !== '"') { lit += section[i]; i++; }
+      i++;
+      tokens.push({ type: "literal", length: lit.length, value: lit });
+      continue;
+    }
+
+    // Escaped char
+    if (ch === "\\") {
+      i++;
+      tokens.push({ type: "literal", length: 1, value: i < section.length ? section[i] : "" });
+      i++;
+      continue;
+    }
+
+    // Underscore spacing
+    if (ch === "_") {
+      tokens.push({ type: "literal", length: 1, value: " " });
+      i += Math.min(i + 2, section.length) - i;
+      continue;
+    }
+
+    // Fill char
+    if (ch === "*") {
+      i += Math.min(i + 2, section.length) - i;
+      continue;
+    }
+
+    // Bracket expression
+    if (ch === "[") {
+      const closeIdx = section.indexOf("]", i);
+      if (closeIdx === -1) { i++; continue; }
+      const inner = section.slice(i + 1, closeIdx).toLowerCase();
+      if (inner === "h" || inner === "m" || inner === "s") {
+        const typeMap: Record<string, "hour" | "minute" | "second"> = {
+          h: "hour", m: "minute", s: "second",
+        };
+        tokens.push({ type: typeMap[inner], length: 1, value: inner, elapsed: true });
+      }
+      i = closeIdx + 1;
+      continue;
+    }
+
+    // AM/PM or A/P
+    if (section.slice(i, i + 5).toUpperCase() === "AM/PM") {
+      tokens.push({ type: "ampm", length: 5, value: "AM/PM" });
+      i += 5;
+      continue;
+    }
+    if (section.slice(i, i + 3).toUpperCase() === "A/P") {
+      tokens.push({ type: "ampm", length: 3, value: "A/P" });
+      i += 3;
+      continue;
+    }
+
+    // Date/time letters
+    if (lo === "y" || lo === "d" || lo === "h" || lo === "s" || lo === "m") {
+      let len = 0;
+      while (i + len < section.length && section[i + len].toLowerCase() === lo) len++;
+      const typeMap: Record<string, DateToken["type"]> = {
+        y: "year", d: "day", h: "hour", s: "second", m: "month",
+      };
+      tokens.push({ type: typeMap[lo], length: len, value: section.slice(i, i + len) });
+      i += len;
+      continue;
+    }
+
+    // Subsecond: .0, .00, .000
+    if (ch === "." && i + 1 < section.length && section[i + 1] === "0") {
+      let len = 0;
+      let j = i + 1;
+      while (j < section.length && section[j] === "0") { len++; j++; }
+      tokens.push({ type: "subsecond", length: len, value: section.slice(i, j) });
+      i = j;
+      continue;
+    }
+
+    // Literal
+    tokens.push({ type: "literal", length: 1, value: ch });
+    i++;
+  }
+
+  // Resolve m/mm ambiguity: if preceded by h/[h] or followed by s/[s], treat as minutes
+  for (let t = 0; t < tokens.length; t++) {
+    if (tokens[t].type !== "month") continue;
+    let prev: DateToken | undefined;
+    for (let p = t - 1; p >= 0; p--) {
+      if (tokens[p].type !== "literal") { prev = tokens[p]; break; }
+    }
+    let next: DateToken | undefined;
+    for (let n = t + 1; n < tokens.length; n++) {
+      if (tokens[n].type !== "literal") { next = tokens[n]; break; }
+    }
+    if (prev?.type === "hour" || next?.type === "second" || next?.type === "subsecond") {
+      tokens[t] = { ...tokens[t], type: "minute" };
+    }
+  }
+
+  return tokens;
+}
+
+// =============================================================================
+// Number section formatter
+// =============================================================================
+
+function formatNumberSection(value: number, section: string): string {
+  const isPercent = containsUnquoted(section, "%");
+  let v = isPercent ? value * 100 : value;
+
+  const { scaled, cleaned: scaledSection } = applyTrailingCommaScaling(v, section);
+  v = scaled;
+
+  if (hasScientific(scaledSection)) return formatScientific(v, scaledSection);
+  if (hasFraction(scaledSection)) return formatFraction(v, scaledSection);
+  return formatDigitPattern(v, scaledSection);
+}
+
+function containsUnquoted(section: string, ch: string): boolean {
+  let inQuote = false;
+  for (let i = 0; i < section.length; i++) {
+    if (section[i] === '"') { inQuote = !inQuote; continue; }
+    if (!inQuote && section[i] === ch) return true;
+  }
+  return false;
+}
+
+function hasScientific(section: string): boolean {
+  let inQuote = false;
+  for (let i = 0; i < section.length - 1; i++) {
+    if (section[i] === '"') { inQuote = !inQuote; continue; }
+    if (!inQuote && section[i].toUpperCase() === "E" && (section[i + 1] === "+" || section[i + 1] === "-")) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function hasFraction(section: string): boolean {
+  let inQuote = false;
+  for (let i = 1; i < section.length - 1; i++) {
+    if (section[i] === '"') { inQuote = !inQuote; continue; }
+    if (!inQuote && section[i] === "/") {
+      const before = section.slice(0, i);
+      const after = section.slice(i + 1);
+      if (/[0#?]/.test(before) && /[0#?\d]/.test(after)) return true;
+    }
+  }
+  return false;
+}
+
+function applyTrailingCommaScaling(
+  value: number,
+  section: string,
+): { scaled: number; cleaned: string } {
+  // Trailing commas after the last digit placeholder scale down by 1000 each
+  const lastDigit = findLastDigitPlaceholder(section);
+  if (lastDigit < 0) return { scaled: value, cleaned: section };
+
+  let count = 0;
+  let i = lastDigit + 1;
+  while (i < section.length && section[i] === ",") { count++; i++; }
+  if (count === 0) return { scaled: value, cleaned: section };
+
+  const cleaned = section.slice(0, lastDigit + 1) + section.slice(lastDigit + 1 + count);
+  return { scaled: value / Math.pow(1000, count), cleaned };
+}
+
+function findLastDigitPlaceholder(section: string): number {
+  let inQuote = false;
+  let last = -1;
+  for (let i = 0; i < section.length; i++) {
+    if (section[i] === '"') { inQuote = !inQuote; continue; }
+    if (!inQuote && /[0#?]/.test(section[i])) last = i;
+  }
+  return last;
+}
+
+// =============================================================================
+// Digit pattern formatter — handles #,##0.00 style formats
+// =============================================================================
+
+function formatDigitPattern(value: number, section: string): string {
+  const { intZeros, decSpec, hasThousands, hasDecimal } = analyzePattern(section);
+
+  const decPlaces = decSpec.length;
+  const rounded = roundTo(Math.abs(value), decPlaces);
+  const intPart = Math.trunc(rounded);
+  const decPart = rounded - intPart;
+
+  // Build integer string
+  let intStr = String(intPart);
+  while (intStr.length < intZeros) intStr = "0" + intStr;
+  // Suppress zero integer when format is all # (e.g., #.## for 0.5 → .5)
+  if (intPart === 0 && intZeros === 0) intStr = "";
+  if (hasThousands && intStr.length > 0) {
+    intStr = addThousandsSep(intStr);
+  }
+
+  // Build decimal string
+  let decStr = "";
+  if (hasDecimal && decPlaces > 0) {
+    const raw = decPart.toFixed(decPlaces).slice(2); // skip "0."
+    decStr = applyDecimalSpec(raw, decSpec);
+  }
+
+  // Walk the format template and substitute
+  return walkTemplate(section, intStr, decStr, hasDecimal);
+}
+
+interface PatternInfo {
+  intZeros: number;
+  decSpec: string;
+  hasThousands: boolean;
+  hasDecimal: boolean;
+}
+
+function analyzePattern(section: string): PatternInfo {
+  let inQuote = false;
+  let intZeros = 0;
+  let decSpec = "";
+  let hasThousands = false;
+  let hasDecimal = false;
+  let afterDecimal = false;
+  let seenDigit = false;
+
+  for (let i = 0; i < section.length; i++) {
+    const ch = section[i];
+    if (ch === '"') { inQuote = !inQuote; continue; }
+    if (inQuote) continue;
+    if (ch === "\\") { i++; continue; }
+    if (ch === "_" || ch === "*") { i++; continue; }
+    if (ch === "[") { while (i < section.length && section[i] !== "]") i++; continue; }
+
+    if (ch === ".") {
+      hasDecimal = true;
+      afterDecimal = true;
+      continue;
+    }
+
+    if (afterDecimal && (ch === "0" || ch === "#" || ch === "?")) {
+      decSpec += ch;
+      continue;
+    }
+
+    if (!afterDecimal && ch === "0") {
+      intZeros++;
+      seenDigit = true;
+      continue;
+    }
+    if (!afterDecimal && (ch === "#" || ch === "?")) {
+      seenDigit = true;
+      continue;
+    }
+    if (!afterDecimal && ch === "," && seenDigit) {
+      hasThousands = true;
+    }
+  }
+
+  return { intZeros, decSpec, hasThousands, hasDecimal };
+}
+
+function applyDecimalSpec(raw: string, spec: string): string {
+  let result = "";
+  for (let i = 0; i < spec.length; i++) {
+    const ch = spec[i];
+    const digit = raw[i] ?? "0";
+    if (ch === "0") {
+      result += digit;
+    } else if (ch === "#") {
+      // Trim trailing zeros for # positions
+      if (/^0*$/.test(raw.slice(i))) break;
+      result += digit;
+    } else if (ch === "?") {
+      result += digit === "0" && /^0*$/.test(raw.slice(i)) ? " " : digit;
+    }
+  }
+  return result;
+}
+
+function addThousandsSep(s: string): string {
+  const parts: string[] = [];
+  for (let i = s.length; i > 0; i -= 3) {
+    parts.unshift(s.slice(Math.max(0, i - 3), i));
+  }
+  return parts.join(",");
+}
+
+function roundTo(value: number, places: number): number {
+  if (places <= 0) return Math.round(value);
+  const f = Math.pow(10, places);
+  return Math.round(value * f) / f;
+}
+
+// Walk the format template, replacing digit placeholders with formatted values
+function walkTemplate(
+  section: string,
+  intStr: string,
+  decStr: string,
+  hasDecimal: boolean,
+): string {
+  let result = "";
+  let i = 0;
+  let intEmitted = false;
+  let decEmitted = false;
+
+  while (i < section.length) {
+    const ch = section[i];
+
+    // Quoted string
+    if (ch === '"') {
+      i++;
+      while (i < section.length && section[i] !== '"') { result += section[i]; i++; }
+      i++;
+      continue;
+    }
+
+    // Escaped char
+    if (ch === "\\") {
+      i++;
+      if (i < section.length) { result += section[i]; i++; }
+      continue;
+    }
+
+    // Underscore spacing
+    if (ch === "_") {
+      result += " ";
+      i += 2;
+      continue;
+    }
+
+    // Fill char — skip
+    if (ch === "*") {
+      i += 2;
+      continue;
+    }
+
+    // Bracket expression — skip
+    if (ch === "[") {
+      while (i < section.length && section[i] !== "]") i++;
+      i++;
+      continue;
+    }
+
+    // Digit placeholder in integer zone (before decimal)
+    if (!decEmitted && (ch === "0" || ch === "#" || ch === "?")) {
+      if (!intEmitted) {
+        result += intStr;
+        intEmitted = true;
+      }
+      // Skip all integer digit placeholders and commas
+      while (i < section.length && /[0#?,]/.test(section[i])) i++;
+      continue;
+    }
+
+    // Comma in integer zone before any digit is emitted
+    if (!intEmitted && ch === ",") {
+      i++;
+      continue;
+    }
+
+    // Decimal point
+    if (ch === "." && intEmitted && !decEmitted) {
+      if (hasDecimal && decStr.length > 0) {
+        result += "." + decStr;
+      } else if (hasDecimal) {
+        // Decimal with no decimal digits — just show the dot if format has 0s
+        // Actually if decStr is empty, we might still want to show the dot
+      }
+      decEmitted = true;
+      i++;
+      // Skip decimal digit placeholders
+      while (i < section.length && /[0#?]/.test(section[i])) i++;
+      continue;
+    }
+
+    // Percent
+    if (ch === "%") {
+      result += "%";
+      i++;
+      continue;
+    }
+
+    // Currency and other literal chars
+    result += ch;
+    i++;
+  }
+
+  return result;
+}
+
+// =============================================================================
+// Scientific notation formatter
+// =============================================================================
+
+function formatScientific(value: number, section: string): string {
+  // Find E+/E- position (outside quotes)
+  let ePos = -1;
+  let eSign = "+";
+  let inQuote = false;
+  for (let i = 0; i < section.length - 1; i++) {
+    if (section[i] === '"') { inQuote = !inQuote; continue; }
+    if (!inQuote && section[i].toUpperCase() === "E" && (section[i + 1] === "+" || section[i + 1] === "-")) {
+      ePos = i;
+      eSign = section[i + 1];
+      break;
+    }
+  }
+  if (ePos < 0) return String(value);
+
+  const coeffFmt = section.slice(0, ePos);
+  const expFmt = section.slice(ePos + 2);
+
+  // Count coefficient integer and decimal digits
+  const coeffInfo = analyzePattern(coeffFmt);
+  const intDigitCount = Math.max(coeffInfo.intZeros, 1);
+  const decDigits = coeffInfo.decSpec.length;
+  const expMinDigits = (expFmt.match(/[0#?]/g) ?? []).length || 1;
+
+  if (value === 0) {
+    const coeffStr = (0).toFixed(decDigits);
+    const expStr = "0".padStart(expMinDigits, "0");
+    return `${coeffStr}E${eSign}${expStr}`;
+  }
+
+  const abs = Math.abs(value);
+  const rawExp = Math.floor(Math.log10(abs));
+  // Exponent is a multiple of intDigitCount (engineering notation when > 1)
+  const exp = Math.floor(rawExp / intDigitCount) * intDigitCount;
+  const coeff = value / Math.pow(10, exp);
+  const coeffStr = roundTo(Math.abs(coeff), decDigits).toFixed(decDigits);
+
+  const absExp = Math.abs(exp);
+  const expStr = String(absExp).padStart(expMinDigits, "0");
+  const sign = exp >= 0 ? (eSign === "+" ? "+" : "") : "-";
+
+  return `${value < 0 ? "-" : ""}${coeffStr}E${sign}${expStr}`;
+}
+
+// =============================================================================
+// Fraction formatter
+// =============================================================================
+
+function formatFraction(value: number, section: string): string {
+  const abs = Math.abs(value);
+  const intPart = Math.floor(abs);
+  const fracPart = abs - intPart;
+
+  // Find the slash position (outside quotes)
+  let slashPos = -1;
+  let inQuote = false;
+  for (let i = 0; i < section.length; i++) {
+    if (section[i] === '"') { inQuote = !inQuote; continue; }
+    if (!inQuote && section[i] === "/") { slashPos = i; break; }
+  }
+  if (slashPos < 0) return String(value);
+
+  // Parse denominator: fixed number or variable digits
+  const afterSlash = section.slice(slashPos + 1);
+  const fixedDenomMatch = afterSlash.match(/^(\d+)/);
+  const varDenomMatch = afterSlash.match(/^([?#0]+)/);
+  let denom: number;
+  let numer: number;
+  let denomWidth: number;
+
+  if (fixedDenomMatch) {
+    denom = parseInt(fixedDenomMatch[1]);
+    denomWidth = fixedDenomMatch[1].length;
+    numer = Math.round(fracPart * denom);
+    if (numer >= denom) { numer -= denom; /* integer would be intPart+1 but we keep simple */ }
+  } else if (varDenomMatch) {
+    denomWidth = varDenomMatch[1].length;
+    const maxDenom = Math.pow(10, denomWidth) - 1;
+    const best = bestFraction(fracPart, maxDenom);
+    numer = best.num;
+    denom = best.den;
+  } else {
+    return String(value);
+  }
+
+  // Parse numerator width
+  const beforeSlash = section.slice(0, slashPos);
+  const numMatch = beforeSlash.match(/([?#0]+)\s*$/);
+  const numWidth = numMatch ? numMatch[1].length : 1;
+
+  // Check if format has an integer part (digit placeholder before the fraction pattern)
+  const beforeNum = numMatch ? beforeSlash.slice(0, numMatch.index!) : beforeSlash;
+  const hasIntPart = /[#0?]/.test(beforeNum.replace(/"[^"]*"/g, ""));
+
+  // Prefix: everything before the integer/fraction pattern
+  let prefix = "";
+  {
+    const stripped = beforeNum.replace(/"[^"]*"/g, "");
+    // Walk to extract prefix literals
+    const firstDigit = stripped.search(/[#0?]/);
+    if (firstDigit < 0) {
+      prefix = extractLiterals(beforeNum);
+    } else {
+      prefix = extractLiterals(beforeNum.slice(0, findRawIndex(beforeNum, firstDigit)));
+    }
+  }
+
+  // Build fraction string
+  const numStr = numer === 0 && hasIntPart
+    ? " ".repeat(numWidth)
+    : String(numer).padStart(numWidth, " ");
+  const denStr = numer === 0 && hasIntPart
+    ? " ".repeat(denomWidth)
+    : String(denom).padStart(denomWidth, " ");
+  const divider = numer === 0 && hasIntPart ? " " : "/";
+
+  const intDisplay = hasIntPart ? (intPart > 0 || numer === 0 ? String(intPart) : "") : "";
+  const space = hasIntPart && intDisplay ? " " : "";
+
+  if (!hasIntPart && numer === 0) return `${prefix}0`;
+  if (!hasIntPart) {
+    // Improper fraction
+    const totalNum = intPart * denom + numer;
+    return `${prefix}${String(totalNum).padStart(numWidth, " ")}/${denStr}`;
+  }
+
+  return `${prefix}${intDisplay}${space}${numStr}${divider}${denStr}`;
+}
+
+function bestFraction(value: number, maxDenom: number): { num: number; den: number } {
+  if (value < 1e-12) return { num: 0, den: 1 };
+  let bestNum = 0;
+  let bestDen = 1;
+  let bestErr = value;
+  for (let d = 1; d <= maxDenom; d++) {
+    const n = Math.round(value * d);
+    if (n > maxDenom) continue;
+    const err = Math.abs(value - n / d);
+    if (err < bestErr - 1e-12) {
+      bestErr = err;
+      bestNum = n;
+      bestDen = d;
+      if (err < 1e-12) break;
+    }
+  }
+  return { num: bestNum, den: bestDen };
+}
+
+function extractLiterals(section: string): string {
+  let result = "";
+  let i = 0;
+  while (i < section.length) {
+    if (section[i] === '"') {
+      i++;
+      while (i < section.length && section[i] !== '"') { result += section[i]; i++; }
+      i++;
+    } else if (section[i] === "\\") {
+      i++;
+      if (i < section.length) { result += section[i]; i++; }
+    } else if (section[i] === "_") {
+      result += " ";
+      i += 2;
+    } else if (section[i] === "*") {
+      i += 2;
+    } else if (section[i] === "[") {
+      while (i < section.length && section[i] !== "]") i++;
+      i++;
+    } else if (/[0#?,%.]/.test(section[i])) {
+      // Skip format chars
+      i++;
+    } else {
+      result += section[i];
+      i++;
+    }
+  }
+  return result;
+}
+
+function findRawIndex(s: string, targetCleanIdx: number): number {
+  let clean = 0;
+  let i = 0;
+  while (i < s.length && clean < targetCleanIdx) {
+    if (s[i] === '"') {
+      i++;
+      while (i < s.length && s[i] !== '"') i++;
+      i++;
+    } else {
+      clean++;
+      i++;
+    }
+  }
+  return i;
+}