@svgrid/enterprise 3.0.2 → 3.1.0

package/dist/sheet/number-format.js

@@ -69,8 +69,20 @@ function splitSections(pattern) {
     out.push(current);
     return out;
 }
+const CONDITION = /^(<=|>=|<>|<|>|=)\s*(-?\d+(?:\.\d+)?)$/;
+function passes(condition, n) {
+    switch (condition.op) {
+        case '<': return n < condition.value;
+        case '<=': return n <= condition.value;
+        case '>': return n > condition.value;
+        case '>=': return n >= condition.value;
+        case '=': return n === condition.value;
+        case '<>': return n !== condition.value;
+    }
+}
 function parseSection(raw) {
     let color;
+    let condition;
     let body = '';
     // Walk rather than regex-replace: a pattern like `"[" @ "]"` has brackets
     // INSIDE quoted literals, and a global /\[[^\]]*\]/ happily eats the text
@@ -96,19 +108,37 @@ function parseSection(raw) {
                 continue;
             }
             const inner = raw.slice(i + 1, end).trim().toUpperCase();
+            // An elapsed-time token is part of the pattern rather than a
+            // directive about it, so it stays in the body for the renderer.
+            if (ELAPSED_TOKEN.test(raw.slice(i))) {
+                body += raw.slice(i, end + 1);
+                i = end;
+                continue;
+            }
             const named = COLORS[inner];
             if (named)
                 color = named;
-            // Anything else (a condition like [<100]) is unsupported: drop it rather
-            // than print it.
+            const cond = CONDITION.exec(inner);
+            if (cond)
+                condition = { op: cond[1], value: Number(cond[2]) };
+            // Anything else ([$-409] locale tags and the like) is dropped rather
+            // than printed.
             i = end;
             continue;
         }
         body += ch;
     }
-    return { raw, color, body };
+    return condition ? { raw, color, condition, body } : { raw, color, body };
 }
-const DATE_TOKEN = /^(yyyy|yy|mmmm|mmm|mm|m|dddd|ddd|dd|d|hh|h|ss|s|AM\/PM|am\/pm|A\/P)/;
+const DATE_TOKEN = /^(yyyy|yy|mmmmm|mmmm|mmm|mm|m|dddd|ddd|dd|d|hh|h|ss|s|AM\/PM|am\/pm|A\/P|a\/p)/;
+/**
+ * Excel's elapsed-time tokens: the hours, minutes or seconds a duration
+ * holds in TOTAL rather than the clock's reading of it, which is what a
+ * timesheet needs. `[h]:mm` over 1.5 days is 36:00, not 12:00. Only h, m
+ * and s go in these brackets, so a colour (`[Red]`) or a condition
+ * (`[>100]`) never matches.
+ */
+const ELAPSED_TOKEN = /^\[(hh?|mm?|ss?)\]/;
 /** Does this section describe a date? Scans outside quotes and escapes. */
 function looksLikeDate(body) {
     for (let i = 0; i < body.length; i += 1) {
@@ -122,6 +152,15 @@ function looksLikeDate(body) {
             i = end < 0 ? body.length : end;
             continue;
         }
+        if (ELAPSED_TOKEN.test(body.slice(i)))
+            return true;
+        if (ch === '[') {
+            // Any other bracket is a colour or a condition, and says nothing
+            // about whether this is a date.
+            const end = body.indexOf(']', i + 1);
+            i = end < 0 ? body.length : end;
+            continue;
+        }
         if (DATE_TOKEN.test(body.slice(i))) {
             // `m` alone is ambiguous with the thousands/number grammar only in
             // theory: a numeric pattern never contains a bare letter outside quotes.
@@ -150,9 +189,74 @@ function toDate(value) {
     }
     return null;
 }
-function renderDate(body, date) {
+/** The meridiem token a pattern carries, which puts `h` on a 12-hour clock. */
+function meridiemOf(body) {
+    for (let i = 0; i < body.length; i += 1) {
+        if (body[i] === '\\') {
+            i += 1;
+            continue;
+        }
+        if (body[i] === '"') {
+            const end = body.indexOf('"', i + 1);
+            i = end < 0 ? body.length : end;
+            continue;
+        }
+        const m = /^(AM\/PM|am\/pm|A\/P|a\/p)/.exec(body.slice(i));
+        if (m)
+            return m[1];
+    }
+    return null;
+}
+/**
+ * The finest unit a time pattern shows, in milliseconds, or null for a
+ * pattern that shows no time. Excel ROUNDS to it: 23:59:40 under `hh:mm`
+ * reads 00:00, and the date rolls with it where the pattern shows one.
+ */
+function finestUnit(body) {
+    let unit = null;
+    let sawHour = false;
+    const finer = (ms) => { unit = unit === null ? ms : Math.min(unit, ms); };
+    for (let i = 0; i < body.length; i += 1) {
+        if (body[i] === '\\') {
+            i += 1;
+            continue;
+        }
+        if (body[i] === '"') {
+            const end = body.indexOf('"', i + 1);
+            i = end < 0 ? body.length : end;
+            continue;
+        }
+        const fraction = /^\.(0+)/.exec(body.slice(i));
+        if (fraction && unit !== null) {
+            finer(Math.pow(10, 3 - fraction[1].length));
+            i += fraction[0].length - 1;
+            continue;
+        }
+        const m = DATE_TOKEN.exec(body.slice(i));
+        if (!m)
+            continue;
+        const token = m[1];
+        i += token.length - 1;
+        if (token === 'h' || token === 'hh') {
+            sawHour = true;
+            finer(3600000);
+        }
+        else if (token === 's' || token === 'ss')
+            finer(1000);
+        else if ((token === 'm' || token === 'mm') && sawHour)
+            finer(60000);
+    }
+    return unit;
+}
+function renderDate(body, date, serial) {
+    const unit = finestUnit(body);
+    if (unit !== null && unit > 0)
+        date = new Date(Math.round(date.getTime() / unit) * unit);
+    const meridiem = meridiemOf(body);
+    const hourOf = (d) => (meridiem ? ((d.getUTCHours() + 11) % 12) + 1 : d.getUTCHours());
     let out = '';
     let sawHour = false;
+    let sawSecond = false;
     for (let i = 0; i < body.length; i += 1) {
         const ch = body[i];
         if (ch === '\\') {
@@ -160,12 +264,33 @@ function renderDate(body, date) {
             i += 1;
             continue;
         }
+        const elapsed = ELAPSED_TOKEN.exec(body.slice(i));
+        if (elapsed) {
+            const token = elapsed[1];
+            i += elapsed[0].length - 1;
+            // Without a serial there is no duration to total, so the clock's own
+            // reading is the best answer; with one, the whole of it counts.
+            const days = serial ?? 0;
+            const total = token.startsWith('h') ? days * 24 : token.startsWith('m') ? days * 1440 : days * 86400;
+            const whole = Math.floor(Math.abs(total) + 1e-9) * (total < 0 ? -1 : 1);
+            out += token.length === 2 ? pad2(whole) : String(whole);
+            if (token.startsWith('h'))
+                sawHour = true;
+            continue;
+        }
         if (ch === '"') {
             const end = body.indexOf('"', i + 1);
             out += body.slice(i + 1, end < 0 ? body.length : end);
             i = end < 0 ? body.length : end;
             continue;
         }
+        const fraction = sawSecond ? /^\.(0+)/.exec(body.slice(i)) : null;
+        if (fraction) {
+            const digits = fraction[1].length;
+            out += `.${String(date.getUTCMilliseconds()).padStart(3, '0').slice(0, digits).padEnd(digits, '0')}`;
+            i += fraction[0].length - 1;
+            continue;
+        }
         const m = DATE_TOKEN.exec(body.slice(i));
         if (!m) {
             out += ch;
@@ -173,6 +298,8 @@ function renderDate(body, date) {
         }
         const token = m[1];
         i += token.length - 1;
+        if (token === 's' || token === 'ss')
+            sawSecond = true;
         switch (token) {
             case 'yyyy':
                 out += date.getUTCFullYear();
@@ -199,11 +326,11 @@ function renderDate(body, date) {
                 out += date.getUTCDate();
                 break;
             case 'hh':
-                out += pad2(date.getUTCHours());
+                out += pad2(hourOf(date));
                 sawHour = true;
                 break;
             case 'h':
-                out += date.getUTCHours();
+                out += hourOf(date);
                 sawHour = true;
                 break;
             case 'ss':
@@ -212,10 +339,22 @@ function renderDate(body, date) {
             case 's':
                 out += date.getUTCSeconds();
                 break;
+            // Excel prints what the token spells: AM/PM in full, A/P as the one
+            // letter, and each in the case it was written in.
             case 'AM/PM':
+                out += date.getUTCHours() < 12 ? 'AM' : 'PM';
+                break;
             case 'am/pm':
+                out += date.getUTCHours() < 12 ? 'am' : 'pm';
+                break;
             case 'A/P':
-                out += date.getUTCHours() < 12 ? 'AM' : 'PM';
+                out += date.getUTCHours() < 12 ? 'A' : 'P';
+                break;
+            case 'a/p':
+                out += date.getUTCHours() < 12 ? 'a' : 'p';
+                break;
+            case 'mmmmm':
+                out += MONTHS[date.getUTCMonth()].slice(0, 1);
                 break;
             // `m` and `mm` are MINUTES after an hour token, MONTHS otherwise. This
             // is the one piece of context the scanner carries, and getting it wrong
@@ -231,7 +370,105 @@ function renderDate(body, date) {
     }
     return out;
 }
-/** Pull a numeric section apart into literal text and digit placeholders. */
+const FRACTION = /^(?:([#0?]+)\s+)?([#0?]+)\/([#0?]+|\d+)$/;
+/** The plan for a fraction section, or null when it is not one. */
+function planFraction(body) {
+    // Only the bare shape reads as a fraction; anything with quoted text or an
+    // escape around it stays on the ordinary numeric path, where it always was.
+    const m = FRACTION.exec(body.trim());
+    if (!m)
+        return null;
+    const den = m[3];
+    return { int: m[1] ?? null, num: m[2], den, denLiteral: /^\d+$/.test(den) ? Number(den) : null };
+}
+/** The closest numerator and denominator, with the denominator capped. */
+function bestFraction(value, maxDen) {
+    // Stern-Brocot: take the mediant of the two bounding fractions until the
+    // denominator would pass the cap. Exact for anything that fits, and it
+    // cannot run longer than the cap.
+    let loNum = 0;
+    let loDen = 1;
+    let hiNum = 1;
+    let hiDen = 0;
+    let bestNum = Math.round(value);
+    let bestDen = 1;
+    let bestErr = Math.abs(value - bestNum);
+    for (let i = 0; i < 64; i += 1) {
+        const num = loNum + hiNum;
+        const den = loDen + hiDen;
+        if (den > maxDen)
+            break;
+        const mediant = num / den;
+        const err = Math.abs(value - mediant);
+        if (err < bestErr - 1e-12) {
+            bestErr = err;
+            bestNum = num;
+            bestDen = den;
+        }
+        if (err < 1e-12)
+            break;
+        if (mediant < value) {
+            loNum = num;
+            loDen = den;
+        }
+        else {
+            hiNum = num;
+            hiDen = den;
+        }
+    }
+    return { num: bestNum, den: bestDen };
+}
+/** A placeholder group as Excel pads it: `0` a zero, `?` a space, `#` nothing. */
+function padHolders(text, holders) {
+    if (text.length >= holders.length)
+        return text;
+    const filler = holders.includes('0') ? '0' : holders.includes('?') ? ' ' : '';
+    return filler ? filler.repeat(holders.length - text.length) + text : text;
+}
+/** One number through a fraction pattern. */
+function renderFraction(plan, value) {
+    const sign = value < 0 ? '-' : '';
+    const magnitude = Math.abs(value);
+    const whole = plan.int ? Math.floor(magnitude + 1e-12) : 0;
+    const rest = magnitude - whole;
+    const maxDen = plan.denLiteral ?? Math.pow(10, plan.den.length) - 1;
+    const found = plan.denLiteral
+        ? { num: Math.round(rest * plan.denLiteral), den: plan.denLiteral }
+        : bestFraction(rest, maxDen);
+    let num = found.num;
+    const den = found.den;
+    let carried = whole;
+    // Rounding up to a whole: 0.99 over `# ?/?` is 1, not 1/1.
+    if (den > 0 && num >= den) {
+        carried += Math.floor(num / den);
+        num %= den;
+    }
+    if (!plan.int) {
+        return `${sign}${padHolders(String(num + carried * den), plan.num)}/${padHolders(String(den), plan.den)}`;
+    }
+    const blanks = (holders) => (holders.includes('?') ? ' '.repeat(holders.length) : '');
+    const wholeText = carried === 0 && !plan.int.includes('0')
+        ? ' '.repeat(plan.int.includes('?') ? plan.int.length : 0)
+        : padHolders(String(carried), plan.int);
+    // No remainder: Excel leaves the fraction's width blank rather than
+    // printing 0/1, so a column of them still lines up.
+    const fraction = num === 0
+        ? `${blanks(plan.num)} ${blanks(plan.den)}`
+        : `${padHolders(String(num), plan.num)}/${padHolders(String(den), plan.den)}`;
+    return `${sign}${wholeText} ${fraction}`.replace(/\s+$/, '');
+}
+/**
+ * Pull a numeric section apart into literal text and digit placeholders.
+ *
+ * Literal text before the first digit is the prefix and after the last is
+ * the suffix. Literal text BETWEEN integer digits, as in `000-00-0000` or
+ * `(###) ###-####`, turns the integer side into a mask that the digits are
+ * laid into from the right, which is how Excel's Special formats work.
+ *
+ * `_x` (Excel: leave the width of x) and `*x` (fill the cell with x) both
+ * become one space here: text has no cell width to leave or fill, and one
+ * space is what keeps `_($* #,##0.00_)` reading as `$ 1,234.00`.
+ */
 function planNumeric(body) {
     let prefix = '';
     let suffix = '';
@@ -244,24 +481,35 @@ function planNumeric(body) {
     let scale = 1;
     let seenPlaceholder = false;
     let afterDecimal = false;
+    // The integer side as tokens, literal text included, until the decimal
+    // point. `pending` holds literal text after the last integer digit, which
+    // is part of the mask only if another digit follows it.
+    const mask = [];
+    let pending = '';
+    let maskHasLiteral = false;
+    const literal = (text) => {
+        if (!seenPlaceholder)
+            prefix += text;
+        else if (afterDecimal || scientific)
+            suffix += text;
+        else
+            pending += text;
+    };
     for (let i = 0; i < body.length; i += 1) {
         const ch = body[i];
         if (ch === '\\') {
-            const next = body[i + 1] ?? '';
-            if (seenPlaceholder)
-                suffix += next;
-            else
-                prefix += next;
+            literal(body[i + 1] ?? '');
+            i += 1;
+            continue;
+        }
+        if (ch === '_' || ch === '*') {
+            literal(' ');
             i += 1;
             continue;
         }
         if (ch === '"') {
             const end = body.indexOf('"', i + 1);
-            const text = body.slice(i + 1, end < 0 ? body.length : end);
-            if (seenPlaceholder)
-                suffix += text;
-            else
-                prefix += text;
+            literal(body.slice(i + 1, end < 0 ? body.length : end));
             i = end < 0 ? body.length : end;
             continue;
         }
@@ -273,8 +521,15 @@ function planNumeric(body) {
                 expPlaceholders += ch;
             else if (afterDecimal)
                 fracPlaceholders += ch;
-            else
+            else {
                 intPlaceholders += ch;
+                if (pending) {
+                    mask.push({ kind: 'lit', text: pending });
+                    maskHasLiteral = true;
+                    pending = '';
+                }
+                mask.push({ kind: 'digit', ch });
+            }
             continue;
         }
         if (ch === '.') {
@@ -294,10 +549,7 @@ function planNumeric(body) {
         }
         if (ch === '%') {
             percent = true;
-            if (seenPlaceholder)
-                suffix += '%';
-            else
-                prefix += '%';
+            literal('%');
             continue;
         }
         if ((ch === 'E' || ch === 'e') && /^[+-]/.test(body.slice(i + 1))) {
@@ -305,33 +557,74 @@ function planNumeric(body) {
             i += 1;
             continue;
         }
-        if (seenPlaceholder)
-            suffix += ch;
-        else
-            prefix += ch;
+        literal(ch);
     }
+    // Literal text after the last integer digit belongs to the suffix, before
+    // whatever the fraction and exponent added.
+    if (pending)
+        suffix = pending + suffix;
+    // A `?` on the integer side pads with a space, which the mask renderer
+    // does and the plain path (digits, grouping) does not.
+    const needsMask = maskHasLiteral || intPlaceholders.includes('?');
     return {
-        prefix, suffix, intPlaceholders, fracPlaceholders, expPlaceholders,
+        prefix, suffix, intPlaceholders, intMask: needsMask ? mask : null,
+        fracPlaceholders, expPlaceholders,
         useGrouping, scale, percent, scientific,
     };
 }
-function group(intText) {
-    return intText.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+/** Lay digits into a mask from the right: `000-00-0000` on 123456789 is
+ *  `123-45-6789`; digits left over go in front, missing ones follow the
+ *  placeholder's rule, so `###-####` on 1234 is `-1234` as Excel gives. */
+function renderMask(mask, digits) {
+    let out = '';
+    let at = digits.length;
+    for (let i = mask.length - 1; i >= 0; i -= 1) {
+        const token = mask[i];
+        if (token.kind === 'lit') {
+            out = token.text + out;
+            continue;
+        }
+        if (at > 0) {
+            at -= 1;
+            out = digits[at] + out;
+            continue;
+        }
+        if (token.ch === '0')
+            out = `0${out}`;
+        else if (token.ch === '?')
+            out = ` ${out}`;
+    }
+    return digits.slice(0, at) + out;
+}
+function group(intText, mark) {
+    return intText.replace(/\B(?=(\d{3})+(?!\d))/g, mark);
 }
-function renderNumeric(plan, value) {
+function renderNumeric(plan, value, marks) {
     let n = value;
     if (plan.percent)
         n *= 100;
     if (plan.scale !== 1)
         n /= plan.scale;
     if (plan.scientific) {
-        const text = n.toExponential(plan.fracPlaceholders.length);
-        // toExponential gives "1.23e+4"; Excel writes the exponent with at least
-        // as many digits as the pattern asked for.
-        const [mantissa = '', exponent = ''] = text.split('e');
-        const sign = exponent.startsWith('-') ? '-' : '+';
-        const digits = exponent.replace(/^[+-]/, '').padStart(plan.expPlaceholders.length || 1, '0');
-        return `${plan.prefix}${mantissa}E${sign}${digits}${plan.suffix}`;
+        // The integer placeholders set the STEP of the exponent, which is what
+        // makes `##0.0E+0` engineering notation: three of them means the
+        // exponent moves in threes and the mantissa carries up to three integer
+        // digits, so 12345 reads 12.3E+3 rather than 1.2E+4. The everyday
+        // `0.00E+00` has one, and is the ordinary scientific form.
+        const step = Math.max(1, plan.intPlaceholders.length);
+        const decimals = plan.fracPlaceholders.length;
+        let exponent = n === 0 ? 0 : Math.floor(Math.log10(Math.abs(n)));
+        exponent = Math.floor(exponent / step) * step;
+        let mantissa = n / Math.pow(10, exponent);
+        // Rounding can carry the mantissa over its own width: 999.95 with one
+        // decimal is 1000.0, which is 1.0 a step further out.
+        if (Math.abs(Number(mantissa.toFixed(decimals))) >= Math.pow(10, step)) {
+            mantissa /= Math.pow(10, step);
+            exponent += step;
+        }
+        const sign = exponent < 0 ? '-' : '+';
+        const digits = String(Math.abs(exponent)).padStart(plan.expPlaceholders.length || 1, '0');
+        return `${plan.prefix}${mantissa.toFixed(decimals)}E${sign}${digits}${plan.suffix}`;
     }
     const decimals = plan.fracPlaceholders.length;
     const fixed = Math.abs(n).toFixed(decimals);
@@ -340,12 +633,17 @@ function renderNumeric(plan, value) {
     // leading zero entirely when the pattern is all `#`.
     const minInt = plan.intPlaceholders.split('').filter((c) => c === '0').length;
     let intText = rawInt;
-    if (intText.length < minInt)
-        intText = intText.padStart(minInt, '0');
-    if (minInt === 0 && intText === '0' && plan.intPlaceholders.length > 0)
-        intText = '';
-    if (plan.useGrouping && intText !== '')
-        intText = group(intText);
+    if (plan.intMask) {
+        intText = renderMask(plan.intMask, rawInt === '0' && minInt === 0 ? '' : rawInt);
+    }
+    else {
+        if (intText.length < minInt)
+            intText = intText.padStart(minInt, '0');
+        if (minInt === 0 && intText === '0' && plan.intPlaceholders.length > 0)
+            intText = '';
+        if (plan.useGrouping && intText !== '')
+            intText = group(intText, marks.group);
+    }
     // Trim optional decimals from the right: `0.0#` on 1.5 gives "1.5", not
     // "1.50". A `0` placeholder is never trimmed, a `#` always may be, and a
     // `?` becomes a space so columns line up.
@@ -358,7 +656,7 @@ function renderNumeric(plan, value) {
             break;
         fracText = kind === '?' ? `${fracText.slice(0, i)} ` : fracText.slice(0, i);
     }
-    const body = fracText === '' ? intText : `${intText}.${fracText}`;
+    const body = fracText === '' ? intText : `${intText}${marks.decimal}${fracText}`;
     // `#` on zero prints nothing, which is how "hide zeros" patterns work. The
     // fallback below is only for a pattern with no digit placeholders at all.
     return plan.prefix + body + plan.suffix;
@@ -368,6 +666,32 @@ function renderNumeric(plan, value) {
 function hasPlaceholders(plan) {
     return plan.intPlaceholders !== '' || plan.fracPlaceholders !== '';
 }
+/** The text section: `@` is the value, quotes and backslashes wrap
+ *  literals, `_x` and `*x` are one space, as on the numeric side. */
+function renderText(body, value) {
+    let out = '';
+    for (let i = 0; i < body.length; i += 1) {
+        const ch = body[i];
+        if (ch === '\\') {
+            out += body[i + 1] ?? '';
+            i += 1;
+            continue;
+        }
+        if (ch === '_' || ch === '*') {
+            out += ' ';
+            i += 1;
+            continue;
+        }
+        if (ch === '"') {
+            const end = body.indexOf('"', i + 1);
+            out += body.slice(i + 1, end < 0 ? body.length : end);
+            i = end < 0 ? body.length : end;
+            continue;
+        }
+        out += ch === '@' ? value : ch;
+    }
+    return out;
+}
 /** Excel's General: up to 11 significant digits, no trailing zeros. */
 function general(value) {
     if (typeof value === 'number') {
@@ -386,8 +710,12 @@ function general(value) {
  * ten thousand cells sharing one format parses it once.
  */
 const cache = new Map();
-export function compileNumberFormat(pattern) {
-    const hit = cache.get(pattern);
+export const INVARIANT_MARKS = { decimal: '.', group: ',' };
+export function compileNumberFormat(pattern, marks = INVARIANT_MARKS) {
+    // The marks join the cache key, so a sheet showing one locale does not
+    // serve its rendered numbers to a sheet showing another.
+    const key = marks === INVARIANT_MARKS ? pattern : `${pattern}\u0000${marks.decimal}${marks.group}`;
+    const hit = cache.get(key);
     if (hit)
         return hit;
     const sections = splitSections(pattern).map(parseSection);
@@ -395,15 +723,22 @@ export function compileNumberFormat(pattern) {
     const negative = sections[1];
     const zero = sections[2];
     const text = sections[3];
+    const conditional = sections.some((sec) => sec.condition);
     // Plans are built once here, not per value.
     const plans = new Map();
+    const fractions = new Map();
     const dateFlags = new Map();
     for (const s of sections) {
         if (!s)
             continue;
         const isDate = looksLikeDate(s.body);
         dateFlags.set(s, isDate);
-        if (!isDate)
+        if (isDate)
+            continue;
+        const fraction = planFraction(s.body);
+        if (fraction)
+            fractions.set(s, fraction);
+        else
             plans.set(s, planNumeric(s.body));
     }
     const compiled = {
@@ -413,15 +748,15 @@ export function compileNumberFormat(pattern) {
                 return { text: general(value) };
             }
             if (typeof value === 'string' && value !== '') {
-                const section = text ?? positive;
+                // Excel's FOURTH section is the one that governs text. With one, `@`
+                // puts the text where it stands and a section without an `@` shows
+                // only its own literals, which is what makes `;;;` hide a cell and
+                // `;;;"n/a"` show n/a whatever was typed. With no fourth section the
+                // text is shown as it is, even under a numeric pattern like `0.00`.
+                const section = text ?? (positive?.body.includes('@') ? positive : undefined);
                 if (!section)
                     return { text: value };
-                // The text section substitutes @ for the value; without an @ the
-                // section's literal text is all you get.
-                const body = section.body.includes('@')
-                    ? section.body.replace(/@/g, value).replace(/"/g, '')
-                    : value;
-                return { text: body, color: section.color };
+                return { text: renderText(section.body, section.body.includes('@') ? value : ''), color: section.color };
             }
             if (value === null || value === undefined || value === '')
                 return { text: '' };
@@ -436,55 +771,113 @@ export function compileNumberFormat(pattern) {
                 return { text: String(value) };
             }
             // Pick the section. Two sections means the second covers zero too.
-            let section = positive;
-            if (n < 0 && negative)
-                section = negative;
-            else if (n === 0 && zero)
-                section = zero;
+            // With conditions, the first section whose condition the value passes
+            // wins and an unconditioned one is the fallback, as in Excel's
+            // `[<=9999999]###-####;(###) ###-####`.
+            let section;
+            if (conditional) {
+                section = sections.find((sec) => sec && (sec.condition ? passes(sec.condition, n) : true));
+            }
+            else {
+                section = positive;
+                if (n < 0 && negative)
+                    section = negative;
+                else if (n === 0 && zero)
+                    section = zero;
+            }
             if (!section)
                 return { text: general(value) };
             if (dateFlags.get(section)) {
                 const d = toDate(value);
+                // `n` is the serial the value stands for, which is what an elapsed
+                // token totals: 1.5 is a day and a half, [h]:mm reads 36:00.
                 return d
-                    ? { text: renderDate(section.body, d), color: section.color }
+                    ? { text: renderDate(section.body, d, n), color: section.color }
                     : { text: general(value) };
             }
+            const asFraction = fractions.get(section);
+            if (asFraction) {
+                // A negative with its own section is rendered from its magnitude,
+                // as everywhere else: the section supplies the sign.
+                const usingNegative = n < 0 && section === negative && !conditional;
+                return { text: renderFraction(asFraction, usingNegative ? Math.abs(n) : n), color: section.color };
+            }
             const plan = plans.get(section);
             if (!hasPlaceholders(plan)) {
+                // `@` is the text placeholder, and a NUMBER in a cell formatted as
+                // Text is still shown by Excel as the number rather than as the
+                // placeholder: `@` over 5 reads 5, not @.
+                if (section.body.includes('@')) {
+                    return { text: renderText(section.body, general(value)), color: section.color };
+                }
                 return { text: plan.prefix + plan.suffix, color: section.color };
             }
             // A negative shown by its own section renders its ABSOLUTE value: the
             // section supplies the sign, usually as parentheses or a literal minus.
-            const usingNegativeSection = n < 0 && section === negative;
+            const usingNegativeSection = n < 0 && section === negative && !conditional;
             const magnitude = usingNegativeSection ? Math.abs(n) : n;
-            let out = renderNumeric(plan, magnitude);
+            let out = renderNumeric(plan, magnitude, marks);
             // With no negative section, put the sign back on.
             if (n < 0 && !usingNegativeSection && !out.startsWith('-'))
                 out = `-${out}`;
             return { text: out, color: section.color };
         },
     };
-    cache.set(pattern, compiled);
+    cache.set(key, compiled);
     return compiled;
 }
 /** Format one value against a pattern. Convenience over compile-then-call. */
 export function formatWithPattern(value, pattern) {
     return compileNumberFormat(pattern).format(value).text;
 }
-/** The presets behind Ctrl+Shift+1 through 6. */
+/** The presets behind Ctrl+Shift+1 through 6 and the ribbon's $ % , buttons.
+ *  Percent is Excel's Percent Style, no decimals: 0.425 reads 43%. */
 export const FORMAT_PRESETS = {
     general: 'General',
     number: '#,##0.00',
     time: 'h:mm AM/PM',
     date: 'yyyy-mm-dd',
     currency: '$#,##0.00;($#,##0.00)',
-    percent: '0.00%',
+    accounting: '_($* #,##0.00_);_($* (#,##0.00);_($* "-"??_);_(@_)',
+    percent: '0%',
     scientific: '0.00E+00',
 };
+/** What the ribbon's Number Format combo applies for a category. Excel's
+ *  "Percentage" there carries two decimals where its % button carries none;
+ *  the other entries are the presets. */
+export const FORMAT_CATEGORY_PATTERNS = {
+    ...FORMAT_PRESETS,
+    percent: '0.00%',
+};
+/** Excel's Special category: fixed-shape numbers laid into a mask. */
+export const SPECIAL_FORMATS = {
+    zip: { label: 'Zip Code', pattern: '00000' },
+    zip4: { label: 'Zip Code + 4', pattern: '00000-0000' },
+    phone: { label: 'Phone Number', pattern: '[<=9999999]###-####;(###) ###-####' },
+    ssn: { label: 'Social Security Number', pattern: '000-00-0000' },
+};
+/** The pattern Excel's Accounting category spells for a symbol and a
+ *  number of decimals; an empty symbol is its "None". */
+export function accountingPattern(symbol, decimals) {
+    const digits = `#,##0${decimals > 0 ? '.' + '0'.repeat(decimals) : ''}`;
+    const sym = symbol === '$' ? '$* ' : symbol ? `${JSON.stringify(symbol)}* ` : '* ';
+    return `_(${sym}${digits}_);_(${sym}(${digits});_(${sym}"-"${'?'.repeat(decimals)}_);_(@_)`;
+}
+/** The symbol and decimals an accounting pattern was built from, or null
+ *  when the pattern is not one `accountingPattern` would spell. */
+export function accountingParts(fmt) {
+    if (!fmt)
+        return null;
+    const m = /^_\((?:"([^"]*)"|\$)?\* #,##0(\.0+)?_\);/.exec(fmt);
+    if (!m)
+        return null;
+    const symbol = m[1] !== undefined ? m[1] : fmt.startsWith('_($') ? '$' : '';
+    return { symbol, decimals: m[2] ? m[2].length - 1 : 0 };
+}
 /**
  * Which of Excel's categories a pattern belongs to, with the decimals and
  * separator it carries, so the ribbon's combo can say "Percentage" for a
- * cell holding `0%` (a typed 12%) as well as for the preset's `0.00%`, and
+ * cell holding `0%` (a typed 12%) as well as for the combo's `0.00%`, and
  * Format Cells can open on the right category. A pattern that is none of
  * them is 'custom'.
  */
@@ -492,6 +885,10 @@ export function formatCategory(fmt) {
     if (!fmt || fmt === 'General')
         return { category: 'general', decimals: 2, thousands: true };
     const decimals = fmt.match(/\.(0+)/)?.[1]?.length ?? 0;
+    if (accountingParts(fmt))
+        return { category: 'accounting', decimals, thousands: true };
+    if (Object.values(SPECIAL_FORMATS).some((sp) => sp.pattern === fmt))
+        return { category: 'special', decimals: 0, thousands: false };
     if (/E\+/i.test(fmt))
         return { category: 'scientific', decimals, thousands: false };
     if (/%$/.test(fmt))