@rowsncolumns/utils 9.2.39 → 9.2.41

package/dist/cjs/excel-number-format.js

@@ -0,0 +1,659 @@
+"use strict";
+/**
+ * Excel-parity pre-pass for number formatting.
+ *
+ * `numfmt` renders the bulk of Excel's format language, but it decides three
+ * things from the binary double where Excel decides them from the number's
+ * 15-significant-digit decimal representation:
+ *
+ *  - rounding to a fixed number of decimals (`0.00` of `1.005` is `1.01`, not
+ *    the `1.00` the double `1.00499999999999989…` rounds to);
+ *  - `General`, which switches to scientific notation below 1E-4 and above
+ *    11 digits and rounds (never truncates) the 11th digit;
+ *  - magnitudes ≥ 1E15, where Excel pads the 15 significant digits with
+ *    zeros (`0.00` of `1E21` is `1000000000000000000000.00`).
+ *
+ * It also renders a date/time format for a serial outside Excel's calendar
+ * (negative, or ≥ 10000-01-01) as `#######`, as Excel does in the cell.
+ *
+ * Everything here works on the pattern's SECTION the value selects, so
+ * multi-section formats (`0.00;(0.00);"-"`) keep their Excel section rules.
+ * A format with `[>100]`-style conditions is resolved here too — which
+ * section matches, and whether the value's sign is shown — so the matched
+ * section gets the same decimal rules; the library then renders that one
+ * section on its own.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excelNumberPrePass = exports.groupDigits = exports.hugeIntegerDigits = exports.excelGeneral = exports.roundDecimal15 = exports.stripConditionTokens = exports.resolveConditionalSection = exports.pickNumberSection = exports.analyzeFormatSection = exports.splitFormatSections = exports.DATE_OVERFLOW_DISPLAY = void 0;
+var tslib_1 = require("tslib");
+/** Excel's largest date serial: 9999-12-31 is 2958465 (1900 date system). */
+var MAX_DATE_SERIAL_EXCLUSIVE = 2958466;
+/**
+ * What Excel shows when a value cannot be rendered by its format: a
+ * date/time outside the calendar, or a number no conditional section takes.
+ */
+exports.DATE_OVERFLOW_DISPLAY = "#######";
+/**
+ * Split a format code into its `;` sections, honouring quotes, bracket
+ * tokens and backslash escapes.
+ */
+var splitFormatSections = function (code) {
+    var sections = [];
+    var current = "";
+    var inQuotes = false;
+    var inBrackets = false;
+    for (var i = 0; i < code.length; i++) {
+        var c = code[i];
+        if (inQuotes) {
+            current += c;
+            if (c === '"')
+                inQuotes = false;
+            continue;
+        }
+        if (inBrackets) {
+            current += c;
+            if (c === "]")
+                inBrackets = false;
+            continue;
+        }
+        if (c === "\\" && i + 1 < code.length) {
+            current += c + code[i + 1];
+            i++;
+            continue;
+        }
+        if (c === '"') {
+            inQuotes = true;
+            current += c;
+            continue;
+        }
+        if (c === "[") {
+            inBrackets = true;
+            current += c;
+            continue;
+        }
+        if (c === ";") {
+            sections.push(current);
+            current = "";
+            continue;
+        }
+        current += c;
+    }
+    sections.push(current);
+    return sections;
+};
+exports.splitFormatSections = splitFormatSections;
+var isDigitPlaceholder = function (c) { return c === "0" || c === "#" || c === "?"; };
+var isDateLetter = function (c) { return /[ymdhsYMDHS]/.test(c); };
+var CONDITION_TOKEN = /^(<>|<=|>=|=|<|>)\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)\s*$/;
+var parseCondition = function (token) {
+    var match = CONDITION_TOKEN.exec(token);
+    if (!match)
+        return undefined;
+    return {
+        op: match[1],
+        operand: Number(match[2]),
+    };
+};
+/** Classify one section of a format code. */
+var analyzeFormatSection = function (section) {
+    var info = {
+        kind: "other",
+        body: "",
+        hasCondition: false,
+        isElapsed: false,
+        generalPrefix: "",
+        decimals: 0,
+        percent: 0,
+        commaScale: 0,
+        grouping: false,
+        isPlainNumber: true,
+        volatileSign: false,
+    };
+    // Pass 1: strip bracket tokens, classify them.
+    var body = "";
+    var inQuotes = false;
+    var hasToken = false;
+    for (var i = 0; i < section.length; i++) {
+        var c = section[i];
+        if (inQuotes) {
+            body += c;
+            if (c === '"')
+                inQuotes = false;
+            continue;
+        }
+        if (c === "\\" && i + 1 < section.length) {
+            body += c + section[i + 1];
+            i++;
+            continue;
+        }
+        if (c === '"') {
+            inQuotes = true;
+            body += c;
+            continue;
+        }
+        if (c === "[") {
+            var end = section.indexOf("]", i);
+            if (end === -1) {
+                info.kind = "other";
+                return info;
+            }
+            var token = section.slice(i + 1, end);
+            i = end;
+            hasToken = true;
+            if (/^[<>=]/.test(token)) {
+                var condition = parseCondition(token);
+                if (!condition) {
+                    info.kind = "other";
+                    return info;
+                }
+                info.hasCondition = true;
+                info.condition = condition;
+            }
+            else if (/^[hmsHMS]+$/.test(token)) {
+                info.isElapsed = true;
+                body += "[".concat(token, "]");
+            }
+            else if (/^\$/.test(token) || /^color\s*\d+$/i.test(token)) {
+                // currency/locale pin or color: no effect on the digits
+            }
+            else if (/^(black|blue|cyan|green|magenta|red|white|yellow)$/i.test(token)) {
+                // color
+            }
+            else {
+                info.kind = "other";
+                return info;
+            }
+            continue;
+        }
+        body += c;
+    }
+    info.body = body;
+    if (body.trim() === "") {
+        // `0;;;` hides the value; a section holding only `[Red]` / `[$-409]` /
+        // `[<0]` tokens is Excel's `General` (`[Blue];[Red]` colors by sign).
+        info.kind = hasToken ? "general" : "empty";
+        return info;
+    }
+    // General (optionally with a literal prefix such as `-General`).
+    var generalMatch = /^([^"A-Za-z0#?@]*)general$/i.exec(body.trim());
+    if (generalMatch) {
+        info.kind = "general";
+        info.generalPrefix = generalMatch[1];
+        return info;
+    }
+    // Pass 2: scan the body outside quotes / escapes / pad markers.
+    var placeholders = 0;
+    var afterDot = false;
+    var sawDot = false;
+    var hasDate = info.isElapsed;
+    var hasText = false;
+    var hasScientific = false;
+    var hasFraction = false;
+    var hasOtherLetter = false;
+    var hasLiteral = false;
+    var chars = [];
+    inQuotes = false;
+    for (var i = 0; i < body.length; i++) {
+        var c = body[i];
+        if (inQuotes) {
+            if (c === '"')
+                inQuotes = false;
+            else
+                hasLiteral = true;
+            continue;
+        }
+        if (c === '"') {
+            inQuotes = true;
+            continue;
+        }
+        if (c === "\\" || c === "_" || c === "*") {
+            hasLiteral = true;
+            i++;
+            continue;
+        }
+        if (c === "[") {
+            // elapsed token kept from pass 1
+            var end = body.indexOf("]", i);
+            i = end === -1 ? body.length : end;
+            continue;
+        }
+        chars.push(c);
+        if (isDigitPlaceholder(c)) {
+            placeholders++;
+            if (afterDot)
+                info.decimals++;
+            continue;
+        }
+        if (c === ".") {
+            if (!sawDot) {
+                sawDot = true;
+                afterDot = true;
+            }
+            continue;
+        }
+        if (c === ",") {
+            // A comma directly followed by a digit placeholder groups; any
+            // other comma placed after a digit placeholder scales by 1000.
+            var j = i + 1;
+            while (j < body.length && (body[j] === "_" || body[j] === "*"))
+                j += 2;
+            if (j < body.length && isDigitPlaceholder(body[j])) {
+                info.grouping = true;
+            }
+            else if (placeholders > 0) {
+                info.commaScale++;
+            }
+            else {
+                hasLiteral = true;
+            }
+            continue;
+        }
+        if (c === "%") {
+            info.percent++;
+            afterDot = false;
+            continue;
+        }
+        if ((c === "E" || c === "e") &&
+            (body[i + 1] === "+" || body[i + 1] === "-")) {
+            hasScientific = true;
+            i++;
+            continue;
+        }
+        if (c === "/") {
+            if (placeholders > 0)
+                hasFraction = true;
+            else
+                hasLiteral = true;
+            continue;
+        }
+        if (c === "@") {
+            hasText = true;
+            continue;
+        }
+        if (isDateLetter(c) || c === "a" || c === "A" || c === "p" || c === "P") {
+            if (c === "a" || c === "A" || c === "p" || c === "P") {
+                // AM/PM or A/P markers
+                var rest = body.slice(i).toUpperCase();
+                if (rest.startsWith("AM/PM") || rest.startsWith("A/P")) {
+                    hasDate = true;
+                    i += rest.startsWith("AM/PM") ? 4 : 2;
+                    continue;
+                }
+                hasOtherLetter = true;
+                continue;
+            }
+            hasDate = true;
+            continue;
+        }
+        if (/[A-Za-z]/.test(c)) {
+            hasOtherLetter = true;
+            continue;
+        }
+        // $ - + ( ) : space and other literal symbols
+        hasLiteral = true;
+    }
+    if (hasOtherLetter) {
+        info.kind = "other";
+    }
+    else if (hasText) {
+        info.kind = "text";
+    }
+    else if (hasDate) {
+        info.kind = "date";
+    }
+    else if (hasScientific || hasFraction) {
+        info.kind = "other";
+    }
+    else if (placeholders === 0) {
+        info.kind = "other";
+    }
+    else {
+        info.kind = "number";
+    }
+    info.isPlainNumber =
+        info.kind === "number" && !hasLiteral && !info.hasCondition;
+    info.volatileSign = placeholders > 0 && !hasFraction;
+    return info;
+};
+exports.analyzeFormatSection = analyzeFormatSection;
+/**
+ * Which section Excel applies to a numeric value: one section covers every
+ * number; two sections split positive-or-zero / negative; three add a zero
+ * section. Returns the index and whether the section's sign is implicit.
+ */
+var pickNumberSection = function (sectionCount, value) {
+    var numeric = Math.min(sectionCount, 3);
+    if (numeric <= 1)
+        return { index: 0, implicitSign: true };
+    if (value < 0)
+        return { index: 1, implicitSign: false };
+    if (value === 0 && numeric >= 3)
+        return { index: 2, implicitSign: false };
+    return { index: 0, implicitSign: false };
+};
+exports.pickNumberSection = pickNumberSection;
+var conditionHolds = function (_a, value) {
+    var op = _a.op, operand = _a.operand;
+    switch (op) {
+        case "=":
+            return value === operand;
+        case ">":
+            return value > operand;
+        case "<":
+            return value < operand;
+        case ">=":
+            return value >= operand;
+        case "<=":
+            return value <= operand;
+        default:
+            return value !== operand;
+    }
+};
+/**
+ * A condition only negative numbers satisfy. Excel renders such a section
+ * without the value's `-` (`[<-25]0` of -50 is `50`); every other conditional
+ * section shows it (`[<0]"neg"` of -3 is `-neg`).
+ */
+var matchesOnlyNegatives = function (cond) {
+    return cond !== undefined &&
+        cond.operand < 0 &&
+        (cond.op === "<" || cond.op === "<=" || cond.op === "=");
+};
+/**
+ * Excel's section selection for a format with `[>100]`-style conditions:
+ * the first of the (up to three) numeric sections whose condition holds —
+ * an unconditional section always holds — or `undefined` when none does.
+ * `conditions[i]` is section i's condition (or `undefined`).
+ */
+var resolveConditionalSection = function (conditions, value) {
+    var parts = conditions.length === 1 ? [conditions[0], undefined] : conditions.slice(0, 4);
+    var first = parts[0];
+    var showsSign = function (index) {
+        var cond = parts[index];
+        if (parts.length <= 2 && index === 1 && cond === undefined) {
+            // The unconditional second section of a two-section conditional
+            // format shows the sign only when the first condition leaves the
+            // negatives to it.
+            return (first !== undefined &&
+                (first.op === "=" ||
+                    (first.operand >= 0 && (first.op === ">" || first.op === ">="))));
+        }
+        return !matchesOnlyNegatives(cond);
+    };
+    for (var index = 0; index < Math.min(parts.length, 3); index++) {
+        var cond = parts[index];
+        if (cond === undefined || conditionHolds(cond, value)) {
+            return {
+                index: index,
+                generated: index >= conditions.length,
+                minus: showsSign(index),
+            };
+        }
+    }
+    return undefined;
+};
+exports.resolveConditionalSection = resolveConditionalSection;
+/** Remove the `[>100]`-style condition tokens from one section. */
+var stripConditionTokens = function (section) {
+    var out = "";
+    var inQuotes = false;
+    for (var i = 0; i < section.length; i++) {
+        var c = section[i];
+        if (inQuotes) {
+            out += c;
+            if (c === '"')
+                inQuotes = false;
+            continue;
+        }
+        if (c === "\\" && i + 1 < section.length) {
+            out += c + section[i + 1];
+            i++;
+            continue;
+        }
+        if (c === '"') {
+            inQuotes = true;
+            out += c;
+            continue;
+        }
+        if (c === "[") {
+            var end = section.indexOf("]", i);
+            if (end !== -1 && /^[<>=]/.test(section.slice(i + 1, end))) {
+                i = end;
+                continue;
+            }
+        }
+        out += c;
+    }
+    return out;
+};
+exports.stripConditionTokens = stripConditionTokens;
+/**
+ * Decompose |x| into 15 significant decimal digits: x = digits × 10^exp10
+ * where `digits` is a 15-character string and exp10 = exponent − 14.
+ */
+var decimal15 = function (x) {
+    var _a = tslib_1.__read(Math.abs(x).toExponential(14).split("e"), 2), mantissa = _a[0], exponent = _a[1];
+    return { digits: mantissa.replace(".", ""), exp10: Number(exponent) - 14 };
+};
+/**
+ * Round |x|·10^shift half away from zero to `decimals` places using its
+ * 15-significant-digit decimal representation, and return the rounded value
+ * scaled back (÷10^shift). Returns `x` unchanged when no digit is dropped.
+ */
+var roundDecimal15 = function (x, decimals, shift) {
+    if (shift === void 0) { shift = 0; }
+    if (!Number.isFinite(x) || x === 0)
+        return x;
+    var _a = decimal15(x), digits = _a.digits, exp10 = _a.exp10;
+    var exp = exp10 + shift;
+    if (exp >= -decimals)
+        return x;
+    var drop = -decimals - exp;
+    var sign = x < 0 ? -1 : 1;
+    if (drop > 15)
+        return sign * 0;
+    var mantissa = Number(digits); // ≤ 15 digits, exact
+    var p = Math.pow(10, drop);
+    var remainder = mantissa % p;
+    var quotient = (mantissa - remainder) / p;
+    if (remainder >= p / 2)
+        quotient += 1;
+    var scale = decimals + shift;
+    var rounded = scale >= 0 ? quotient / Math.pow(10, scale) : quotient * Math.pow(10, -scale);
+    return sign * rounded;
+};
+exports.roundDecimal15 = roundDecimal15;
+/**
+ * |v| rounded half away from zero to `precision` significant digits on its
+ * 15-digit decimal representation, as (`digits`, decimal exponent of the
+ * first digit). `toPrecision` would round the binary double instead.
+ */
+var significantDigits = function (v, precision) {
+    var _a = decimal15(v), digits = _a.digits, exp10 = _a.exp10;
+    var exponent = exp10 + 14;
+    if (precision >= 15)
+        return { digits: digits, exponent: exponent };
+    var drop = 15 - precision;
+    var mantissa = Number(digits);
+    var p = Math.pow(10, drop);
+    var remainder = mantissa % p;
+    var quotient = (mantissa - remainder) / p;
+    if (remainder >= p / 2)
+        quotient += 1;
+    if (quotient >= Math.pow(10, precision)) {
+        quotient /= 10;
+        exponent += 1;
+    }
+    return { digits: String(quotient).padStart(precision, "0"), exponent: exponent };
+};
+/** `precision` significant digits of |v| in fixed notation. */
+var toPrecisionFixed = function (v, precision) {
+    var _a = significantDigits(v, precision), digits = _a.digits, exponent = _a.exponent;
+    if (exponent >= 0) {
+        var intLength = exponent + 1;
+        if (digits.length <= intLength)
+            return digits.padEnd(intLength, "0");
+        return "".concat(digits.slice(0, intLength), ".").concat(digits.slice(intLength));
+    }
+    return "0.".concat("0".repeat(-exponent - 1)).concat(digits);
+};
+/** Excel `General` for a finite number, using `.`/`E` (caller localizes). */
+var excelGeneral = function (value) {
+    if (value === 0 || !Number.isFinite(value))
+        return "0";
+    var negative = value < 0;
+    var v = Math.abs(value);
+    var exponent = decimal15(v).exp10 + 14;
+    var out;
+    if (exponent >= -4 && exponent <= -1) {
+        out = stripTrailingZeros(toPrecisionFixed(v, 10 + exponent));
+    }
+    else if (exponent >= 0 && exponent <= 9) {
+        out = stripTrailingZeros(toPrecisionFixed(v, 10));
+    }
+    else if (exponent === 10) {
+        out = toPrecisionFixed(v, 11);
+    }
+    else {
+        out = generalScientific(v);
+    }
+    if (out.length > 11)
+        out = generalScientific(v);
+    return negative ? "-".concat(out) : out;
+};
+exports.excelGeneral = excelGeneral;
+var generalScientific = function (v) {
+    var _a = significantDigits(v, 6), digits = _a.digits, exponent = _a.exponent;
+    var m = stripTrailingZeros("".concat(digits[0], ".").concat(digits.slice(1)));
+    var sign = exponent < 0 ? "-" : "+";
+    return "".concat(m, "E").concat(sign).concat(String(Math.abs(exponent)).padStart(2, "0"));
+};
+var stripTrailingZeros = function (s) {
+    if (!s.includes("."))
+        return s;
+    return s.replace(/\.?0+$/, "");
+};
+/**
+ * Digits of |x| for |x| ≥ 1E15 as Excel shows them: the 15 significant
+ * digits followed by zeros (Excel stores nothing beyond 15 digits).
+ */
+var hugeIntegerDigits = function (x) {
+    var _a = decimal15(x), digits = _a.digits, exp10 = _a.exp10;
+    if (exp10 >= 0)
+        return digits + "0".repeat(exp10);
+    // |x| ≥ 1E15 always has exp10 ≥ 0; guard anyway.
+    return digits.slice(0, digits.length + exp10);
+};
+exports.hugeIntegerDigits = hugeIntegerDigits;
+var groupDigits = function (digits, separator) {
+    var out = "";
+    for (var i = 0; i < digits.length; i++) {
+        var fromEnd = digits.length - i;
+        if (i > 0 && fromEnd % 3 === 0)
+            out += separator;
+        out += digits[i];
+    }
+    return out;
+};
+exports.groupDigits = groupDigits;
+var HUGE = 1e15;
+var GENERAL_SECTION = (0, exports.analyzeFormatSection)("General");
+/**
+ * Excel's decimal rules for one non-date section. `signPrefix` is prepended
+ * to a rendering produced here; `value` keeps its sign for the library.
+ */
+var prePassSection = function (info, value, signPrefix, l10n) {
+    var magnitude = Math.abs(value);
+    switch (info.kind) {
+        case "empty":
+            return { text: "", value: value };
+        case "general": {
+            var rendered = (0, exports.excelGeneral)(magnitude).replace(".", l10n.decimal);
+            return { text: "".concat(signPrefix).concat(info.generalPrefix).concat(rendered), value: value };
+        }
+        case "number": {
+            var shift = 2 * info.percent - 3 * info.commaScale;
+            if (magnitude >= HUGE && info.isPlainNumber && shift === 0) {
+                var digits = (0, exports.hugeIntegerDigits)(value);
+                var intPart = info.grouping
+                    ? (0, exports.groupDigits)(digits, l10n.group)
+                    : digits;
+                var frac = info.decimals > 0
+                    ? "".concat(l10n.decimal).concat("0".repeat(info.decimals))
+                    : "";
+                return { text: "".concat(signPrefix).concat(intPart).concat(frac), value: value };
+            }
+            if (magnitude * Math.pow(10, shift) >= HUGE)
+                return { value: value };
+            return { value: (0, exports.roundDecimal15)(value, info.decimals, shift) };
+        }
+        default:
+            return { value: value };
+    }
+};
+/**
+ * A format with conditions: pick the section Excel applies, render that
+ * section alone for the magnitude (so it gets the decimal rules), and show
+ * the sign by Excel's conditional-section rule.
+ */
+var renderConditional = function (sections, infos, value, l10n, render) {
+    var _a;
+    var resolved = (0, exports.resolveConditionalSection)(infos.map(function (info) { return info.condition; }), value);
+    if (!resolved)
+        return { text: exports.DATE_OVERFLOW_DISPLAY, value: value };
+    var info = resolved.generated ? GENERAL_SECTION : infos[resolved.index];
+    var code = resolved.generated
+        ? "General"
+        : (0, exports.stripConditionTokens)(sections[resolved.index]);
+    if (info.kind === "date" && !info.isElapsed) {
+        // A date never carries a sign; the calendar rule applies to the serial.
+        if (value < 0 || value >= MAX_DATE_SERIAL_EXCLUSIVE) {
+            return { text: exports.DATE_OVERFLOW_DISPLAY, value: value };
+        }
+        return { text: render(code, value), value: value };
+    }
+    var pre = prePassSection(info, Math.abs(value), "", l10n);
+    var rendered = (_a = pre.text) !== null && _a !== void 0 ? _a : render(code, pre.value);
+    // Elapsed durations keep their `-36:00` policy; the volatile sign is
+    // dropped when every rendered digit is zero.
+    var showSign = value < 0 &&
+        (info.isElapsed ||
+            (resolved.minus && (!info.volatileSign || /[1-9]/.test(rendered))));
+    return { text: showSign ? "-".concat(rendered) : rendered, value: value };
+};
+/**
+ * Apply Excel's decimal rules before handing a numeric value to `numfmt`.
+ * `render` formats one section of the pattern with the library; it is used
+ * when the pre-pass has to resolve a conditional format itself.
+ */
+var excelNumberPrePass = function (pattern, value, l10n, render) {
+    if (!Number.isFinite(value) || pattern.trim() === "")
+        return { value: value };
+    var sections = (0, exports.splitFormatSections)(pattern);
+    var infos = sections.map(exports.analyzeFormatSection);
+    if (infos.some(function (s) { return s.hasCondition; })) {
+        return renderConditional(sections, infos, value, l10n, render);
+    }
+    var _a = (0, exports.pickNumberSection)(infos.length, value), index = _a.index, implicitSign = _a.implicitSign;
+    var info = infos[index];
+    if (!info)
+        return { value: value };
+    if (info.kind === "date") {
+        if (info.isElapsed && sections.length === 1)
+            return { value: value };
+        if (value < 0 || value >= MAX_DATE_SERIAL_EXCLUSIVE) {
+            return { text: exports.DATE_OVERFLOW_DISPLAY, value: value };
+        }
+        return { value: value };
+    }
+    var pre = prePassSection(info, value, implicitSign && value < 0 ? "-" : "", l10n);
+    // Excel picks the section from the value's sign, then rounds: a tiny
+    // negative under an explicit negative section still renders that section
+    // (`0.00;(0.00)` of -0.001 is `(0.00)`). The library would see the rounded
+    // -0 as positive, so render the negative section for the zero magnitude.
+    if (index === 1 && value < 0 && pre.text === undefined && pre.value === 0) {
+        return { text: render(sections[index], 0), value: value };
+    }
+    return pre;
+};
+exports.excelNumberPrePass = excelNumberPrePass;

package/dist/cjs/formatter.d.ts

@@ -23,6 +23,26 @@ export declare const isTextPattern: (pattern: string | undefined | null) => bool
  * characters are skipped; `ddd`/`dddd` are weekday names, not a day.
  */
 export declare const isStandaloneMonthPattern: (pattern: string) => boolean;
+/**
+ * Does the pattern carry Excel's short `A/P` marker outside quoted literals,
+ * bracket directives and escapes? Returns the pattern with the marker
+ * upper-cased (Excel accepts `a/p` and renders it `A`/`P`; numfmt only
+ * tokenizes `A/P`) and its `[$-LCID]` tokens re-pointed at the companion
+ * `A`/`P` locale, or `undefined` when there is none.
+ */
+export declare const withShortAmPmMarker: (pattern: string) => string | undefined;
+/**
+ * Excel's `[$symbol-LCID]` token selects the currency symbol and the
+ * language of day/month names and AM/PM; digit grouping and the decimal
+ * separator follow the workbook locale (`[$€-407] #,##0.00` is
+ * `€ 1,234.50` on a US host). numfmt applies the token's locale to the whole
+ * section, separators included, so the locale part is dropped from every
+ * section that is not a date (number, scientific, fraction, text, …); a
+ * date section keeps the token for its names, re-pointed at a companion
+ * locale that carries the workbook's separators for fractional seconds.
+ * Returns `undefined` when nothing had to change.
+ */
+export declare const withWorkbookSeparators: (pattern: string, locale?: string) => string | undefined;
 export declare const ssfFormat: (pattern: string, value: any, locale?: string) => string;
 export declare const ssfFormatColor: (pattern: string, value: any) => string | undefined;
 //# sourceMappingURL=formatter.d.ts.map

package/dist/cjs/formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../formatter.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OASlE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KACjC,OAWF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OAWlE,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OAOlE,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,KAAG,OA4B1D,CAAC;AA8EF,eAAO,MAAM,SAAS,GACpB,SAAS,MAAM,EACf,OAAO,GAAG,EACV,SAAS,MAAM,KACd,MAeF,CAAC;AAmLF,eAAO,MAAM,cAAc,GACzB,SAAS,MAAM,EACf,OAAO,GAAG,KACT,MAAM,GAAG,SAoBX,CAAC"}
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../formatter.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OASlE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KACjC,OAWF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OAWlE,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OAOlE,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,KAAG,OA4B1D,CAAC;AAuHF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,KAAG,MAAM,GAAG,SA4C9D,CAAC;AAiIF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,MAAM,EACf,SAAS,MAAM,KACd,MAAM,GAAG,SAiBX,CAAC;AAiBF,eAAO,MAAM,SAAS,GACpB,SAAS,MAAM,EACf,OAAO,GAAG,EACV,SAAS,MAAM,KACd,MAyCF,CAAC;AAmLF,eAAO,MAAM,cAAc,GACzB,SAAS,MAAM,EACf,OAAO,GAAG,KACT,MAAM,GAAG,SAoBX,CAAC"}