@rowsncolumns/toolkit 24.4.1

package/dist/esm/excel-import-session.js

@@ -0,0 +1,255 @@
+import { RequestType, ResponseType } from "./excel-parser/types";
+// Hosts whose bundlers can't resolve the `new URL(...)` worker specifier
+// (e.g. turbopack) can supply their own worker constructors here — same
+// global and same `excel` slot as `createExcelImportWorker`.
+const createWorkerInstance = () => globalThis.__ATHENA_TOOLKIT_WORKER_FACTORIES?.excel?.() ??
+    new Worker(new URL("@rowsncolumns/toolkit/worker", import.meta.url), {
+        type: "module",
+    });
+// The watchdog covers workbook opening only (the worker-never-loaded
+// failure mode). A resident session is expected to sit idle between sheet
+// loads, and a streaming sheet can legitimately pause on host-side
+// consumption, so prolonged silence is not an error outside open().
+const WORKER_OPEN_TIMEOUT_MS = 20000;
+const abortError = () => {
+    const error = new Error("The sheet load was aborted");
+    error.name = "AbortError";
+    return error;
+};
+/**
+ * Typed client for the session import worker protocol (issue #336). Opens
+ * a workbook once, keeps it resident worker-side, and streams individual
+ * sheets on demand with automatic requestId allocation, chunk
+ * acknowledgement backpressure, cancellation, and generation management.
+ */
+export const createExcelImportSession = (file, options) => {
+    const worker = createWorkerInstance();
+    let generation = 0;
+    let requestCounter = 0;
+    let disposed = false;
+    let pendingOpen = null;
+    const streams = new Map();
+    let openWatchdog = null;
+    const clearOpenWatchdog = () => {
+        if (openWatchdog !== null) {
+            clearTimeout(openWatchdog);
+            openWatchdog = null;
+        }
+    };
+    const failEverything = (error) => {
+        clearOpenWatchdog();
+        if (pendingOpen) {
+            const { reject } = pendingOpen;
+            pendingOpen = null;
+            reject(error);
+        }
+        for (const state of streams.values()) {
+            state.failed = error;
+            state.waiter?.();
+        }
+    };
+    const settleOpen = (result) => {
+        if (!pendingOpen) {
+            return;
+        }
+        clearOpenWatchdog();
+        const { resolve } = pendingOpen;
+        pendingOpen = null;
+        resolve(result);
+    };
+    worker.onmessage = (e) => {
+        const data = e?.data;
+        if (!data?.responseType) {
+            return;
+        }
+        const messageGeneration = data.generation;
+        if (messageGeneration !== undefined && messageGeneration !== generation) {
+            return;
+        }
+        switch (data.responseType) {
+            case ResponseType.OPEN_WORKBOOK_COMPLETE: {
+                const { responseType: _rt, generation: _g, ...rest } = data;
+                settleOpen({ status: "open", ...rest });
+                break;
+            }
+            case ResponseType.PASSWORD_REQUIRED: {
+                settleOpen({ status: "password-required", message: data.message });
+                break;
+            }
+            case ResponseType.SHEET_CHUNK:
+            case ResponseType.SHEET_COMPLETE: {
+                const state = streams.get(data.requestId);
+                if (state) {
+                    state.queue.push(data);
+                    state.waiter?.();
+                }
+                break;
+            }
+            case ResponseType.ERROR: {
+                const error = new Error(data.error ?? "Excel import worker error");
+                const requestId = data.requestId;
+                if (requestId !== undefined) {
+                    const state = streams.get(requestId);
+                    if (state) {
+                        state.failed = error;
+                        state.waiter?.();
+                    }
+                    break;
+                }
+                if (pendingOpen) {
+                    clearOpenWatchdog();
+                    const { reject } = pendingOpen;
+                    pendingOpen = null;
+                    reject(error);
+                }
+                break;
+            }
+            default:
+                // IMPORT_PROGRESS and other liveness messages need no routing.
+                break;
+        }
+    };
+    worker.onerror = (error) => {
+        failEverything(error instanceof ErrorEvent && error.message
+            ? new Error(error.message)
+            : new Error("Worker failed to load or crashed. Check worker URL resolution and browser console/network logs."));
+    };
+    worker.onmessageerror = () => {
+        failEverything(new Error("Worker could not deserialize a message (onmessageerror). It likely failed to load. Check the browser console/network logs."));
+    };
+    const awaitOpenResult = (send) => new Promise((resolve, reject) => {
+        if (disposed) {
+            reject(new Error("The import session has been disposed"));
+            return;
+        }
+        if (pendingOpen) {
+            pendingOpen.reject(new Error("Superseded by a newer open()"));
+        }
+        pendingOpen = { generation, resolve, reject };
+        send();
+        clearOpenWatchdog();
+        openWatchdog = setTimeout(() => {
+            failEverything(new Error("Worker failed to load or stalled (no response). Check worker URL resolution and browser console/network logs."));
+        }, WORKER_OPEN_TIMEOUT_MS);
+    });
+    const open = () => {
+        generation += 1;
+        // Streams from the previous generation will never see another message.
+        const superseded = new Error("Superseded by a newer open()");
+        for (const state of streams.values()) {
+            state.failed = superseded;
+            state.waiter?.();
+        }
+        return awaitOpenResult(() => {
+            worker.postMessage({
+                requestType: RequestType.OPEN_WORKBOOK,
+                generation,
+                file,
+                minRowCount: options?.minRowCount,
+                minColumnCount: options?.minColumnCount,
+            });
+        });
+    };
+    const providePassword = (password) => awaitOpenResult(() => {
+        worker.postMessage({
+            requestType: RequestType.PROVIDE_PASSWORD,
+            password,
+        });
+    });
+    async function* loadSheet(sheetId, loadOptions) {
+        if (disposed) {
+            throw new Error("The import session has been disposed");
+        }
+        if (generation === 0) {
+            throw new Error("open() must resolve before loading sheets");
+        }
+        const signal = loadOptions?.signal;
+        if (signal?.aborted) {
+            throw abortError();
+        }
+        requestCounter += 1;
+        const requestId = `req-${requestCounter}`;
+        const requestGeneration = generation;
+        const state = { queue: [], waiter: null, failed: null };
+        streams.set(requestId, state);
+        let done = false;
+        const cancel = () => {
+            if (done || disposed) {
+                return;
+            }
+            worker.postMessage({
+                requestType: RequestType.CANCEL_REQUEST,
+                generation: requestGeneration,
+                requestId,
+            });
+        };
+        const onAbort = () => {
+            cancel();
+            state.failed = abortError();
+            state.waiter?.();
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+            worker.postMessage({
+                requestType: RequestType.LOAD_SHEET,
+                generation: requestGeneration,
+                requestId,
+                sheetId,
+                options: {
+                    chunkSize: loadOptions?.chunkSize,
+                    enableCellXfsRegistry: loadOptions?.enableCellXfsRegistry,
+                    enableSharedStrings: loadOptions?.enableSharedStrings,
+                    enableBackpressure: true,
+                },
+            });
+            for (;;) {
+                if (state.failed) {
+                    throw state.failed;
+                }
+                const message = state.queue.shift();
+                if (!message) {
+                    await new Promise((resolve) => {
+                        state.waiter = resolve;
+                    });
+                    state.waiter = null;
+                    continue;
+                }
+                if (message.responseType === ResponseType.SHEET_COMPLETE) {
+                    done = true;
+                    const { responseType: _rt, generation: _g, requestId: _r, ...rest } = message;
+                    return rest;
+                }
+                const { responseType: _rt, generation: _g, requestId: _r, ...chunk } = message;
+                yield chunk;
+                // The host consumed the chunk (the generator resumed) — release the
+                // worker's backpressure gate.
+                worker.postMessage({
+                    requestType: RequestType.ACK_ROW_DATA,
+                    sheetId: chunk.sheetId,
+                    chunkIndex: chunk.chunkIndex,
+                    requestId,
+                });
+            }
+        }
+        finally {
+            signal?.removeEventListener("abort", onAbort);
+            streams.delete(requestId);
+            // Early generator termination (break / .return()) leaves the worker
+            // stream running — stop it.
+            cancel();
+        }
+    }
+    const dispose = () => {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        worker.postMessage({
+            requestType: RequestType.DISPOSE_WORKBOOK,
+            generation,
+        });
+        failEverything(new Error("The import session has been disposed"));
+        worker.terminate();
+    };
+    return { open, providePassword, loadSheet, dispose };
+};

package/dist/esm/excel-import-worker.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from "rxjs";
+import type { WorkerResponse } from "./excel-parser/types";
+export declare const createExcelImportWorker: (file: File | ArrayBuffer, minRowCount?: number, minColumnCount?: number) => {
+    observable: Observable<WorkerResponse>;
+    sendMessage: (message: any) => void;
+};
+//# sourceMappingURL=excel-import-worker.d.ts.map

package/dist/esm/excel-import-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excel-import-worker.d.ts","sourceRoot":"","sources":["../../excel-import-worker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAW,MAAM,MAAM,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAuC3D,eAAO,MAAM,uBAAuB,GAClC,MAAM,IAAI,GAAG,WAAW,EACxB,cAAc,MAAM,EACpB,iBAAiB,MAAM;;2BAyGO,GAAG;CASlC,CAAC"}

package/dist/esm/excel-import-worker.js

@@ -0,0 +1,116 @@
+import { Observable, Subject } from "rxjs";
+import { RequestType, ResponseType } from "./excel-parser/types";
+const getWorkerErrorMessage = (error) => {
+    if (error instanceof ErrorEvent) {
+        const parts = [error.message || "Worker runtime error"];
+        if (error.filename) {
+            const line = error.lineno ? `:${error.lineno}` : "";
+            const col = error.colno ? `:${error.colno}` : "";
+            parts.push(`(${error.filename}${line}${col})`);
+        }
+        return parts.join(" ");
+    }
+    // Some browsers emit a plain Event for worker load failures.
+    return "Worker failed to load or crashed. Check worker URL resolution and browser console/network logs.";
+};
+const getWorkerFactories = () => globalThis.__ATHENA_TOOLKIT_WORKER_FACTORIES;
+// A module worker that fails to load/instantiate (e.g. a transient chunk fetch
+// failure on the first import of a session) can emit neither `onmessage` nor
+// `onerror` in some browsers, so the import promise would hang forever (the
+// "Parsing XLSX" loader never clears). The watchdog converts prolonged silence
+// into the normal ERROR path so callers can recover instead of spinning.
+const WORKER_INACTIVITY_TIMEOUT_MS = 20000;
+export const createExcelImportWorker = (file, minRowCount, minColumnCount) => {
+    const worker = getWorkerFactories()?.excel?.() ??
+        new Worker(new URL("@rowsncolumns/toolkit/worker", import.meta.url), {
+            type: "module",
+        });
+    // Create a subject to emit worker events
+    const subject = new Subject();
+    // Watchdog state: once settled (terminal event or failure) we stop watching.
+    let settled = false;
+    let watchdogTimer = null;
+    const clearWatchdog = () => {
+        if (watchdogTimer !== null) {
+            clearTimeout(watchdogTimer);
+            watchdogTimer = null;
+        }
+    };
+    const failWorker = (message) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        clearWatchdog();
+        subject.next({
+            responseType: ResponseType.ERROR,
+            error: message,
+        });
+        subject.complete();
+        worker.terminate();
+    };
+    const armWatchdog = () => {
+        if (settled) {
+            return;
+        }
+        clearWatchdog();
+        watchdogTimer = setTimeout(() => {
+            failWorker("Worker failed to load or stalled (no response). Check worker URL resolution and browser console/network logs.");
+        }, WORKER_INACTIVITY_TIMEOUT_MS);
+    };
+    // Handle worker messages
+    worker.onmessage = (e) => {
+        if (settled) {
+            return;
+        }
+        const responseType = e?.data?.responseType;
+        if (responseType === ResponseType.PARSE_EXCEL_COMPLETE ||
+            responseType === ResponseType.ERROR) {
+            // Terminal event from the worker — stop watching.
+            settled = true;
+            clearWatchdog();
+        }
+        else {
+            // A healthy import streams messages continuously; reset the inactivity
+            // timer so only a real stall (or a worker that never starts) trips it.
+            armWatchdog();
+        }
+        subject.next(e.data);
+    };
+    // Handle worker errors
+    worker.onerror = (error) => {
+        failWorker(getWorkerErrorMessage(error));
+    };
+    // Some browsers surface a failed module instantiation via onmessageerror.
+    worker.onmessageerror = () => {
+        failWorker("Worker could not deserialize a message (onmessageerror). It likely failed to load. Check the browser console/network logs.");
+    };
+    // Initiate the parsing process
+    worker.postMessage({
+        requestType: RequestType.PARSE_EXCEL,
+        file,
+        minRowCount,
+        minColumnCount,
+    });
+    // Start watching as soon as parsing is kicked off.
+    armWatchdog();
+    // Create an observable that completes and cleans up when unsubscribed
+    const observable = new Observable((observer) => {
+        const subscription = subject.subscribe(observer);
+        // Clean up function that runs when unsubscribed
+        return () => {
+            clearWatchdog();
+            subscription.unsubscribe();
+            worker.terminate();
+        };
+    });
+    // Create a function to send messages to the worker
+    const sendMessage = (message) => {
+        worker.postMessage(message);
+    };
+    // Return both the observable and the send function
+    return {
+        observable,
+        sendMessage,
+    };
+};

package/dist/esm/excel-parser/builtin-numfmts.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Canonical Excel built-in number-format dictionary (numFmtId 0–49) per
+ * ECMA-376 §18.8.30. Single source of truth shared by both the importer
+ * (`excel-parser/plugins/xlsx`) and the exporter (`exporter/xlsx`) so a
+ * built-in numFmt survives round-trips through our data layer.
+ *
+ * IDs 23–36 are reserved / locale-specific and intentionally omitted —
+ * Excel substitutes them per locale on render; we don't materialize them.
+ *
+ * Currency patterns (5–8) and accounting patterns (41–44) use the quoted
+ * `"$"` literal form, which is what Excel's own writer emits in xlsx
+ * files. Pattern 47 is `mmss.0` (no colon) per ECMA-376 — Excel writes
+ * this without a colon despite some third-party tools using `mm:ss.0`.
+ */
+export type BuiltinNumFmtEntry = readonly [id: number, pattern: string];
+export declare const BUILTIN_NUMFMTS: readonly BuiltinNumFmtEntry[];
+/** Map: numFmtId → pattern. Used by the importer. */
+export declare const BUILTIN_NUMFMT_BY_ID: ReadonlyMap<number, string>;
+/**
+ * Map: pattern → numFmtId. Used by the exporter to emit a built-in
+ * reference instead of registering a custom numFmt.
+ */
+export declare const BUILTIN_NUMFMT_BY_PATTERN: ReadonlyMap<string, number>;
+//# sourceMappingURL=builtin-numfmts.d.ts.map

package/dist/esm/excel-parser/builtin-numfmts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-numfmts.d.ts","sourceRoot":"","sources":["../../../excel-parser/builtin-numfmts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAExE,eAAO,MAAM,eAAe,EAAE,SAAS,kBAAkB,EAqCxD,CAAC;AAEF,qDAAqD;AACrD,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAE5D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAEjE,CAAC"}

package/dist/esm/excel-parser/builtin-numfmts.js

@@ -0,0 +1,59 @@
+/**
+ * Canonical Excel built-in number-format dictionary (numFmtId 0–49) per
+ * ECMA-376 §18.8.30. Single source of truth shared by both the importer
+ * (`excel-parser/plugins/xlsx`) and the exporter (`exporter/xlsx`) so a
+ * built-in numFmt survives round-trips through our data layer.
+ *
+ * IDs 23–36 are reserved / locale-specific and intentionally omitted —
+ * Excel substitutes them per locale on render; we don't materialize them.
+ *
+ * Currency patterns (5–8) and accounting patterns (41–44) use the quoted
+ * `"$"` literal form, which is what Excel's own writer emits in xlsx
+ * files. Pattern 47 is `mmss.0` (no colon) per ECMA-376 — Excel writes
+ * this without a colon despite some third-party tools using `mm:ss.0`.
+ */
+export const BUILTIN_NUMFMTS = [
+    [0, "General"],
+    [1, "0"],
+    [2, "0.00"],
+    [3, "#,##0"],
+    [4, "#,##0.00"],
+    [5, '"$"#,##0_);("$"#,##0)'],
+    [6, '"$"#,##0_);[Red]("$"#,##0)'],
+    [7, '"$"#,##0.00_);("$"#,##0.00)'],
+    [8, '"$"#,##0.00_);[Red]("$"#,##0.00)'],
+    [9, "0%"],
+    [10, "0.00%"],
+    [11, "0.00E+00"],
+    [12, "# ?/?"],
+    [13, "# ??/??"],
+    [14, "m/d/yyyy"],
+    [15, "d-mmm-yy"],
+    [16, "d-mmm"],
+    [17, "mmm-yy"],
+    [18, "h:mm AM/PM"],
+    [19, "h:mm:ss AM/PM"],
+    [20, "h:mm"],
+    [21, "h:mm:ss"],
+    [22, "m/d/yyyy h:mm"],
+    [37, "#,##0_);(#,##0)"],
+    [38, "#,##0_);[Red](#,##0)"],
+    [39, "#,##0.00_);(#,##0.00)"],
+    [40, "#,##0.00_);[Red](#,##0.00)"],
+    [41, '_(* #,##0_);_(* (#,##0);_(* "-"_);_(@_)'],
+    [42, '_("$"* #,##0_);_("$"* (#,##0);_("$"* "-"_);_(@_)'],
+    [43, '_(* #,##0.00_);_(* (#,##0.00);_(* "-"??_);_(@_)'],
+    [44, '_("$"* #,##0.00_);_("$"* (#,##0.00);_("$"* "-"??_);_(@_)'],
+    [45, "mm:ss"],
+    [46, "[h]:mm:ss"],
+    [47, "mmss.0"],
+    [48, "##0.0E+0"],
+    [49, "@"],
+];
+/** Map: numFmtId → pattern. Used by the importer. */
+export const BUILTIN_NUMFMT_BY_ID = new Map(BUILTIN_NUMFMTS);
+/**
+ * Map: pattern → numFmtId. Used by the exporter to emit a built-in
+ * reference instead of registering a custom numFmt.
+ */
+export const BUILTIN_NUMFMT_BY_PATTERN = new Map(BUILTIN_NUMFMTS.map(([id, pattern]) => [pattern, id]));

package/dist/esm/excel-parser/cfb-decryptor.d.ts

@@ -0,0 +1,53 @@
+/**
+ * What a CFB (Compound File Binary) container actually holds. Both encrypted
+ * OOXML workbooks and legacy BIFF `.xls` workbooks share the same CFB magic
+ * bytes, so the outer signature alone cannot distinguish them.
+ */
+export type CfbContainerKind = "encrypted-ooxml" | "legacy-xls" | "unknown";
+export declare const LEGACY_XLS_UNSUPPORTED_MESSAGE = "This file is a legacy Excel 97-2003 (.xls) workbook, which is not supported. Please open it in Excel and save it as .xlsx, then try again.";
+/**
+ * Inspects a CFB container's directory to decide whether it is an
+ * Office-encrypted OOXML package (`EncryptionInfo` stream present) or an
+ * unencrypted legacy BIFF `.xls` workbook (`Workbook`/`Book` stream present
+ * without `EncryptionInfo`). Returns "unknown" for anything else, including
+ * containers that fail to parse — callers should fall back to their existing
+ * behavior in that case.
+ */
+export declare const detectCfbContainerKind: (source: File | ArrayBuffer) => Promise<CfbContainerKind>;
+export declare class CFBDecryptor {
+    /**
+     * Decrypts a CFB-encrypted XLSX file
+     * @param source The encrypted file or array buffer
+     * @param password The password to decrypt with
+     * @returns The decrypted XLSX data as ArrayBuffer
+     */
+    static decrypt(source: File | ArrayBuffer, password: string): Promise<ArrayBuffer>;
+    private static decryptAgile;
+    private static getEncryptionInfoContent;
+    private static decryptStandardFamily;
+    /** Standard key derivation (MS-OFFCRYPTO §2.3.4.7): iterated SHA1 then the X1‖X2 final block. */
+    private static standardKey;
+    private static decryptStandardPackage;
+    /** RC4 CryptoAPI key derivation (MS-OFFCRYPTO §2.3.5.2). */
+    private static rc4CryptoApiKey;
+    private static decryptRc4Package;
+    /** AES-ECB block decrypt (no padding). Trailing sub-block bytes are ignored. */
+    private static aesEcbDecrypt;
+    /** RC4 stream cipher (KSA + PRGA). Symmetric — the same op encrypts and decrypts. */
+    private static rc4;
+    private static le32;
+    private static bytesEqual;
+    private static parseEncryptionInfo;
+    private static parseAgileEncryptionXml;
+    private static deriveKey;
+    private static decryptEncryptedKey;
+    private static verifyPassword;
+    private static getEncryptedPackage;
+    private static decryptPackage;
+    private static decryptAESNoPadding;
+    private static deriveAgileBlockKey;
+    private static hash;
+    private static stringToUtf16LE;
+    private static concatArrays;
+}
+//# sourceMappingURL=cfb-decryptor.d.ts.map

package/dist/esm/excel-parser/cfb-decryptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cfb-decryptor.d.ts","sourceRoot":"","sources":["../../../excel-parser/cfb-decryptor.ts"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,GAAG,YAAY,GAAG,SAAS,CAAC;AAE5E,eAAO,MAAM,8BAA8B,+IACmG,CAAC;AAE/I;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GACjC,QAAQ,IAAI,GAAG,WAAW,KACzB,OAAO,CAAC,gBAAgB,CAiB1B,CAAC;AAEF,qBAAa,YAAY;IACvB;;;;;OAKG;WACU,OAAO,CAClB,MAAM,EAAE,IAAI,GAAG,WAAW,EAC1B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,WAAW,CAAC;IAiCvB,OAAO,CAAC,MAAM,CAAC,YAAY;IA6B3B,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAiBvC,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAsEpC,iGAAiG;IACjG,OAAO,CAAC,MAAM,CAAC,WAAW;IAyB1B,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAiBrC,4DAA4D;IAC5D,OAAO,CAAC,MAAM,CAAC,eAAe;IAmB9B,OAAO,CAAC,MAAM,CAAC,iBAAiB;IA4BhC,gFAAgF;IAChF,OAAO,CAAC,MAAM,CAAC,aAAa;IAM5B,qFAAqF;IACrF,OAAO,CAAC,MAAM,CAAC,GAAG;IAwBlB,OAAO,CAAC,MAAM,CAAC,IAAI;IAMnB,OAAO,CAAC,MAAM,CAAC,UAAU;IAQzB,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA4ClC,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAoGtC,OAAO,CAAC,MAAM,CAAC,SAAS;IAuBxB,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAoBlC,OAAO,CAAC,MAAM,CAAC,cAAc;IAuD7B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAclC,OAAO,CAAC,MAAM,CAAC,cAAc;IAwD7B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IASlC,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAWlC,OAAO,CAAC,MAAM,CAAC,IAAI;IAenB,OAAO,CAAC,MAAM,CAAC,eAAe;IAU9B,OAAO,CAAC,MAAM,CAAC,YAAY;CAW5B"}