@rowsncolumns/utils 9.2.35

package/dist/esm/dom.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Check if its being rendered in Browser or SSR
+ */
+export declare const canUseDOM: boolean;
+export declare const moveSelectionToEndOfActiveInput: () => void;
+export declare const moveSelectionToEndOfTextArea: () => void;
+export declare const scheduleAfterPaint: (callback: () => void) => () => void;
+export declare const focusableNodeNames: Set<string>;
+export declare const isFocusable: (el: Element | null) => boolean;
+//# sourceMappingURL=dom.d.ts.map

package/dist/esm/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../dom.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,SAAS,SAGkB,CAAC;AAEzC,eAAO,MAAM,+BAA+B,YAsB3C,CAAC;AAEF,eAAO,MAAM,4BAA4B,YAiBxC,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,IAAI,eAmCtD,CAAC;AAGF,eAAO,MAAM,kBAAkB,aAA2C,CAAC;AAE3E,eAAO,MAAM,WAAW,GAAI,IAAI,OAAO,GAAG,IAAI,YAQ7C,CAAC"}

package/dist/esm/dom.js

@@ -0,0 +1,90 @@
+/**
+ * Check if its being rendered in Browser or SSR
+ */
+export const canUseDOM = typeof window !== "undefined" &&
+    typeof document !== "undefined" &&
+    typeof window.document !== "undefined";
+export const moveSelectionToEndOfActiveInput = () => {
+    try {
+        if (!canUseDOM) {
+            return;
+        }
+        /* Move to end */
+        requestAnimationFrame(() => {
+            if (document.activeElement) {
+                const range = document.createRange();
+                range.selectNodeContents(document.activeElement);
+                range.collapse(false);
+                const selection = typeof window !== "undefined" ? window.getSelection() : undefined;
+                if (selection) {
+                    selection.removeAllRanges();
+                    selection.addRange(range);
+                }
+            }
+        });
+    }
+    catch (err) {
+        console.log("Failed to collapse selection", err);
+    }
+};
+export const moveSelectionToEndOfTextArea = () => {
+    try {
+        if (!canUseDOM) {
+            return;
+        }
+        if (document.activeElement &&
+            document.activeElement.tagName === "TEXTAREA") {
+            const textarea = document.activeElement;
+            const end = textarea.value.length;
+            // ✅ Move focus to End of textarea
+            textarea.setSelectionRange(end, end);
+            textarea.focus();
+        }
+    }
+    catch (err) { }
+};
+export const scheduleAfterPaint = (callback) => {
+    if (typeof requestAnimationFrame === "function") {
+        if (typeof MessageChannel !== "undefined") {
+            const channel = new MessageChannel();
+            channel.port1.onmessage = () => {
+                channel.port1.onmessage = null;
+                callback();
+            };
+            requestAnimationFrame(() => {
+                channel.port2.postMessage(null);
+            });
+            return () => {
+                channel.port1.onmessage = null;
+            };
+        }
+        const frameId = requestAnimationFrame(() => callback());
+        return () => {
+            if (typeof cancelAnimationFrame === "function") {
+                cancelAnimationFrame(frameId);
+            }
+        };
+    }
+    if (typeof MessageChannel !== "undefined") {
+        const channel = new MessageChannel();
+        channel.port1.onmessage = () => {
+            channel.port1.onmessage = null;
+            callback();
+        };
+        channel.port2.postMessage(null);
+        return () => {
+            channel.port1.onmessage = null;
+        };
+    }
+    callback();
+    return () => { };
+};
+/* Focusable node names */
+export const focusableNodeNames = new Set(["INPUT", "TEXTAREA", "SELECT"]);
+export const isFocusable = (el) => {
+    if (!el) {
+        return false;
+    }
+    return (Boolean(el.getAttribute("contenteditable")) ||
+        focusableNodeNames.has(el.nodeName));
+};

package/dist/esm/formatter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pattern-based type inference (Excel parity). xlsx files routinely carry
+ * a `numberFormat.pattern` without an accompanying `type` field — these
+ * helpers let callers classify such cells from the pattern alone.
+ *
+ * Notes:
+ *  - `isDateFormat` from numfmt returns true for any pattern containing
+ *    date *or* time tokens. We split that into DATE (date only) vs
+ *    DATE_TIME (has a time component) using `getFormatDateInfo`, mirroring
+ *    Excel's `CELL("format")` distinctions.
+ *  - `isTextFormat` only flags patterns whose entire body is the `@`
+ *    placeholder. Multi-section formats with an `@` text section
+ *    (`#,##0;-#,##0;0;[Magenta]@`) are NOT text formats — they're number
+ *    formats whose text section happens to be reachable for string values.
+ */
+export declare const isDatePattern: (pattern: string | undefined | null) => boolean;
+export declare const isDateTimePattern: (pattern: string | undefined | null) => boolean;
+export declare const isTimePattern: (pattern: string | undefined | null) => boolean;
+export declare const isTextPattern: (pattern: string | undefined | null) => boolean;
+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

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../formatter.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;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,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"}

package/dist/esm/formatter.js

@@ -0,0 +1,253 @@
+import { format, formatColor, getFormatDateInfo, isDateFormat, isTextFormat, } from "numfmt";
+import { IndexedColors } from "./colors";
+/**
+ * Pattern-based type inference (Excel parity). xlsx files routinely carry
+ * a `numberFormat.pattern` without an accompanying `type` field — these
+ * helpers let callers classify such cells from the pattern alone.
+ *
+ * Notes:
+ *  - `isDateFormat` from numfmt returns true for any pattern containing
+ *    date *or* time tokens. We split that into DATE (date only) vs
+ *    DATE_TIME (has a time component) using `getFormatDateInfo`, mirroring
+ *    Excel's `CELL("format")` distinctions.
+ *  - `isTextFormat` only flags patterns whose entire body is the `@`
+ *    placeholder. Multi-section formats with an `@` text section
+ *    (`#,##0;-#,##0;0;[Magenta]@`) are NOT text formats — they're number
+ *    formats whose text section happens to be reachable for string values.
+ */
+export const isDatePattern = (pattern) => {
+    if (!pattern)
+        return false;
+    try {
+        if (!isDateFormat(pattern))
+            return false;
+        const info = getFormatDateInfo(pattern);
+        return info.day || info.month || info.year;
+    }
+    catch {
+        return false;
+    }
+};
+export const isDateTimePattern = (pattern) => {
+    if (!pattern)
+        return false;
+    try {
+        if (!isDateFormat(pattern))
+            return false;
+        const info = getFormatDateInfo(pattern);
+        const hasDate = info.day || info.month || info.year;
+        const hasTime = info.hours || info.minutes || info.seconds;
+        return hasDate && hasTime;
+    }
+    catch {
+        return false;
+    }
+};
+export const isTimePattern = (pattern) => {
+    if (!pattern)
+        return false;
+    try {
+        if (!isDateFormat(pattern))
+            return false;
+        const info = getFormatDateInfo(pattern);
+        const hasDate = info.day || info.month || info.year;
+        const hasTime = info.hours || info.minutes || info.seconds;
+        return hasTime && !hasDate;
+    }
+    catch {
+        return false;
+    }
+};
+export const isTextPattern = (pattern) => {
+    if (!pattern)
+        return false;
+    try {
+        return isTextFormat(pattern);
+    }
+    catch {
+        return false;
+    }
+};
+const isSingleSectionElapsedTimePattern = (pattern) => !pattern.includes(";") &&
+    /\[(?:h+|m+|s+)\]/i.test(pattern.replace(/\[\$[^\]]+\]/g, ""));
+export const ssfFormat = (pattern, value, locale) => {
+    try {
+        const isNegativeElapsedTime = typeof value === "number" &&
+            value < 0 &&
+            isSingleSectionElapsedTimePattern(pattern);
+        const formatted = format(pattern, isNegativeElapsedTime ? Math.abs(value) : value, { locale });
+        return isNegativeElapsedTime ? `-${formatted}` : formatted;
+    }
+    catch (err) {
+        return String(value);
+    }
+};
+/**
+ * Excel's legacy fixed 56-color palette used by `[ColorN]` directives
+ * inside number format patterns (1-indexed). This palette is INDEPENDENT
+ * of the workbook's `<indexedColors>` block — `[ColorN]` always refers
+ * to Excel's hard-coded legacy palette, even in files that override the
+ * indexed colors.
+ *
+ * Excel's `[ColorN]` (1-56) resolves to indexed-palette entry `N + 7`
+ * (indices 8–63 of the 64-entry legacy palette; entries 0–7 are the
+ * "EGA duplicate" block that `[ColorN]` never addresses).
+ *
+ * `numfmt` instead resolves `[ColorN]` as its `indexColors[N - 1]` — a
+ * straight off-by-8 against Excel. That happens to agree for N=1..8
+ * (the palette's first 8 entries repeat at 8..15) but is wrong for 28
+ * of the remaining 48 indices: `[Color11]` (Excel navy `#000080`)
+ * renders pure red, as do `[Color17]` and `[Color38]`. We therefore
+ * resolve `[ColorN]` ourselves whenever the matched format segment
+ * carries one (see `ssfFormatColor`).
+ *
+ * Source: ECMA-376 §18.8.27 (indexedColors) and Excel's documented
+ * legacy palette. Note `[ColorN]` always refers to Excel's hard-coded
+ * legacy palette, never a workbook's custom `<indexedColors>` block.
+ */
+const LEGACY_COLOR_PALETTE = {};
+for (let n = 1; n <= 56; n++) {
+    LEGACY_COLOR_PALETTE[n] = IndexedColors[n + 7];
+}
+const COLOR_DIRECTIVE_REGEX = /\[Color(\d+)\]/i;
+const COLOR_OVERRIDE_CACHE = new Map();
+const COLOR_OVERRIDE_CACHE_LIMIT = 256;
+/**
+ * Extract a `[ColorN]` directive resolution for each segment of a
+ * SpreadsheetML pattern. Returns `null` (cached) if the pattern
+ * contains no `[ColorN]` at all — short-circuits any further work
+ * for the vast majority of patterns. Walks the pattern once,
+ * scanning for `;` separators outside string literals and `[ColorN]`
+ * tokens; no `String#split` allocation.
+ */
+const PATTERNS_WITHOUT_COLOR = new Set();
+const getPerSegmentColorOverrides = (pattern) => {
+    if (PATTERNS_WITHOUT_COLOR.has(pattern))
+        return null;
+    const cached = COLOR_OVERRIDE_CACHE.get(pattern);
+    if (cached)
+        return cached;
+    // Fast pre-check: no `[Color` substring → no override possible.
+    // `indexOf` is far cheaper than a regex when the pattern is long
+    // and there's no match. (`[ColorN]` is case-sensitive — Excel
+    // accepts `[color10]` too but the standard form is title case.)
+    if (pattern.indexOf("[Color") === -1 && pattern.indexOf("[color") === -1) {
+        if (PATTERNS_WITHOUT_COLOR.size > COLOR_OVERRIDE_CACHE_LIMIT) {
+            PATTERNS_WITHOUT_COLOR.clear();
+        }
+        PATTERNS_WITHOUT_COLOR.add(pattern);
+        return null;
+    }
+    // Single pass: track current segment, current `[ColorN]` index, and
+    // whether we're inside a string literal. When we hit `;` outside a
+    // string, advance the segment. When we see `[Color\d+]`, record it
+    // for the current segment (only the first occurrence per segment —
+    // matches Excel's behaviour).
+    const segmentColors = [
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+    ];
+    let seg = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < pattern.length; i++) {
+        if (seg > 3)
+            break;
+        const ch = pattern[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escape = true;
+            continue;
+        }
+        if (ch === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (ch === ";" && !inString) {
+            seg++;
+            continue;
+        }
+        if (ch === "[" && !inString && segmentColors[seg] === undefined) {
+            // Look ahead for `Color\d+]` — case-insensitive on the prefix.
+            const end = pattern.indexOf("]", i + 1);
+            if (end === -1)
+                continue;
+            const inside = pattern.slice(i + 1, end);
+            if (/^Color\d+$/i.test(inside)) {
+                const idx = Number(inside.slice(5));
+                const resolved = LEGACY_COLOR_PALETTE[idx];
+                if (resolved)
+                    segmentColors[seg] = resolved;
+            }
+            i = end;
+            continue;
+        }
+    }
+    const result = [
+        segmentColors[0],
+        segmentColors[1],
+        segmentColors[2],
+        segmentColors[3],
+        Math.min(seg, 3) + 1,
+    ];
+    // No `[ColorN]` in any segment after all — treat as "no override".
+    if (!result.slice(0, 4).some((x) => x !== undefined)) {
+        if (PATTERNS_WITHOUT_COLOR.size > COLOR_OVERRIDE_CACHE_LIMIT) {
+            PATTERNS_WITHOUT_COLOR.clear();
+        }
+        PATTERNS_WITHOUT_COLOR.add(pattern);
+        return null;
+    }
+    if (COLOR_OVERRIDE_CACHE.size > COLOR_OVERRIDE_CACHE_LIMIT) {
+        COLOR_OVERRIDE_CACHE.clear();
+    }
+    COLOR_OVERRIDE_CACHE.set(pattern, result);
+    return result;
+};
+/**
+ * Pick the `[ColorN]` override the value's matched segment carries, honoring
+ * Excel's section-selection rules for patterns with fewer than 4 sections:
+ * one section applies to every numeric value; with two, negatives take the
+ * second; zero takes the third only when present; text takes the fourth only
+ * when present (a number-only pattern leaves text unformatted — no color).
+ */
+const pickSegmentOverride = (overrides, value) => {
+    const sections = overrides[4];
+    if (typeof value === "string") {
+        return sections === 4 ? overrides[3] : undefined;
+    }
+    const n = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(n) || n > 0)
+        return overrides[0];
+    if (n < 0)
+        return sections >= 2 ? overrides[1] : overrides[0];
+    return sections >= 3 ? overrides[2] : overrides[0];
+};
+export const ssfFormatColor = (pattern, value) => {
+    // numfmt resolves `[ColorN]` as its `indexColors[N - 1]`, but Excel's
+    // `[ColorN]` is legacy-indexed-palette entry `N + 7` — numfmt's answer
+    // is wrong for most N ≥ 9 (`[Color11]` navy renders pure red) and
+    // `#FFF` for some others. Whenever the matched segment carries a
+    // `[ColorN]` directive, prefer our palette resolution over numfmt's
+    // raw color. The `PATTERNS_WITHOUT_COLOR` set makes this check free
+    // for the common case of patterns with no `[ColorN]`.
+    const overrides = getPerSegmentColorOverrides(pattern);
+    if (overrides) {
+        const resolved = pickSegmentOverride(overrides, value);
+        if (resolved)
+            return resolved;
+    }
+    let raw;
+    try {
+        raw = formatColor(pattern, value);
+    }
+    catch (err) {
+        raw = undefined;
+    }
+    return raw && raw.length > 0 ? raw : undefined;
+};

package/dist/esm/formula-refs.d.ts

@@ -0,0 +1,7 @@
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+export interface FormulaToRelativeReferenceOptions {
+    exclusionRange?: GridRange;
+    ignoreCircular?: boolean;
+}
+export declare const formulaToRelativeReference: (formula: string | undefined, sourceCell: CellInterface, destinationCell: CellInterface, options?: FormulaToRelativeReferenceOptions) => string | undefined;
+//# sourceMappingURL=formula-refs.d.ts.map

package/dist/esm/formula-refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula-refs.d.ts","sourceRoot":"","sources":["../../formula-refs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAsB3E,MAAM,WAAW,iCAAiC;IAChD,cAAc,CAAC,EAAE,SAAS,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,eAAO,MAAM,0BAA0B,GACrC,SAAS,MAAM,GAAG,SAAS,EAC3B,YAAY,aAAa,EACzB,iBAAiB,aAAa,EAC9B,UAAU,iCAAiC,KAC1C,MAAM,GAAG,SAgCX,CAAC"}

package/dist/esm/formula-refs.js

@@ -0,0 +1,49 @@
+import { alpha2number, number2Alpha } from "./numbers";
+const CELL_ADDR_RE = /((?:'[^']+'|[^'!,]+)!)?(\$?[A-Z]+\$?\d+)(?::(\$?[A-Z]+\$?\d+))?/g;
+const parseAddr = (addr) => {
+    const m = /^(\$?)([A-Z]+)(\$?)(\d+)$/.exec(addr);
+    if (!m)
+        return null;
+    const [, absCol, colAlpha, absRow, rowStr] = m;
+    return {
+        col: alpha2number(colAlpha),
+        row: parseInt(rowStr, 10),
+        absCol: absCol === "$",
+        absRow: absRow === "$",
+    };
+};
+const formatAddr = (row, col, absCol, absRow) => {
+    const colAlpha = number2Alpha(Math.max(0, col - 1));
+    const rowNum = Math.max(1, row);
+    return `${absCol ? "$" : ""}${colAlpha}${absRow ? "$" : ""}${rowNum}`;
+};
+export const formulaToRelativeReference = (formula, sourceCell, destinationCell, options) => {
+    // Arguments exclusionRange and ignoreCircular were previously unused in this implementation
+    // We keep the options signature for compatibility but they remain unused in this regex-based impl?
+    // Actually, checking the previous code, they were underscored (_exclusionRange) so likely unused.
+    if (!formula)
+        return formula;
+    if (sourceCell.rowIndex === destinationCell.rowIndex &&
+        sourceCell.columnIndex === destinationCell.columnIndex) {
+        return formula;
+    }
+    const dRow = destinationCell.rowIndex - sourceCell.rowIndex;
+    const dCol = destinationCell.columnIndex - sourceCell.columnIndex;
+    return formula.replace(CELL_ADDR_RE, (match, sheetPrefix, left, right) => {
+        const adjustOne = (addr) => {
+            const p = parseAddr(addr);
+            if (!p)
+                return addr;
+            const newRow = p.absRow ? p.row : p.row + dRow;
+            const newCol = p.absCol ? p.col : p.col + dCol;
+            return formatAddr(newRow, newCol, p.absCol, p.absRow);
+        };
+        if (right) {
+            const leftAdjusted = adjustOne(left);
+            const rightAdjusted = adjustOne(right);
+            return `${sheetPrefix ?? ""}${leftAdjusted}:${rightAdjusted}`;
+        }
+        const singleAdjusted = adjustOne(left);
+        return `${sheetPrefix ?? ""}${singleAdjusted}`;
+    });
+};

package/dist/esm/formula.d.ts

@@ -0,0 +1,80 @@
+import type { AreaStyle, GridRange, SelectionArea } from "@rowsncolumns/common-types";
+/**
+ * Add/remove parenthesis in formulas
+ * @param str
+ * @returns
+ */
+export declare const balanceParentheses: (str: string) => string;
+/**
+ * Add closing quotes in formulas when a string is unterminated.
+ * Handles escaped quotes ("") inside strings.
+ */
+export declare const balanceQuotes: (str: string) => string;
+/**
+ * Add/remove parenthesis and add closing quotes in formulas.
+ */
+export declare const balanceFormula: (str: string) => string;
+/**
+ * Check if parenthesis is balanced
+ * @param str
+ * @returns
+ */
+export declare const isBalancedParenthesis: (str: string) => boolean;
+export declare const looksLikeMarkdown: (text: string) => boolean;
+export declare const setDefaultEnableAtFormula: (enable?: boolean) => void;
+/**
+ * Check if text is a formula
+ * @param text
+ * @returns
+ */
+export declare const isAFormula: (text: any) => boolean;
+/**
+ * Check if text is a formula-shaped expression stored WITHOUT the
+ * leading "=". OOXML defined names (`<definedName>` in workbook.xml)
+ * store their expressions bare — `OFFSET(Sheet1!$A$1,0,0,10)` rather
+ * than `=OFFSET(...)` — so `isAFormula` can't classify them.
+ *
+ * Returns false for anything that already resolves as a static value
+ * or plain reference today: quoted string / numeric / boolean
+ * literals, single-area range references (including external-workbook
+ * references like `'[1]Revenue'!$A$17`), and broken `#REF!`
+ * expressions. Returns true only for expressions that need the
+ * calculator: function calls and operator expressions.
+ * @param text
+ * @returns
+ */
+export declare const isBareFormulaExpression: (text: unknown) => boolean;
+export declare const isAlternateFormula: (text: string) => boolean;
+export declare const isValidFormula: (text: any) => boolean;
+/**
+ * Check if a key is an Arrow key
+ * @param code
+ * @returns
+ */
+export declare const isAnArrowKey: (code: string) => boolean;
+/**
+ * Iterate over all cells in a bound
+ * @param bounds
+ * @param callback
+ */
+export declare const iterateCells: (top: number, right: number | ((rowIndex: number) => number), bottom: number, left: number) => Generator<[number, number]>;
+export declare function combineIterators<T>(...generators: (Generator<T> | undefined)[]): Generator<T>;
+/**
+ * Iterate cells in range
+ * @param range
+ * @returns
+ */
+export type GridRangeIterator = GridRange | {
+    startRowIndex: number;
+    endColumnIndex: number | ((rowIndex: number) => number);
+    endRowIndex: number;
+    startColumnIndex: number;
+};
+export declare const iterateCellsInRange: (range: GridRangeIterator) => Generator<[number, number], any, any>;
+/**
+ * Iterate all cells in multiple selections
+ * @param selections
+ * @returns
+ */
+export declare const iterateSelections: <T extends AreaStyle>(selections: SelectionArea<T>[]) => Generator<Generator<[number, number], any, any>, void, unknown>;
+//# sourceMappingURL=formula.d.ts.map

package/dist/esm/formula.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula.d.ts","sourceRoot":"","sources":["../../formula.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,SAAS,EACT,aAAa,EACd,MAAM,4BAA4B,CAAC;AAgBpC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,WAc7C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,WAkDxC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,WAEzC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,YAEhD,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,OAsChD,CAAC;AAIF,eAAO,MAAM,yBAAyB,GAAI,SAAS,OAAO,SAEzD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,GAAG,YAcnC,CAAC;AAYF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,GAAI,MAAM,OAAO,KAAG,OAgCvD,CAAC;AAgBF,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,YAwC9C,CAAC;AAGF,eAAO,MAAM,cAAc,GAAI,MAAM,GAAG,YAGvC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,YAA6B,CAAC;AAEvE;;;;GAIG;AACH,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EACX,OAAO,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,EAC9C,QAAQ,MAAM,EACd,MAAM,MAAM,KACX,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAO5B,CAAC;AAEF,wBAAiB,gBAAgB,CAAC,CAAC,EACjC,GAAG,UAAU,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,GAC1C,SAAS,CAAC,CAAC,CAAC,CAId;AAED;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GACzB,SAAS,GACT;IACE,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IACxD,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AACN,eAAO,MAAM,mBAAmB,GAAI,OAAO,iBAAiB,0CAO3D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAc,CAAC,SAAS,SAAS,EAC7D,YAAY,aAAa,CAAC,CAAC,CAAC,EAAE,oEAK/B,CAAC"}