@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/api/date.js

@@ -0,0 +1,220 @@
+import { parse } from "@rowsncolumns/date-parser";
+// Pre-compiled regex patterns for better performance.
+// AM/PM variants still cap hours at 2 digits — a 12-hour clock entry like
+// `100:00 AM` is nonsensical. The non-meridian variants allow up to 4
+// digits in the hour field so Excel-style elapsed-time inputs (e.g.
+// `25:30:00`, `9999:00:00`) parse cleanly; the numeric upper bound is
+// then enforced by `isValidTimeComponents` (`MAX_ELAPSED_HOURS`).
+const TIME_REGEX = {
+    FULL_WITH_MERIDIAN: /^(\d{1,2}):(\d{1,2}):(\d{1,2})\s*(AM|PM|a|p)$/i,
+    FULL: /^(\d{1,4}):(\d{1,2}):(\d{1,2})$/,
+    SHORT_WITH_MERIDIAN: /^(\d{1,2}):(\d{1,2})\s*(AM|PM)$/i,
+    SHORT: /^(\d{1,4}):(\d{1,2})$/,
+};
+// Time format definitions
+const TIME_FORMATS = {
+    FULL_WITH_MERIDIAN: "hh:mm:ss AM/PM",
+    FULL: "hh:mm:ss",
+    SHORT_WITH_MERIDIAN: "hh:mm AM/PM",
+    SHORT: "hh:mm",
+    // Excel "elapsed time" patterns. The square brackets around `h` tell the
+    // formatter to display the full elapsed-hours count without wrapping at
+    // 24 — `[h]:mm:ss` will render a 25.5-hour duration as `25:30:00`, not
+    // `01:30:00`. Excel auto-applies these when the user types a value with
+    // hours > 24.
+    FULL_ELAPSED: "[h]:mm:ss",
+    SHORT_ELAPSED: "[h]:mm",
+};
+// Cap elapsed-time hours at Excel's documented limit (`9999:59:59`). Beyond
+// this, treat as text rather than producing absurdly large fractional
+// serials. JS `Number.isFinite` would let `Infinity` through, so we cap
+// explicitly.
+const MAX_ELAPSED_HOURS = 9999;
+// Excel's date system runs from 1900-01-01 (serial 1) to 9999-12-31
+// (serial 2958465). The 1904 mode pushes the floor up to 1904-01-01, but
+// 1900 is the safer baseline for cell-input validation since downstream
+// code converts to serials regardless of mode. Anything outside this
+// window has no valid Excel serial representation — Excel surfaces such
+// inputs as plain text rather than letting them become bogus serials.
+const EXCEL_DATE_MIN_YEAR = 1900;
+const EXCEL_DATE_MAX_YEAR = 9999;
+// Performant date validation with early returns
+export const validateDate = (value, locale) => {
+    if (typeof value !== "string")
+        return undefined;
+    // Reject patterns that look like incomplete time formats (e.g., "1a", "1p", "12p")
+    // These should be treated as text, not dates/times
+    const trimmed = value.trim();
+    if (/^\d{1,2}[ap]$/i.test(trimmed)) {
+        return undefined;
+    }
+    const result = parse(value, { locale });
+    if (!result)
+        return undefined;
+    const { dateValue } = result;
+    const year = dateValue.getFullYear();
+    // Pre-1900 and post-9999 dates have no Excel serial representation —
+    // treat them as plain text (matches both Excel and Sheets behavior, and
+    // prevents downstream `toSerial` from emitting negative / out-of-range
+    // serials that would corrupt save/reload).
+    if (year < EXCEL_DATE_MIN_YEAR || year > EXCEL_DATE_MAX_YEAR) {
+        return undefined;
+    }
+    return {
+        format: result.pattern,
+        parts: {
+            year,
+            month: dateValue.getMonth(),
+            day: dateValue.getDate(),
+            hour: dateValue.getHours(),
+            minute: dateValue.getMinutes(),
+            second: dateValue.getSeconds(),
+        },
+    };
+};
+// Time-only validation
+export const validateDateTime = (value) => {
+    if (typeof value !== "string")
+        return undefined;
+    const str = value.trim();
+    let match;
+    // Try full format with meridian
+    if ((match = TIME_REGEX.FULL_WITH_MERIDIAN.exec(str))) {
+        const hour = parseInt(match[1], 10);
+        const minute = parseInt(match[2], 10);
+        const second = parseInt(match[3], 10);
+        const meridian = match[4];
+        if (isValidTimeComponents(hour, minute, second, meridian)) {
+            return createTimeResult(TIME_FORMATS.FULL_WITH_MERIDIAN, adjustHour(hour, meridian), minute, second);
+        }
+    }
+    // Try full format
+    if ((match = TIME_REGEX.FULL.exec(str))) {
+        const hour = parseInt(match[1], 10);
+        const minute = parseInt(match[2], 10);
+        const second = parseInt(match[3], 10);
+        if (isValidTimeComponents(hour, minute, second)) {
+            // Excel parity: hour > 24 is an elapsed-time entry (e.g. `25:30:00`,
+            // `48:00:00`). Auto-apply `[h]:mm:ss` so the cell displays the full
+            // hours count instead of wrapping to `01:30:00`.
+            const format = hour > 24 ? TIME_FORMATS.FULL_ELAPSED : TIME_FORMATS.FULL;
+            return createTimeResult(format, hour, minute, second);
+        }
+    }
+    // Try short format with meridian
+    if ((match = TIME_REGEX.SHORT_WITH_MERIDIAN.exec(str))) {
+        const hour = parseInt(match[1], 10);
+        const minute = parseInt(match[2], 10);
+        const meridian = match[3];
+        if (isValidTimeComponents(hour, minute, 0, meridian)) {
+            return createTimeResult(TIME_FORMATS.SHORT_WITH_MERIDIAN, adjustHour(hour, meridian), minute, 0);
+        }
+    }
+    // Try short format
+    if ((match = TIME_REGEX.SHORT.exec(str))) {
+        const hour = parseInt(match[1], 10);
+        const minute = parseInt(match[2], 10);
+        if (isValidTimeComponents(hour, minute, 0)) {
+            // Same elapsed-time auto-pattern logic as the full form above.
+            const format = hour > 24 ? TIME_FORMATS.SHORT_ELAPSED : TIME_FORMATS.SHORT;
+            return createTimeResult(format, hour, minute, 0);
+        }
+    }
+    return undefined;
+};
+// Helper functions for time validation
+const isValidTimeComponents = (hour, minute, second, meridian) => {
+    if (minute > 59 || second > 59) {
+        return false;
+    }
+    const upperMeridian = meridian?.toUpperCase();
+    if (upperMeridian) {
+        // 12-hour clock with AM/PM — hours 1..12 only.
+        if (hour < 1 || hour > 12) {
+            return false;
+        }
+        return true;
+    }
+    // 24-hour clock OR elapsed-time entry. Excel accepts hour up to 9999 for
+    // elapsed times like `[h]:mm:ss` (e.g. `25:30:00`, `100:00:00`). The
+    // upper cap keeps the resulting serial within a sane range — anything
+    // beyond is treated as text. Hour === 24 must have zero min/sec (the
+    // `24:00:00` end-of-day convention); larger hours are unconstrained.
+    if (hour < 0 || hour > MAX_ELAPSED_HOURS) {
+        return false;
+    }
+    if (hour === 24 && (minute !== 0 || second !== 0)) {
+        return false;
+    }
+    return true;
+};
+const adjustHour = (hour, meridian) => {
+    const meridianChar = meridian?.toLowerCase().charAt(0);
+    if (meridianChar === "p" && hour < 12) {
+        return hour + 12;
+    }
+    if (meridianChar === "a" && hour === 12) {
+        return 0;
+    }
+    return hour;
+};
+/**
+ * Convert a time-only value to an Excel serial fraction.
+ */
+export const toTimeSerial = (hour, minute, second) => {
+    const seconds = hour * 3600 + minute * 60 + second;
+    return seconds / (24 * 60 * 60);
+};
+const createTimeResult = (format, hour, minute, second) => {
+    const base = new Date(1899, 11, 31);
+    return {
+        format,
+        parts: {
+            year: base.getFullYear(),
+            month: base.getMonth(),
+            day: base.getDate(),
+            hour,
+            minute,
+            second,
+        },
+        isTimeOnly: true,
+    };
+};
+// Simple wrapper functions with type guards
+export const isValidDate = (value, locale) => {
+    if (!value || (typeof value !== "string" && !(value instanceof Date))) {
+        return false;
+    }
+    return !!validateDate(value, locale);
+};
+export const isValidDateTime = (value) => {
+    if (!value || typeof value !== "string") {
+        return false;
+    }
+    return !!validateDateTime(value);
+};
+// Fast pattern detection without validation
+export const detectDateFormatPattern = (value, locale) => {
+    if (!value || (typeof value !== "string" && !(value instanceof Date))) {
+        return undefined;
+    }
+    return validateDate(value, locale)?.format;
+};
+export const detectDateTimeFormatPattern = (value) => {
+    if (!value || typeof value !== "string") {
+        return undefined;
+    }
+    return validateDateTime(value)?.format;
+};
+// Current date utilities using single Date instance
+const getCurrentParts = () => {
+    const now = new Date();
+    return {
+        year: now.getFullYear(),
+        month: now.getMonth(),
+        day: now.getDate(),
+    };
+};
+export const getCurrentYear = () => getCurrentParts().year;
+export const getCurrentMonth = () => getCurrentParts().month;
+export const getCurrentDay = () => getCurrentParts().day;

package/dist/esm/api/decimals.d.ts

@@ -0,0 +1,10 @@
+export declare const pattern_number = "#";
+export declare const pattern_number_thousands = "#,##0";
+export declare const getDecimalPlaces: (value: string | number, locale?: string) => number;
+export declare const detectDecimalPattern: (value: string | number | boolean | Date | undefined, defaultPattern?: string, locale?: string) => string;
+export declare const changeDecimals: (pattern?: string | undefined, changeBy?: number, delta?: boolean) => string;
+export declare const getCurrentDecimalCountInPattern: (pattern?: string | undefined | null) => number;
+export declare const addThousandSeparator: (pattern?: string | undefined) => string;
+export declare const removeThousandSeparator: (pattern?: string | undefined) => string;
+export declare const hasThousandsSeparator: (pattern?: string | undefined) => boolean;
+//# sourceMappingURL=decimals.d.ts.map

package/dist/esm/api/decimals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimals.d.ts","sourceRoot":"","sources":["../../../api/decimals.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,wBAAwB,UAAU,CAAC;AAyDhD,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,GAAG,MAAM,EACtB,SAAS,MAAM,KACd,MAsCF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EACnD,uBAA+B,EAC/B,SAAS,MAAM,WAkChB,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,UAAS,MAAM,GAAG,SAAc,EAChC,WAAU,MAAU,EACpB,eAAY,WAuCb,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,UAAS,MAAM,GAAG,SAAS,GAAG,IAAS,WAexC,CAAC;AAGF,eAAO,MAAM,oBAAoB,GAAI,UAAS,MAAM,GAAG,SAAc,WAwBpE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,UAAS,MAAM,GAAG,SAAc,WAQvE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,UAAS,MAAM,GAAG,SAAc,YAIrE,CAAC"}

package/dist/esm/api/decimals.js

@@ -0,0 +1,181 @@
+import { isNil } from "@rowsncolumns/utils";
+import { getLocaleSeparators } from "./intl";
+export const pattern_number = "#";
+export const pattern_number_thousands = "#,##0";
+// Pre-compile regular expressions
+const THOUSAND_REGEX = /(\,[#,0]{3})/gi;
+const PATTERN_SEPARATOR = ";";
+const THOUSAND_PATTERN = ",##0";
+/**
+ * Change decimals places of a pattern
+ * @param pattern
+ * @param changeBy
+ *
+ * https://regex101.com/r/SzttwT/2
+ */
+const DECIMAL_REGEX = new RegExp(
+// "(?<prefix>[\\d]+)(?<decimal>\\.)?(?<suffix>\\d{1,})?",
+"(?<prefix>[\\d#,]+)(?<decimal>\\.)?(?<suffix>\\d{1,})?", "i");
+const createZeros = (len) => {
+    return Array.from({ length: len })
+        .map(() => `0`)
+        .join("");
+};
+const CANONICAL_DOT_DECIMAL_REGEX = /^-?\d+\.\d+(?:e[+-]?\d+)?$/i;
+const MAX_FLOAT_ROUNDING_DECIMALS = 12;
+const FLOAT_ROUNDING_EPSILON_FACTOR = 10;
+const normalizeFloatingPointString = (value) => {
+    if (!Number.isFinite(value)) {
+        return String(value);
+    }
+    const tolerance = Number.EPSILON * Math.max(1, Math.abs(value)) * FLOAT_ROUNDING_EPSILON_FACTOR;
+    for (let decimals = 0; decimals <= MAX_FLOAT_ROUNDING_DECIMALS; decimals += 1) {
+        const rounded = Number(value.toFixed(decimals));
+        if (Math.abs(value - rounded) <= tolerance) {
+            return rounded.toString();
+        }
+    }
+    return value.toString();
+};
+/**
+ * Get the number of decimal places in a string
+ * @param value The string value to check
+ * @returns The number of decimal places
+ */
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+export const getDecimalPlaces = (value, locale) => {
+    if (typeof value === "number") {
+        const normalizedValue = normalizeFloatingPointString(value);
+        const dotIndex = normalizedValue.indexOf(".");
+        if (dotIndex === -1) {
+            return 0;
+        }
+        const exponentIndex = normalizedValue.search(/[eE]/);
+        const endIndex = exponentIndex === -1 ? normalizedValue.length : exponentIndex;
+        return Math.max(endIndex - dotIndex - 1, 0);
+    }
+    const { decimal, group } = getLocaleSeparators(locale);
+    const decimalSeparator = decimal ?? ".";
+    const groupSeparator = group ?? ",";
+    const allowed = `0-9${escapeRegex(decimalSeparator)}${escapeRegex(groupSeparator)}`;
+    const cleanupRegex = new RegExp(`[^${allowed}]`, "g");
+    const cleanedValue = value.replace(cleanupRegex, "");
+    if (!decimalSeparator || !cleanedValue.includes(decimalSeparator)) {
+        return 0;
+    }
+    const parts = cleanedValue.split(decimalSeparator);
+    // If there are no decimal separators, return 0
+    if (parts.length === 1) {
+        return 0;
+    }
+    // Get the last part after the decimal separator
+    const decimalPart = parts[parts.length - 1];
+    // Return the length of the decimal part
+    return decimalPart.length;
+};
+export const detectDecimalPattern = (value, defaultPattern = pattern_number, locale) => {
+    const str = typeof value === "number" ? normalizeFloatingPointString(value) : String(value);
+    const { decimal, group } = getLocaleSeparators(locale);
+    const groupSeparator = group ?? ",";
+    const decimalSeparator = decimal ?? ".";
+    const usesCanonicalDotDecimal = decimalSeparator !== "." && CANONICAL_DOT_DECIMAL_REGEX.test(str);
+    const effectiveDecimalSeparator = usesCanonicalDotDecimal
+        ? "."
+        : decimalSeparator;
+    const integerPart = effectiveDecimalSeparator
+        ? str.split(effectiveDecimalSeparator)[0]
+        : str;
+    const hasThousands = Boolean(groupSeparator) && integerPart.includes(groupSeparator);
+    const decimalsLen = getDecimalPlaces(value, locale);
+    // Use "0" pattern for numbers less than 1 to ensure leading zero
+    const numValue = Number(str.replace(/[^0-9.-]/g, ""));
+    const needsLeadingZero = Math.abs(numValue) < 1;
+    let prefix = hasThousands ? pattern_number_thousands : defaultPattern;
+    if (decimalsLen !== 0) {
+        // For decimal numbers less than 1, use "0" pattern to show leading zero
+        if (needsLeadingZero && prefix === pattern_number) {
+            prefix = "0";
+        }
+        return changeDecimals(prefix, decimalsLen, true);
+    }
+    return prefix;
+};
+export const changeDecimals = (pattern = "", changeBy = 1, delta = true) => {
+    const patterns = pattern.split(PATTERN_SEPARATOR);
+    return patterns
+        .map((p) => {
+        const match = p.match(DECIMAL_REGEX);
+        if (match && match.groups) {
+            const { _, decimal, suffix } = match.groups;
+            // There is no decimal point
+            if (!decimal) {
+                const newDecimals = Math.max(changeBy, 0);
+                const zeros = createZeros(newDecimals);
+                return p.replace(DECIMAL_REGEX, `$1$2${zeros.length ? "." + zeros : ""}`);
+            }
+            let newSuffix = 0;
+            if (suffix) {
+                newSuffix = Math.max(delta ? suffix.length + changeBy : changeBy, 0);
+            }
+            const zeros = createZeros(newSuffix);
+            return p.replace(DECIMAL_REGEX, `$1${zeros.length ? "$2" + zeros : ""}`);
+        }
+        // Empty pattern
+        if (!p) {
+            const newDecimals = Math.max(changeBy, 0);
+            const zeros = createZeros(newDecimals);
+            return `0${zeros.length ? "." + zeros : ""}`;
+        }
+        return p;
+    })
+        .join(PATTERN_SEPARATOR);
+};
+export const getCurrentDecimalCountInPattern = (pattern = "") => {
+    if (!pattern)
+        return 0;
+    const patterns = pattern.split(PATTERN_SEPARATOR);
+    return Math.max(0, ...patterns.map((p) => {
+        const match = p.match(DECIMAL_REGEX);
+        if (match && match.groups) {
+            const suffix = match.groups.suffix;
+            return isNil(suffix) ? 0 : suffix.length;
+        }
+        return 0;
+    }));
+};
+// Adds a thousand separator
+export const addThousandSeparator = (pattern = "") => {
+    if (!pattern) {
+        return `#${THOUSAND_PATTERN}`;
+    }
+    const patterns = pattern.split(PATTERN_SEPARATOR);
+    return patterns
+        .map((p) => {
+        const hasThousand = THOUSAND_REGEX.test(p);
+        // Ignore if its already has thousand separator
+        if (hasThousand) {
+            return p;
+        }
+        const decimalIndex = p.indexOf(".");
+        if (decimalIndex !== -1) {
+            return (p.substring(0, decimalIndex) +
+                THOUSAND_PATTERN +
+                p.substring(decimalIndex));
+        }
+        return p + THOUSAND_PATTERN;
+    })
+        .join(PATTERN_SEPARATOR);
+};
+export const removeThousandSeparator = (pattern = "") => {
+    const patterns = pattern.split(PATTERN_SEPARATOR);
+    return patterns
+        .map((p) => {
+        return p.replace(THOUSAND_REGEX, ``);
+    })
+        .join(PATTERN_SEPARATOR);
+};
+export const hasThousandsSeparator = (pattern = "") => {
+    return pattern
+        .split(PATTERN_SEPARATOR)
+        .some((p) => p.match(THOUSAND_PATTERN));
+};

package/dist/esm/api/dependency.d.ts

@@ -0,0 +1,64 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+import type { CellData } from "@rowsncolumns/spreadsheet";
+import type { Draft } from "immer";
+import type { useCalculation } from "../hooks/use-calculation";
+import type { CellXfsRegistry } from "../hooks/use-cellxfs-registry";
+import type { SharedStringRegistry } from "../hooks/use-ss-registry";
+import type { SheetData } from "../hooks/use-spreadsheet-state";
+import type { RecalcCellCoordinate } from "../types";
+type ProcessDependentCellsProps<T extends CellData> = {
+    rowIndex: number;
+    columnIndex: number;
+    sheetId: number;
+    destinationSheetId?: number;
+    draft: Draft<SheetData<T>>;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    getSheetName?: (sheetId: number) => string;
+    enqueueCalculation?: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueGraphOperation?: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    rowDelta?: number | ((rowIndex: number) => number);
+    columnDelta?: number | ((columnIndex: number) => number);
+    recalcCells: Map<string, RecalcCellCoordinate>;
+    sourceRange?: GridRange;
+    movedKeys: Set<string>;
+    locale?: string;
+    columnCount?: number;
+    rowCount?: number;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+};
+export declare const processSideEffectDependentCells: <T extends CellData>({ draft, rowIndex, columnIndex, sheetId, destinationSheetId, getDependents, getSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, columnDelta, rowDelta, sourceRange, movedKeys, locale, rowCount, columnCount, cellXfsRegistry, sharedStringRegistry, }: ProcessDependentCellsProps<T>) => void;
+export declare const collectUniqueDependentsForRange: <T extends CellData>(params: {
+    draft: Draft<SheetData<T>>;
+    sheetId: number;
+    sourceRange: GridRange;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+}) => Map<string, {
+    sheetId: number;
+    rowIndex: number;
+    columnIndex: number;
+}>;
+export declare const moveFormulaAtPosition: <T extends CellData>({ draft, position, destinationSheetId, activeSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, movedKeys, rowDelta, columnDelta, sourceRange, locale, rowCount, columnCount, cellXfsRegistry, sharedStringRegistry, }: {
+    draft: Draft<SheetData<T>>;
+    position: {
+        sheetId: number;
+        rowIndex: number;
+        columnIndex: number;
+    };
+    destinationSheetId?: number;
+    activeSheetName?: string;
+    enqueueCalculation?: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueGraphOperation?: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    recalcCells: Map<string, RecalcCellCoordinate>;
+    movedKeys: Set<string>;
+    rowDelta?: number;
+    columnDelta?: number;
+    sourceRange?: GridRange;
+    locale?: string;
+    rowCount?: number;
+    columnCount?: number;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+}) => void;
+export {};
+//# sourceMappingURL=dependency.d.ts.map

package/dist/esm/api/dependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency.d.ts","sourceRoot":"","sources":["../../../api/dependency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAG5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAIrD,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3C,kBAAkB,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7E,qBAAqB,CAAC,EAAE,UAAU,CAChC,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IACnD,WAAW,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IACzD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC/C,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAAI,CAAC,SAAS,QAAQ,EAAE,0QAoBjE,0BAA0B,CAAC,CAAC,CAAC,SAwO/B,CAAC;AAIF,eAAO,MAAM,+BAA+B,GAAI,CAAC,SAAS,QAAQ,EAAE,QAAQ;IAC1E,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,SAAS,CAAC;IACvB,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;CACnE;aAIc,MAAM;cAAY,MAAM;iBAAe,MAAM;EAsC3D,CAAC;AAGF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,wOAiBvD;IACD,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,QAAQ,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IACrE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7E,qBAAqB,CAAC,EAAE,UAAU,CAChC,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC/C,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C,SAgFA,CAAC"}