@rowsncolumns/utils 9.2.39 → 9.2.40

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

@@ -0,0 +1,640 @@
+/**
+ * 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.
+ */
+/** Excel's largest date serial: 9999-12-31 is 2958465 (1900 date system). */
+const 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.
+ */
+export const DATE_OVERFLOW_DISPLAY = "#######";
+/**
+ * Split a format code into its `;` sections, honouring quotes, bracket
+ * tokens and backslash escapes.
+ */
+export const splitFormatSections = (code) => {
+    const sections = [];
+    let current = "";
+    let inQuotes = false;
+    let inBrackets = false;
+    for (let i = 0; i < code.length; i++) {
+        const 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;
+};
+const isDigitPlaceholder = (c) => c === "0" || c === "#" || c === "?";
+const isDateLetter = (c) => /[ymdhsYMDHS]/.test(c);
+const CONDITION_TOKEN = /^(<>|<=|>=|=|<|>)\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)\s*$/;
+const parseCondition = (token) => {
+    const match = CONDITION_TOKEN.exec(token);
+    if (!match)
+        return undefined;
+    return {
+        op: match[1],
+        operand: Number(match[2]),
+    };
+};
+/** Classify one section of a format code. */
+export const analyzeFormatSection = (section) => {
+    const 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.
+    let body = "";
+    let inQuotes = false;
+    let hasToken = false;
+    for (let i = 0; i < section.length; i++) {
+        const 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 === "[") {
+            const end = section.indexOf("]", i);
+            if (end === -1) {
+                info.kind = "other";
+                return info;
+            }
+            const token = section.slice(i + 1, end);
+            i = end;
+            hasToken = true;
+            if (/^[<>=]/.test(token)) {
+                const 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 += `[${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`).
+    const 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.
+    let placeholders = 0;
+    let afterDot = false;
+    let sawDot = false;
+    let hasDate = info.isElapsed;
+    let hasText = false;
+    let hasScientific = false;
+    let hasFraction = false;
+    let hasOtherLetter = false;
+    let hasLiteral = false;
+    const chars = [];
+    inQuotes = false;
+    for (let i = 0; i < body.length; i++) {
+        const 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
+            const 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.
+            let 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
+                const 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;
+};
+/**
+ * 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.
+ */
+export const pickNumberSection = (sectionCount, value) => {
+    const 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 };
+};
+const conditionHolds = ({ op, operand }, value) => {
+    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`).
+ */
+const matchesOnlyNegatives = (cond) => 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`).
+ */
+export const resolveConditionalSection = (conditions, value) => {
+    const parts = conditions.length === 1 ? [conditions[0], undefined] : conditions.slice(0, 4);
+    const first = parts[0];
+    const showsSign = (index) => {
+        const 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 (let index = 0; index < Math.min(parts.length, 3); index++) {
+        const cond = parts[index];
+        if (cond === undefined || conditionHolds(cond, value)) {
+            return {
+                index,
+                generated: index >= conditions.length,
+                minus: showsSign(index),
+            };
+        }
+    }
+    return undefined;
+};
+/** Remove the `[>100]`-style condition tokens from one section. */
+export const stripConditionTokens = (section) => {
+    let out = "";
+    let inQuotes = false;
+    for (let i = 0; i < section.length; i++) {
+        const 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 === "[") {
+            const end = section.indexOf("]", i);
+            if (end !== -1 && /^[<>=]/.test(section.slice(i + 1, end))) {
+                i = end;
+                continue;
+            }
+        }
+        out += c;
+    }
+    return out;
+};
+/**
+ * Decompose |x| into 15 significant decimal digits: x = digits × 10^exp10
+ * where `digits` is a 15-character string and exp10 = exponent − 14.
+ */
+const decimal15 = (x) => {
+    const [mantissa, exponent] = Math.abs(x).toExponential(14).split("e");
+    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.
+ */
+export const roundDecimal15 = (x, decimals, shift = 0) => {
+    if (!Number.isFinite(x) || x === 0)
+        return x;
+    const { digits, exp10 } = decimal15(x);
+    const exp = exp10 + shift;
+    if (exp >= -decimals)
+        return x;
+    const drop = -decimals - exp;
+    const sign = x < 0 ? -1 : 1;
+    if (drop > 15)
+        return sign * 0;
+    const mantissa = Number(digits); // ≤ 15 digits, exact
+    const p = 10 ** drop;
+    const remainder = mantissa % p;
+    let quotient = (mantissa - remainder) / p;
+    if (remainder >= p / 2)
+        quotient += 1;
+    const scale = decimals + shift;
+    const rounded = scale >= 0 ? quotient / 10 ** scale : quotient * 10 ** -scale;
+    return sign * rounded;
+};
+/**
+ * |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.
+ */
+const significantDigits = (v, precision) => {
+    const { digits, exp10 } = decimal15(v);
+    let exponent = exp10 + 14;
+    if (precision >= 15)
+        return { digits, exponent };
+    const drop = 15 - precision;
+    const mantissa = Number(digits);
+    const p = 10 ** drop;
+    const remainder = mantissa % p;
+    let quotient = (mantissa - remainder) / p;
+    if (remainder >= p / 2)
+        quotient += 1;
+    if (quotient >= 10 ** precision) {
+        quotient /= 10;
+        exponent += 1;
+    }
+    return { digits: String(quotient).padStart(precision, "0"), exponent };
+};
+/** `precision` significant digits of |v| in fixed notation. */
+const toPrecisionFixed = (v, precision) => {
+    const { digits, exponent } = significantDigits(v, precision);
+    if (exponent >= 0) {
+        const intLength = exponent + 1;
+        if (digits.length <= intLength)
+            return digits.padEnd(intLength, "0");
+        return `${digits.slice(0, intLength)}.${digits.slice(intLength)}`;
+    }
+    return `0.${"0".repeat(-exponent - 1)}${digits}`;
+};
+/** Excel `General` for a finite number, using `.`/`E` (caller localizes). */
+export const excelGeneral = (value) => {
+    if (value === 0 || !Number.isFinite(value))
+        return "0";
+    const negative = value < 0;
+    const v = Math.abs(value);
+    const exponent = decimal15(v).exp10 + 14;
+    let 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 ? `-${out}` : out;
+};
+const generalScientific = (v) => {
+    const { digits, exponent } = significantDigits(v, 6);
+    const m = stripTrailingZeros(`${digits[0]}.${digits.slice(1)}`);
+    const sign = exponent < 0 ? "-" : "+";
+    return `${m}E${sign}${String(Math.abs(exponent)).padStart(2, "0")}`;
+};
+const stripTrailingZeros = (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).
+ */
+export const hugeIntegerDigits = (x) => {
+    const { digits, exp10 } = decimal15(x);
+    if (exp10 >= 0)
+        return digits + "0".repeat(exp10);
+    // |x| ≥ 1E15 always has exp10 ≥ 0; guard anyway.
+    return digits.slice(0, digits.length + exp10);
+};
+export const groupDigits = (digits, separator) => {
+    let out = "";
+    for (let i = 0; i < digits.length; i++) {
+        const fromEnd = digits.length - i;
+        if (i > 0 && fromEnd % 3 === 0)
+            out += separator;
+        out += digits[i];
+    }
+    return out;
+};
+const HUGE = 1e15;
+const GENERAL_SECTION = 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.
+ */
+const prePassSection = (info, value, signPrefix, l10n) => {
+    const magnitude = Math.abs(value);
+    switch (info.kind) {
+        case "empty":
+            return { text: "", value };
+        case "general": {
+            const rendered = excelGeneral(magnitude).replace(".", l10n.decimal);
+            return { text: `${signPrefix}${info.generalPrefix}${rendered}`, value };
+        }
+        case "number": {
+            const shift = 2 * info.percent - 3 * info.commaScale;
+            if (magnitude >= HUGE && info.isPlainNumber && shift === 0) {
+                const digits = hugeIntegerDigits(value);
+                const intPart = info.grouping
+                    ? groupDigits(digits, l10n.group)
+                    : digits;
+                const frac = info.decimals > 0
+                    ? `${l10n.decimal}${"0".repeat(info.decimals)}`
+                    : "";
+                return { text: `${signPrefix}${intPart}${frac}`, value };
+            }
+            if (magnitude * 10 ** shift >= HUGE)
+                return { value };
+            return { value: roundDecimal15(value, info.decimals, shift) };
+        }
+        default:
+            return { 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.
+ */
+const renderConditional = (sections, infos, value, l10n, render) => {
+    const resolved = resolveConditionalSection(infos.map((info) => info.condition), value);
+    if (!resolved)
+        return { text: DATE_OVERFLOW_DISPLAY, value };
+    const info = resolved.generated ? GENERAL_SECTION : infos[resolved.index];
+    const code = resolved.generated
+        ? "General"
+        : 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: DATE_OVERFLOW_DISPLAY, value };
+        }
+        return { text: render(code, value), value };
+    }
+    const pre = prePassSection(info, Math.abs(value), "", l10n);
+    const rendered = pre.text ?? render(code, pre.value);
+    // Elapsed durations keep their `-36:00` policy; the volatile sign is
+    // dropped when every rendered digit is zero.
+    const showSign = value < 0 &&
+        (info.isElapsed ||
+            (resolved.minus && (!info.volatileSign || /[1-9]/.test(rendered))));
+    return { text: showSign ? `-${rendered}` : rendered, 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.
+ */
+export const excelNumberPrePass = (pattern, value, l10n, render) => {
+    if (!Number.isFinite(value) || pattern.trim() === "")
+        return { value };
+    const sections = splitFormatSections(pattern);
+    const infos = sections.map(analyzeFormatSection);
+    if (infos.some((s) => s.hasCondition)) {
+        return renderConditional(sections, infos, value, l10n, render);
+    }
+    const { index, implicitSign } = pickNumberSection(infos.length, value);
+    const info = infos[index];
+    if (!info)
+        return { value };
+    if (info.kind === "date") {
+        if (info.isElapsed && sections.length === 1)
+            return { value };
+        if (value < 0 || value >= MAX_DATE_SERIAL_EXCLUSIVE) {
+            return { text: DATE_OVERFLOW_DISPLAY, value };
+        }
+        return { value };
+    }
+    const 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 };
+    }
+    return pre;
+};

package/dist/esm/formatter.d.ts

@@ -23,6 +23,14 @@ 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;
 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/esm/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":"AAaA;;;;;;;;;;;;;;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;AAgBF,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"}