documonster 0.20.1 → 0.20.2

package/dist/esm/modules/formula/functions/text.js

@@ -4,7 +4,8 @@
 import { argToNumber, checkError, excelWildcardToRegex } from "./_shared.js";
 import { DEFAULT_FUNCTION_CONTEXT } from "../runtime/function-context.js";
 import { RVKind, ERRORS, isError, isArray, toNumberRV, toStringRV, toBooleanRV, topLeft, rvNumber, rvString, rvBoolean, rvArray } from "../runtime/values.js";
-import { excelToDate } from "../../../utils/utils.base.js";
+import { parseNumberFormat } from "../../../utils/number-format.js";
+import { tryRenderNumberFormat } from "../../../utils/number-format-render.js";
 // ============================================================================
 // Local utility
 // ============================================================================
@@ -413,643 +414,34 @@ export function fnTEXT(args, context = DEFAULT_FUNCTION_CONTEXT) {
         return e1;
     }
     const fmt = toStringRV(topLeft(args[1]));
-    // "@" format = return text as-is
-    if (fmt === "@") {
+    // The format is read and rendered by the same code that produces a cell's display text, so
+    // `TEXT(x, f)` and a cell holding `x` formatted with `f` cannot disagree. Where the cell would show
+    // hashes — a date past 9999, a negative time — `TEXT` is `#VALUE!`, as in Excel.
+    const render = (value) => {
+        const text = tryRenderNumberFormat(fmt, value, { date1904: context.date1904 });
+        return text === undefined ? ERRORS.VALUE : rvString(text);
+    };
+    // A logical is shown as itself under any format: `TEXT(TRUE, "0")` is `TRUE`.
+    if (rawVal.kind === RVKind.Boolean) {
         return rvString(toStringRV(rawVal));
     }
-    // Conditional sections: positive;negative;zero;text (up to 4 parts).
-    // Text input — when the value is a String/Boolean that doesn't parse
-    // as a number — is routed to the 4th section if present. Without this
-    // early dispatch, the later `toNumberRV(rawVal)` would #VALUE! and
-    // `TEXT("hi", "0;-0;0;@")` could never reach the 4th section.
-    const sections = splitFormatSections(fmt);
-    const isTextInput = rawVal.kind === RVKind.String;
-    if (isTextInput && sections.length >= 4) {
-        // The 4th section formats the text value — `@` is a placeholder
-        // that re-emits the source string (like Excel's `@` metacharacter).
-        return rvString(sections[3].replace(/@/g, toStringRV(rawVal)));
+    if (rawVal.kind === RVKind.String) {
+        // A four-section format formats text with its fourth section. Otherwise text that reads as a number is that
+        // number, and any other text goes through the text section if there is one — or comes back unchanged, which
+        // is what Excel does with `TEXT("abc", "0.00")` rather than failing.
+        if (parseNumberFormat(fmt).sections.length < 4) {
+            const num = toNumberRV(rawVal);
+            if (!isError(num)) {
+                return render(num.value);
+            }
+        }
+        return render(toStringRV(rawVal));
     }
     const valRV = toNumberRV(rawVal);
     if (isError(valRV)) {
         return valRV;
     }
-    const val = valRV.value;
-    let activeFmt;
-    if (sections.length >= 3) {
-        activeFmt = val > 0 ? sections[0] : val < 0 ? sections[1] : sections[2];
-    }
-    else if (sections.length === 2) {
-        activeFmt = val >= 0 ? sections[0] : sections[1];
-    }
-    else {
-        activeFmt = sections[0];
-    }
-    // For negative section, use absolute value (sign is in the format)
-    const useVal = sections.length >= 2 && val < 0 ? Math.abs(val) : val;
-    return rvString(formatWithCode(useVal, activeFmt, rawVal, context.date1904));
-}
-/**
- * Split format string on `;` separators, respecting quoted strings.
- */
-function splitFormatSections(fmt) {
-    const sections = [];
-    let current = "";
-    let inQuotes = false;
-    for (let i = 0; i < fmt.length; i++) {
-        if (fmt[i] === '"') {
-            inQuotes = !inQuotes;
-            current += fmt[i];
-        }
-        else if (fmt[i] === ";" && !inQuotes) {
-            sections.push(current);
-            current = "";
-        }
-        else {
-            current += fmt[i];
-        }
-    }
-    sections.push(current);
-    return sections;
-}
-/**
- * Format a number using a single format code section.
- */
-function formatWithCode(val, fmt, rawVal, date1904) {
-    const upper = fmt.toUpperCase();
-    // Date/time formats — detect by presence of date/time tokens
-    if (upper.includes("YYYY") ||
-        upper.includes("YY") ||
-        upper.includes("MMMM") ||
-        upper.includes("MMM") ||
-        upper.includes("DDDD") ||
-        upper.includes("DDD") ||
-        upper.includes("DD") ||
-        /(?:^|[^H])MM(?!M)/.test(upper) ||
-        /(?:^|[^M])M(?!M)/.test(upper.replace(/MMMM|MMM/g, "")) ||
-        upper.includes("HH") ||
-        /(?:^|[^H])H(?!H)/.test(upper) ||
-        upper.includes("SS") ||
-        upper.includes("AM/PM") ||
-        upper.includes("A/P")) {
-        return formatDate(val, fmt, date1904);
-    }
-    // Percentage format
-    if (fmt.includes("%")) {
-        const stripped = fmt.replace(/[^0#.%,]/g, "");
-        const dotIdx = stripped.indexOf(".");
-        const afterDot = dotIdx >= 0
-            ? stripped
-                .slice(dotIdx + 1)
-                .replace(/%/g, "")
-                .replace(/,/g, "")
-            : "";
-        const decimals = afterDot.length;
-        const pctVal = val * 100;
-        let result = pctVal.toFixed(decimals);
-        if (fmt.includes(",")) {
-            const parts = result.split(".");
-            parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-            result = parts.join(".");
-        }
-        return result + "%";
-    }
-    // Scientific notation: 0.00E+00
-    if (/[0#]\.?[0#]*E[+-][0#]+/i.test(fmt)) {
-        return formatScientific(val, fmt);
-    }
-    // Fraction format: # ?/? or # ??/??
-    if (/[?]+\/[?]+/.test(fmt)) {
-        return formatFraction(val, fmt);
-    }
-    // Number format with 0 and #
-    if (fmt.includes("0") || fmt.includes("#")) {
-        return formatNumber(val, fmt);
-    }
-    // Literal-only section (no numeric placeholders). Excel emits the
-    // format string verbatim, substituting any `@` with the stringified
-    // value. This matters for 3- and 4-section formats like
-    // `"pos;neg;zero"` — the selected section has no `#`/`0` but should
-    // still appear in the output.
-    return fmt.replace(/@/g, String(val));
-}
-/**
- * Format number using #, 0, comma patterns.
- */
-/**
- * Format number using #, 0, comma patterns.
- *
- * The implementation tokenises the pattern left-to-right so that *any*
- * literal character (parentheses, `+`/`-`, currency symbols, letters in
- * quoted `"..."` segments, backslash-escaped characters, leading/trailing
- * punctuation) is preserved in its original position. The previous
- * implementation stripped everything that wasn't `0 # . ,` before analysis
- * and tried to re-inject a handful of literals afterwards, which caused
- * formats like `0;(0)` (→ "(5)" for -5) and `#,##0.00;-#,##0.00` to drop
- * their negative-section literal characters entirely.
- */
-function formatNumber(val, fmt) {
-    // Strip `[color]` and `[condition]` tags up front (Excel-style
-    // decorations that don't affect the numeric layout in our engine).
-    const cleanFmt = fmt.replace(/\[[^\]]*\]/g, "");
-    const tokens = [];
-    for (let i = 0; i < cleanFmt.length; i++) {
-        const ch = cleanFmt[i];
-        if (ch === '"') {
-            // Quoted literal run: consume until the closing quote.
-            let j = i + 1;
-            let buf = "";
-            while (j < cleanFmt.length && cleanFmt[j] !== '"') {
-                buf += cleanFmt[j];
-                j++;
-            }
-            tokens.push({ kind: "literal", text: buf });
-            i = j; // skip closing quote
-            continue;
-        }
-        if (ch === "\\" && i + 1 < cleanFmt.length) {
-            // Backslash escape: next character is a literal.
-            tokens.push({ kind: "literal", text: cleanFmt[i + 1] });
-            i++;
-            continue;
-        }
-        if (ch === "0" || ch === "#") {
-            tokens.push({ kind: "digit", char: ch });
-            continue;
-        }
-        if (ch === ".") {
-            tokens.push({ kind: "dot" });
-            continue;
-        }
-        if (ch === ",") {
-            tokens.push({ kind: "comma" });
-            continue;
-        }
-        // Any other character is a literal (space, parentheses, currency
-        // symbol, sign, hyphen, etc.).
-        tokens.push({ kind: "literal", text: ch });
-    }
-    // Count integer/fraction digit slots and decide whether to group.
-    // Trailing commas after the last integer digit token — before the
-    // decimal point or end of pattern — act as a "scale by 1/1000^k"
-    // multiplier (Excel's "thousands scaling"), not thousand separators.
-    // Example: `#,##0,` → 1,234,567 → "1,235" (divide by 1000).
-    // Example: `#,##0,,` → 1,234,567,890 → "1,234" (divide by 1,000,000).
-    let sawDot = false;
-    const intDigitSlots = [];
-    const fracDigitSlots = [];
-    let hasGrouping = false;
-    // Scan for trailing commas that sit strictly after the last integer
-    // digit slot but before any dot or fractional slot. Each such comma
-    // divides the value by 1000. Scan from end-of-pattern backward to
-    // locate them.
-    let scalingFactor = 1;
-    {
-        // Find the last integer digit-slot index.
-        let lastIntDigitIdx = -1;
-        let dotIdx = -1;
-        for (let i = 0; i < tokens.length; i++) {
-            const t = tokens[i];
-            if (t.kind === "dot") {
-                dotIdx = i;
-                break;
-            }
-            if (t.kind === "digit") {
-                lastIntDigitIdx = i;
-            }
-        }
-        // Trailing commas live after `lastIntDigitIdx` and strictly before
-        // `dotIdx` (if present). They must be adjacent — only run-of-commas
-        // directly abutting the last integer digit count as scaling.
-        if (lastIntDigitIdx !== -1) {
-            const stopBefore = dotIdx === -1 ? tokens.length : dotIdx;
-            let k = lastIntDigitIdx + 1;
-            while (k < stopBefore && tokens[k].kind === "comma") {
-                scalingFactor *= 1000;
-                // Remove this comma so later logic doesn't treat it as a
-                // thousand-separator or literal artefact. We mutate the token
-                // to a no-op literal with empty text.
-                tokens[k] = { kind: "literal", text: "" };
-                k++;
-            }
-        }
-    }
-    // Apply the scaling before any other formatting work.
-    const scaledVal = val / scalingFactor;
-    for (const t of tokens) {
-        if (t.kind === "dot") {
-            sawDot = true;
-            continue;
-        }
-        if (t.kind === "digit") {
-            if (sawDot) {
-                fracDigitSlots.push(t.char);
-            }
-            else {
-                intDigitSlots.push(t.char);
-            }
-            continue;
-        }
-        if (t.kind === "comma" && !sawDot) {
-            // A comma between digit slots means "thousands grouping".
-            hasGrouping = true;
-        }
-    }
-    if (intDigitSlots.length === 0 && fracDigitSlots.length === 0) {
-        return fmt; // Nothing to format; return the (raw) pattern.
-    }
-    // Round to the requested fractional precision.
-    const rounded = roundHalfAwayFromZeroFmt(scaledVal, fracDigitSlots.length);
-    const sign = rounded < 0 ? "-" : "";
-    const absStr = Math.abs(rounded).toFixed(fracDigitSlots.length);
-    const [intPartRaw, fracPart = ""] = absStr.split(".");
-    let intPart = intPartRaw;
-    // Pad the integer part to satisfy mandatory `0` slots.
-    const mandatoryInt = intDigitSlots.filter(s => s === "0").length;
-    if (intPart.length < mandatoryInt) {
-        intPart = intPart.padStart(mandatoryInt, "0");
-    }
-    // Apply thousand grouping if the pattern requested it.
-    let groupedInt = intPart;
-    if (hasGrouping) {
-        groupedInt = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-    }
-    // Walk the tokens again and materialise output, interleaving the
-    // integer run, decimal point, and fractional run with literals.
-    let out = "";
-    let intCursor = 0; // index into groupedInt (right-to-left on integer digits)
-    // We emit integer digits in source order using a trick: scan tokens
-    // left-to-right; the first integer digit slot consumes `groupedInt[0]`
-    // if integer has more digits than slots all extras come out before the
-    // first digit slot (Excel overflow rule).
-    const totalIntSlots = intDigitSlots.length;
-    // Determine how much "overflow" we need to prepend. Overflow digits
-    // appear right before the first digit token we encounter.
-    const overflowDigits = Math.max(0, groupedInt.length - totalIntSlots);
-    let fracCursor = 0;
-    let emittedOverflow = false;
-    let firstDigitTokenIdx = -1;
-    for (let k = 0; k < tokens.length; k++) {
-        if (tokens[k].kind === "digit") {
-            // We only care about the first *integer* digit token — one that
-            // comes before the dot. If the pattern has no integer slots, we
-            // still need to emit any overflow somewhere; pick the first digit
-            // token regardless.
-            firstDigitTokenIdx = k;
-            break;
-        }
-        if (tokens[k].kind === "dot") {
-            break;
-        }
-    }
-    for (let k = 0; k < tokens.length; k++) {
-        const t = tokens[k];
-        if (t.kind === "literal") {
-            out += t.text;
-            continue;
-        }
-        if (t.kind === "dot") {
-            if (fracDigitSlots.length > 0 || fracPart.length > 0) {
-                out += ".";
-            }
-            continue;
-        }
-        if (t.kind === "comma") {
-            // Grouping commas are consumed by the integer-build step above,
-            // so trailing commas here are literal (unusual but valid).
-            continue;
-        }
-        // digit token
-        if (sawDotAt(tokens, k)) {
-            // fractional slot
-            if (fracCursor < fracPart.length) {
-                out += fracPart[fracCursor];
-            }
-            else if (t.char === "0") {
-                out += "0";
-            }
-            fracCursor++;
-            continue;
-        }
-        // integer slot
-        if (k === firstDigitTokenIdx && !emittedOverflow) {
-            if (overflowDigits > 0) {
-                out += groupedInt.slice(0, overflowDigits);
-            }
-            emittedOverflow = true;
-        }
-        const slotIdx = intCursor;
-        // Right-align the integer into the digit slots: leading `#` slots
-        // emit nothing when the value is shorter than the pattern, and
-        // leading `0` slots pad with a zero. Previously the logic treated
-        // every slot as if the integer started at slot 0 (left-align),
-        // which made `TEXT(0, "#,##0")` produce "00" instead of "0".
-        //
-        // The number of "padding" slots that must appear before the first
-        // real digit equals `totalIntSlots − groupedInt.length` when that
-        // value is positive (overflow path zeroes it out since we already
-        // prepended the overflow digits before the first slot).
-        const paddingSlots = overflowDigits > 0 ? 0 : Math.max(0, totalIntSlots - groupedInt.length);
-        const srcIdx = overflowDigits + slotIdx - paddingSlots;
-        if (srcIdx >= 0 && srcIdx < groupedInt.length) {
-            out += groupedInt[srcIdx];
-        }
-        else if (t.char === "0") {
-            out += "0";
-        }
-        intCursor++;
-    }
-    return sign + out;
-}
-/**
- * Did a dot token appear at any index < k in `tokens`? Used to classify
- * each digit slot as integer vs fractional during the emit pass.
- */
-function sawDotAt(tokens, k) {
-    for (let i = 0; i < k; i++) {
-        if (tokens[i].kind === "dot") {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Round `val` to `decimals` fractional digits using Excel's half-away-
- * from-zero convention (the same rule `formatNumber`'s caller relies on
- * to keep `-0.5` displaying as `"-1"` instead of `"0"`).
- */
-function roundHalfAwayFromZeroFmt(val, decimals) {
-    if (!isFinite(val) || decimals < 0) {
-        return val;
-    }
-    const factor = Math.pow(10, decimals);
-    return ((val < 0 ? -1 : 1) * Math.round(Math.abs(val) * factor)) / factor;
-}
-/**
- * Format a number in scientific notation: 0.00E+00
- */
-function formatScientific(val, fmt) {
-    const upper = fmt.toUpperCase();
-    const eIdx = upper.indexOf("E");
-    const beforeE = fmt.slice(0, eIdx);
-    const afterE = fmt.slice(eIdx + 1);
-    // Count decimal places in mantissa
-    const dotIdx = beforeE.indexOf(".");
-    const mantissaDecimals = dotIdx >= 0 ? beforeE.slice(dotIdx + 1).replace(/[^0#]/g, "").length : 0;
-    // Count exponent digits
-    const expSign = afterE[0] === "+" || afterE[0] === "-" ? afterE[0] : "+";
-    const expDigits = afterE.replace(/[^0#]/g, "").length;
-    const exp = val === 0 ? 0 : Math.floor(Math.log10(Math.abs(val)));
-    const mantissa = val / Math.pow(10, exp);
-    const expStr = (exp >= 0 && expSign === "+" ? "+" : exp < 0 ? "-" : "") +
-        String(Math.abs(exp)).padStart(expDigits, "0");
-    return mantissa.toFixed(mantissaDecimals) + "E" + expStr;
-}
-/**
- * Format a number as a fraction: "# ?/?" or "# ??/??"
- */
-function formatFraction(val, fmt) {
-    const whole = Math.floor(Math.abs(val));
-    const frac = Math.abs(val) - whole;
-    const sign = val < 0 ? "-" : "";
-    if (frac === 0) {
-        if (fmt.includes("#") || fmt.includes("0")) {
-            return sign + whole + "      ";
-        }
-        return sign + whole + " 0/1";
-    }
-    // Determine max denominator from ? count
-    const slashIdx = fmt.indexOf("/");
-    const denomPattern = fmt.slice(slashIdx + 1).replace(/[^?0#]/g, "");
-    const maxDenom = Math.pow(10, denomPattern.length) - 1;
-    // Find best fraction approximation
-    let bestNum = 0;
-    let bestDen = 1;
-    let bestError = Math.abs(frac);
-    for (let d = 1; d <= maxDenom; d++) {
-        const n = Math.round(frac * d);
-        const error = Math.abs(frac - n / d);
-        if (error < bestError) {
-            bestError = error;
-            bestNum = n;
-            bestDen = d;
-            if (error === 0) {
-                break;
-            }
-        }
-    }
-    const hasWholePart = fmt.indexOf("?") > 0 && fmt[0] !== "?" && fmt[0] !== "/";
-    if (hasWholePart) {
-        const numStr = String(bestNum).padStart(denomPattern.length, " ");
-        const denStr = String(bestDen).padStart(denomPattern.length, " ");
-        return sign + (whole > 0 ? whole + " " : "") + numStr + "/" + denStr;
-    }
-    return sign + (whole * bestDen + bestNum) + "/" + bestDen;
-}
-/**
- * Day name arrays for date formatting.
- */
-const DAY_NAMES_FULL = [
-    "Sunday",
-    "Monday",
-    "Tuesday",
-    "Wednesday",
-    "Thursday",
-    "Friday",
-    "Saturday"
-];
-const DAY_NAMES_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-const MONTH_NAMES_FULL = [
-    "January",
-    "February",
-    "March",
-    "April",
-    "May",
-    "June",
-    "July",
-    "August",
-    "September",
-    "October",
-    "November",
-    "December"
-];
-const MONTH_NAMES_SHORT = [
-    "Jan",
-    "Feb",
-    "Mar",
-    "Apr",
-    "May",
-    "Jun",
-    "Jul",
-    "Aug",
-    "Sep",
-    "Oct",
-    "Nov",
-    "Dec"
-];
-/**
- * Format a numeric Excel serial date with a date/time format code.
- *
- * In the native value system, dates are always numbers (serial values).
- * We always use excelToDate() to convert and then read UTC fields so the
- * output does not drift by a day in timezones west of UTC.
- */
-/**
- * Format a serial-date value using an Excel-style pattern.
- *
- * Unlike a naive multi-pass regex approach, this implementation tokenises
- * the pattern in a single left-to-right sweep and disambiguates the
- * overloaded `m` / `mm` token by looking at its neighbours:
- *
- *   - `mm` after `h:` or before `:ss` is rendered as **minutes**
- *   - otherwise `mm` is rendered as **month**
- *
- * Without this, a mixed format like `"yyyy-mm-dd hh:mm:ss"` would render
- * the time's minutes as months (both tokens fire the same regex), giving
- * garbage like `"2023-06-15 14:06:45"` for a timestamp at 14:30:45.
- */
-function formatDate(val, fmt, date1904) {
-    const d = excelToDate(val, date1904);
-    const year = d.getUTCFullYear();
-    const month0 = d.getUTCMonth();
-    const dayN = d.getUTCDate();
-    const dow = d.getUTCDay();
-    const fracDay = val % 1;
-    const totalSeconds = Math.round(Math.abs(fracDay) * 86400);
-    const hours = Math.floor(totalSeconds / 3600) % 24;
-    const minutes = Math.floor(totalSeconds / 60) % 60;
-    const seconds = totalSeconds % 60;
-    const hasAmPmToken = /AM\/PM/i.test(fmt) || /A\/P/i.test(fmt);
-    const h12 = hours % 12 === 0 ? 12 : hours % 12;
-    const ampm = hours < 12 ? "AM" : "PM";
-    const ap = hours < 12 ? "A" : "P";
-    const runs = [];
-    let i = 0;
-    while (i < fmt.length) {
-        const ch = fmt[i];
-        const lo = ch.toLowerCase();
-        // Handle two-char literals that must not tokenise as letters
-        if (fmt.slice(i, i + 5).toUpperCase() === "AM/PM") {
-            runs.push({ kind: "literal", text: ampm });
-            i += 5;
-            continue;
-        }
-        if (fmt.slice(i, i + 3).toUpperCase() === "A/P") {
-            runs.push({ kind: "literal", text: ap });
-            i += 3;
-            continue;
-        }
-        if (lo === "y" || lo === "m" || lo === "d" || lo === "h" || lo === "s") {
-            let j = i + 1;
-            while (j < fmt.length && fmt[j].toLowerCase() === lo) {
-                j++;
-            }
-            runs.push({ kind: "letters", lower: lo, count: j - i });
-            i = j;
-            continue;
-        }
-        // Literal: consume until the next token-letter (to keep literal runs
-        // contiguous and reduce array churn).
-        let j = i + 1;
-        while (j < fmt.length) {
-            const nx = fmt[j].toLowerCase();
-            if (nx === "y" || nx === "m" || nx === "d" || nx === "h" || nx === "s") {
-                break;
-            }
-            if (fmt.slice(j, j + 5).toUpperCase() === "AM/PM") {
-                break;
-            }
-            if (fmt.slice(j, j + 3).toUpperCase() === "A/P") {
-                break;
-            }
-            j++;
-        }
-        runs.push({ kind: "literal", text: fmt.slice(i, j) });
-        i = j;
-    }
-    // Phase 2: render each run, using neighbour context to decide whether
-    // an `m` / `mm` run means minute (when adjacent to an `h` or `s` run)
-    // or month (otherwise).
-    let out = "";
-    for (let r = 0; r < runs.length; r++) {
-        const run = runs[r];
-        if (run.kind === "literal") {
-            out += run.text;
-            continue;
-        }
-        switch (run.lower) {
-            case "y":
-                out += run.count >= 4 ? String(year).padStart(4, "0") : String(year).slice(-2);
-                break;
-            case "d":
-                if (run.count >= 4) {
-                    out += DAY_NAMES_FULL[dow];
-                }
-                else if (run.count === 3) {
-                    out += DAY_NAMES_SHORT[dow];
-                }
-                else if (run.count === 2) {
-                    out += String(dayN).padStart(2, "0");
-                }
-                else {
-                    out += String(dayN);
-                }
-                break;
-            case "h":
-                out +=
-                    run.count >= 2
-                        ? String(hasAmPmToken ? h12 : hours).padStart(2, "0")
-                        : String(hasAmPmToken ? h12 : hours);
-                break;
-            case "s":
-                out += run.count >= 2 ? String(seconds).padStart(2, "0") : String(seconds);
-                break;
-            case "m": {
-                // Month-names render independent of context.
-                if (run.count === 4) {
-                    out += MONTH_NAMES_FULL[month0];
-                    break;
-                }
-                if (run.count === 3) {
-                    out += MONTH_NAMES_SHORT[month0];
-                    break;
-                }
-                // Otherwise `m` / `mm` is month-or-minute. Follow Excel's rule:
-                // treat as minute iff an adjacent letter-run is `h` or `s`.
-                const isMinute = isAdjacentTimeContext(runs, r);
-                const value = isMinute ? minutes : month0 + 1;
-                out += run.count >= 2 ? String(value).padStart(2, "0") : String(value);
-                break;
-            }
-        }
-    }
-    return out;
-}
-/**
- * Determine whether the `m` / `mm` run at `runs[idx]` should render as
- * minutes (true) or months (false). Excel's rule, simplified: minutes
- * when the immediately preceding or following *letter* run is `h` or
- * `s`, ignoring intervening literal separators like `:`.
- */
-function isAdjacentTimeContext(runs, idx) {
-    for (let j = idx - 1; j >= 0; j--) {
-        const p = runs[j];
-        if (p.kind === "letters") {
-            if (p.lower === "h" || p.lower === "s") {
-                return true;
-            }
-            break;
-        }
-    }
-    for (let j = idx + 1; j < runs.length; j++) {
-        const p = runs[j];
-        if (p.kind === "letters") {
-            if (p.lower === "h" || p.lower === "s") {
-                return true;
-            }
-            break;
-        }
-    }
-    return false;
+    return render(valRV.value);
 }
 // ============================================================================
 // VALUE / EXACT