@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/use-on-import-excel.js

@@ -0,0 +1,595 @@
+import { DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, loadWebFont, scheduleNormalPriorityCallback, useCallbackRef, useGetViewPort, useLoadingIndicator, } from "@rowsncolumns/spreadsheet";
+import { createExcelImportWorker, RequestType, ResponseType, } from "@rowsncolumns/toolkit";
+import { useModal } from "@rowsncolumns/ui";
+import { produce, produceWithPatches } from "immer";
+import { useCallback, useState } from "react";
+import { SheetCell } from "../sheet-cell";
+const TIMEOUT_FONT_LOAD = 5000;
+export const useOnImportExcelFile = ({ enableExcelImportHistory = false, onChangeSheetData, onChangeSheets, onChangeTables, onChangeEmbeds, onChangeNamedRanges, onChangeSharedStrings, onChangeConditionalFormats, onChangeDataValidations, onChangeCellXfs, onChangeCharts, onRequestFonts, onChangeTheme, onCreateDataValidationRule, onClearHistory, onChangeHistory, onChangeSlicers, onChangePivotTables, evaluateConditionalFormatting, evaluateDataValidations, clearRangeCache, onConfirm, onPrompt, }) => {
+    const [isImportingExcelfile, setIsImporting] = useState(false);
+    const [showLoader, hideLoader] = useLoadingIndicator();
+    const getViewPort = useGetViewPort();
+    const { confirm: defaultConfirm, prompt: defaultPrompt } = useModal();
+    // Use provided functions or fall back to defaults
+    const confirm = onConfirm ?? defaultConfirm;
+    const prompt = onPrompt ?? defaultPrompt;
+    // Create patches
+    const generateStatePatches = useCallbackRef(useCallback(async () => {
+        const spreadsheetPatch = {};
+        const promises = [];
+        // Update state
+        if (onChangeSheetData) {
+            promises.push(new Promise((resolve) => {
+                onChangeSheetData?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches({}, () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.sheetData = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeSheets
+        if (onChangeSheets) {
+            promises.push(new Promise((resolve) => {
+                onChangeSheets?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches([], () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.sheets = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeTables
+        if (onChangeTables) {
+            promises.push(new Promise((resolve) => {
+                onChangeTables?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches([], () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.tables = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeCharts
+        if (onChangeCharts) {
+            promises.push(new Promise((resolve) => {
+                onChangeCharts?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches([], () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.charts = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeEmbeds
+        if (onChangeEmbeds) {
+            promises.push(new Promise((resolve) => {
+                onChangeEmbeds?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches([], () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.embeds = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeNamedRanges
+        if (onChangeNamedRanges) {
+            promises.push(new Promise((resolve) => {
+                onChangeNamedRanges?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches([], () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.namedRanges = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeDataValidations
+        if (onChangeDataValidations) {
+            promises.push(new Promise((resolve) => {
+                onChangeDataValidations?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches([], () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.dataValidations = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeConditionalFormats
+        if (onChangeConditionalFormats) {
+            promises.push(new Promise((resolve) => {
+                onChangeConditionalFormats?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches([], () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.conditionalFormats = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeCellXfs
+        if (onChangeCellXfs) {
+            promises.push(new Promise((resolve) => {
+                onChangeCellXfs?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches([], () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.cellXfs = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeSharedStrings
+        if (onChangeSharedStrings) {
+            promises.push(new Promise((resolve) => {
+                onChangeSharedStrings?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches(new Map(), () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.sharedStrings = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // onChangeSlicers
+        if (onChangeSlicers) {
+            promises.push(new Promise((resolve) => {
+                onChangeSlicers?.((prev) => {
+                    const [_, patches, inversePatches] = produceWithPatches([], () => {
+                        return prev;
+                    });
+                    spreadsheetPatch.slicers = { patches, inversePatches };
+                    resolve();
+                    return prev;
+                });
+            }));
+        }
+        // Wait for all callbacks to complete
+        await Promise.all(promises);
+        return spreadsheetPatch;
+    }, [
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeCellXfs,
+        onChangeTables,
+        onChangeEmbeds,
+        onChangeNamedRanges,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onChangeCharts,
+        onChangeSharedStrings,
+        onChangeSlicers,
+    ]));
+    const getImportLabel = (file) => {
+        if (!(file instanceof File)) {
+            return "excel";
+        }
+        const type = file.type.toLowerCase();
+        const name = file.name?.toLowerCase() ?? "";
+        if (type.includes("spreadsheetml.sheet") || name.endsWith(".xlsx")) {
+            return "XLSX";
+        }
+        if (type.includes("sheet.binary.macroenabled.12") ||
+            name.endsWith(".xlsb")) {
+            return "XLSB";
+        }
+        if (type.includes("sheet.macroenabled.12") || name.endsWith(".xlsm")) {
+            return "XLSM";
+        }
+        if (type.includes("opendocument.spreadsheet") || name.endsWith(".ods")) {
+            return "ODS";
+        }
+        return "excel";
+    };
+    // Import excel file
+    const importExcelFile = useCallbackRef(useCallback(async (file, options) => {
+        const pageSize = 100;
+        const minRowCount = options?.minRowCount ?? DEFAULT_ROW_COUNT;
+        const minColumnCount = options?.minColumnCount ?? DEFAULT_COLUMN_COUNT;
+        const enableCellXfsRegistry = options?.enableCellXfsRegistry ?? true;
+        const enableSharedStrings = options?.enabledSharedStrings ?? !!onChangeSharedStrings;
+        const enableBackpressure = options?.enableBackpressure ?? true;
+        const providedPassword = options?.password;
+        // Use custom confirm/prompt if provided, otherwise use default from useModal
+        const confirmFn = options?.confirm ?? confirm;
+        const promptFn = options?.prompt ?? prompt;
+        let dataValidations = [];
+        let conditionalFormats = [];
+        if (enableExcelImportHistory) {
+            const confirmation = await confirmFn("This will delete all your current data. You won't be able to undo this or recover your previous work.", {
+                title: "Are you sure you want to replace your spreadsheet?",
+            });
+            if (!confirmation) {
+                return {
+                    success: false,
+                };
+            }
+        }
+        return new Promise((resolve) => {
+            const viewPort = getViewPort?.();
+            const defaultPageSize = viewPort
+                ? viewPort.visibleRowStopIndex - viewPort.visibleRowStartIndex
+                : pageSize;
+            const { observable, sendMessage } = createExcelImportWorker(file, minRowCount, minColumnCount);
+            let requiresRecalc = false;
+            let iterativeCalculationOptions;
+            let use1904 = false;
+            let isPromptingForPassword = false;
+            let isPasswordProtected = false;
+            // Set import
+            setIsImporting(true);
+            // Loader
+            const label = getImportLabel(file);
+            const isOdsImport = label === "ODS";
+            showLoader(`Parsing ${label} file`);
+            // Clear history
+            onClearHistory();
+            // Excel import streams entire sheets through `onChangeSheetData`
+            // directly, so the calculator's per-cell invalidation never runs
+            // for the imported positions. Wipe the range cache up front;
+            // it repopulates lazily as formulas re-evaluate.
+            clearRangeCache?.();
+            // // Load sheet
+            const subscription = observable.subscribe(async (response) => {
+                // Handle password required
+                if (response.responseType === ResponseType.PASSWORD_REQUIRED) {
+                    // If password was provided in options, use it directly
+                    if (providedPassword) {
+                        isPasswordProtected = true;
+                        showLoader("Decrypting file...");
+                        sendMessage({
+                            requestType: RequestType.PROVIDE_PASSWORD,
+                            password: providedPassword,
+                        });
+                        return;
+                    }
+                    // Prevent multiple password prompts
+                    if (isPromptingForPassword) {
+                        return;
+                    }
+                    isPromptingForPassword = true;
+                    hideLoader();
+                    // Use prompt dialog for password input
+                    const password = await promptFn(response.message ||
+                        "This file is password protected. Please enter the password:", {
+                        title: "Password Required",
+                        inputType: "password",
+                        placeholder: "Enter password",
+                        confirmText: "Open",
+                        cancelText: "Cancel",
+                    });
+                    isPromptingForPassword = false;
+                    if (password) {
+                        isPasswordProtected = true;
+                        showLoader("Decrypting file...");
+                        sendMessage({
+                            requestType: RequestType.PROVIDE_PASSWORD,
+                            password,
+                        });
+                    }
+                    else {
+                        // User cancelled
+                        subscription.unsubscribe();
+                        setIsImporting(false);
+                        resolve({ success: false });
+                    }
+                    return;
+                }
+                // Handle errors
+                if (response.responseType === ResponseType.ERROR) {
+                    hideLoader();
+                    setIsImporting(false);
+                    subscription.unsubscribe();
+                    await confirmFn(response.error || "Failed to import file. Please try again.", {
+                        title: "Import Error",
+                        confirmText: "OK",
+                        cancelText: "",
+                    });
+                    resolve({ success: false });
+                    return;
+                }
+                // always emitted first before ROW_DATA_CHUNK
+                if (response.responseType === ResponseType.GET_FONTS_SUCCESS) {
+                    const { fonts } = response;
+                    const fontFamiliesWithWeights = response.fonts
+                        .map((family) => [`${family}:400`, `${family}:700`])
+                        .flat();
+                    try {
+                        // Fonts loader
+                        showLoader(`Loading ${fonts.length} fonts...`);
+                        try {
+                            if (onRequestFonts) {
+                                await onRequestFonts(response.fonts);
+                            }
+                            else {
+                                await Promise.race([
+                                    loadWebFont(fontFamiliesWithWeights),
+                                    new Promise((_, reject) => setTimeout(() => reject(new Error("Font loading timed out")), TIMEOUT_FONT_LOAD)),
+                                ]);
+                            }
+                        }
+                        catch (err) {
+                            console.log("Error loading fonts");
+                        }
+                        showLoader("Loading sheet data...");
+                        // Request sheet data
+                        sendMessage({
+                            requestType: RequestType.GET_SHEET_DATA,
+                            pageSize: pageSize ?? defaultPageSize,
+                            enableCellXfsRegistry,
+                            enableSharedStrings,
+                            enableBackpressure,
+                        });
+                    }
+                    catch (err) {
+                        console.log("Error loading fonts", err, fonts);
+                    }
+                }
+                if (response.responseType === ResponseType.PARSE_EXCEL_SUCCESS) {
+                    requiresRecalc = response.requiresRecalc ?? false;
+                    iterativeCalculationOptions =
+                        response.iterativeCalculationOptions ?? undefined;
+                    use1904 = response.use1904 ?? false;
+                }
+                if (response.responseType === ResponseType.GET_SHEETS_SUCCESS) {
+                    onChangeSheets(response.sheets);
+                }
+                if (response.responseType === ResponseType.BEGIN_GET_SHEETS) {
+                    showLoader(`Loading ${response.totalSheets} sheets...`);
+                }
+                if (response.responseType === ResponseType.GET_THEME_SUCCESS) {
+                    if (response.theme) {
+                        onChangeTheme?.(response.theme);
+                    }
+                }
+                if (response.responseType === ResponseType.GET_CONDITIONAL_FORMATTING) {
+                    showLoader("Loading conditional formatting");
+                }
+                if (response.responseType === ResponseType.GET_DATAVALIDATION) {
+                    showLoader("Loading data validations");
+                }
+                // Process row data chunk
+                if (response.responseType === ResponseType.ROW_DATA_CHUNK) {
+                    const { sheetId, chunkIndex, rowIndices, rows, cellXfs, title, totalSheets, currentSheetIndex, totalRows, sharedStringsChunk, sharedStringsStartIndex, } = response;
+                    // Loading - show progress with current row out of total
+                    const currentRow = rowIndices[rowIndices.length - 1] ?? 0;
+                    const totalRowCount = totalRows >= 0 ? totalRows + 1 : undefined;
+                    const displayRow = totalRowCount
+                        ? Math.min(currentRow + 1, totalRowCount)
+                        : currentRow + 1;
+                    const totalRowsLabel = totalRowCount ? `/${totalRowCount}` : "";
+                    showLoader(`Processing "${title}" (${currentSheetIndex + 1}/${totalSheets}): Row ${displayRow}${totalRowsLabel}`);
+                    // Update cell formats
+                    onChangeCellXfs?.(cellXfs);
+                    // Update shared strings too
+                    if (enableSharedStrings &&
+                        isOdsImport &&
+                        sharedStringsChunk?.length) {
+                        onChangeSharedStrings?.((prev) => {
+                            const base = prev ?? new Map();
+                            return produce(base, (draft) => {
+                                const isTuple = Array.isArray(sharedStringsChunk[0]);
+                                if (isTuple) {
+                                    // New worker shape: cells already reference these ids.
+                                    for (const entry of sharedStringsChunk) {
+                                        const [id, value] = entry;
+                                        if (draft.get(id) !== value) {
+                                            draft.set(id, value);
+                                        }
+                                    }
+                                }
+                                else {
+                                    // Legacy worker shape: numeric ids assigned by position.
+                                    const startIndex = sharedStringsStartIndex ?? draft.size;
+                                    for (let i = 0; i < sharedStringsChunk.length; i++) {
+                                        draft.set(String(startIndex + i), sharedStringsChunk[i]);
+                                    }
+                                }
+                            });
+                        });
+                    }
+                    // Update sheets
+                    onChangeSheetData?.((prev) => {
+                        if (chunkIndex === 0 && currentSheetIndex === 0) {
+                            prev = {};
+                        }
+                        if (chunkIndex === 0) {
+                            prev[sheetId] = [];
+                        }
+                        for (let i = 0; i < rowIndices.length; i++) {
+                            prev[sheetId][rowIndices[i]] = rows[i];
+                        }
+                        return prev;
+                    });
+                    if (enableBackpressure) {
+                        sendMessage({
+                            requestType: RequestType.ACK_ROW_DATA,
+                            sheetId,
+                            chunkIndex,
+                        });
+                    }
+                }
+                if (response.responseType === ResponseType.CELL_XFS) {
+                    onChangeCellXfs?.(response.cellXfs);
+                }
+                if (response.responseType === ResponseType.GET_TABLES_SUCCESS) {
+                    onChangeTables?.(response.tables);
+                }
+                if (response.responseType === ResponseType.GET_NAMEDRANGES_SUCCESS) {
+                    onChangeNamedRanges?.(response.namedRanges);
+                }
+                if (enableSharedStrings &&
+                    response.responseType === ResponseType.GET_SHARED_STRINGS_SUCCESS) {
+                    // Accept both [id, value][] (new worker) and string[] (legacy).
+                    const newMap = new Map();
+                    const entries = response.sharedStrings;
+                    if (entries.length && Array.isArray(entries[0])) {
+                        for (const [id, value] of entries) {
+                            newMap.set(id, value);
+                        }
+                    }
+                    else {
+                        entries.forEach((value, index) => {
+                            newMap.set(String(index), value);
+                        });
+                    }
+                    onChangeSharedStrings?.(newMap);
+                }
+                if (response.responseType ===
+                    ResponseType.GET_CONDITIONAL_FORMATTING_SUCCESS) {
+                    onChangeConditionalFormats?.(response.conditionalFormatting);
+                    // Schedule conditional format evaluation
+                    conditionalFormats = response.conditionalFormatting;
+                }
+                if (response.responseType === ResponseType.GET_DATAVALIDATION_SUCCESS) {
+                    // Stamp cells with `dv` references but skip the per-cell
+                    // `enqueueCalculation`. Imported workbooks can attach DV rules
+                    // to thousands of cells across inactive sheets — letting
+                    // `updateRule` enqueue each one would pin the calculator with
+                    // off-viewport work before the user has interacted. The
+                    // viewport-aware `evaluateDataValidations` call scheduled in
+                    // PARSE_EXCEL_COMPLETE handles formula evaluation for the
+                    // active sheet's visible range instead.
+                    for (const rule of response.dataValidations) {
+                        onCreateDataValidationRule(rule, {
+                            skipEnqueue: true,
+                            importSource: true,
+                        });
+                    }
+                    dataValidations = response.dataValidations;
+                }
+                if (response.responseType === ResponseType.GET_CHARTS_SUCCESS) {
+                    onChangeCharts?.(response.charts);
+                }
+                if (response.responseType === ResponseType.GET_SLICERS_SUCCESS) {
+                    onChangeSlicers?.(response.slicers);
+                }
+                if (response.responseType === ResponseType.GET_PIVOT_TABLES_SUCCESS) {
+                    // Replace the whole pivot list — Excel files always
+                    // declare their pivots upfront, so any pre-existing
+                    // host-side pivot state from a previous file is stale.
+                    onChangePivotTables?.(() => response.pivotTables);
+                }
+                if (response.responseType === ResponseType.GET_DRAWINGS_SUCCESS) {
+                    const embeds = [];
+                    const images = [];
+                    for (const { isInsideCell, ...drawing } of response.drawings) {
+                        if (isInsideCell) {
+                            images.push(drawing);
+                        }
+                        else {
+                            embeds.push(drawing);
+                        }
+                    }
+                    // Embeds
+                    onChangeEmbeds?.(embeds);
+                    // Sheet images
+                    if (images.length) {
+                        onChangeSheetData?.((prev) => {
+                            for (const image of images) {
+                                const { sheetId, overlayPosition } = image.position;
+                                const { rowIndex, columnIndex } = overlayPosition.anchorCell;
+                                if (!prev[sheetId]) {
+                                    prev[sheetId] = [];
+                                }
+                                const imageUrl = image.spec.imageUrl;
+                                const sheetCell = new SheetCell(sheetId, { rowIndex, columnIndex }, prev[sheetId]?.[rowIndex]?.values[columnIndex]);
+                                sheetCell.setImage(imageUrl);
+                                if (!prev[sheetId][rowIndex]) {
+                                    prev[sheetId][rowIndex] = { values: [] };
+                                }
+                                if (!prev[sheetId][rowIndex].values[columnIndex]) {
+                                    prev[sheetId][rowIndex].values[columnIndex] = {};
+                                }
+                                prev[sheetId][rowIndex].values[columnIndex] =
+                                    sheetCell.getCellData();
+                            }
+                            return prev;
+                        });
+                    }
+                }
+                // Terminate worker
+                if (response.responseType === ResponseType.PARSE_EXCEL_COMPLETE) {
+                    hideLoader();
+                    setIsImporting(false);
+                    subscription.unsubscribe();
+                    if (enableExcelImportHistory) {
+                        // Trigger history change
+                        const patches = await generateStatePatches();
+                        // Pass it on
+                        onChangeHistory?.([[patches]]);
+                    }
+                    // Schedule conditional format + data validation evaluation.
+                    // DV rules were created with `skipEnqueue: true` above, so this
+                    // is the only viewport-aware enqueue point post-import; without
+                    // it the active sheet's formula-backed DV cells would not
+                    // evaluate until the user scrolled or switched sheets (see
+                    // `use-calculation-initialize`'s mount effect, which fires once
+                    // before import resolves with empty initialDataValidations).
+                    scheduleNormalPriorityCallback(() => {
+                        const viewPort = getViewPort?.();
+                        if (conditionalFormats.length) {
+                            evaluateConditionalFormatting?.(conditionalFormats, viewPort);
+                        }
+                        if (dataValidations.length) {
+                            evaluateDataValidations?.(dataValidations, viewPort);
+                        }
+                    });
+                    // Resolve the promise here when parsing is complete
+                    resolve({
+                        requiresRecalc,
+                        iterativeCalculationOptions,
+                        use1904,
+                        success: true,
+                        isPasswordProtected,
+                    });
+                }
+            });
+        });
+    }, [
+        enableExcelImportHistory,
+        evaluateConditionalFormatting,
+        evaluateDataValidations,
+        showLoader,
+        hideLoader,
+        onChangeSheets,
+        onChangeSheetData,
+        onChangeCellXfs,
+        onChangeTables,
+        onChangeEmbeds,
+        onChangeNamedRanges,
+        onChangeConditionalFormats,
+        onChangeCharts,
+        getViewPort,
+        onRequestFonts,
+        onChangeTheme,
+        onCreateDataValidationRule,
+        onChangeHistory,
+        generateStatePatches,
+        onClearHistory,
+        onChangeSharedStrings,
+        confirm,
+        prompt,
+    ]));
+    return {
+        importExcelFile,
+        isImportingExcelfile,
+        generateStatePatches,
+    };
+};

package/dist/esm/hooks/use-on-insert-autosum.d.ts

@@ -0,0 +1,9 @@
+import type { useSheetProperties } from "./use-sheet-properties";
+type useOnInsertAutoSumProps = {
+    getEffectiveValue: ReturnType<typeof useSheetProperties>["getEffectiveValue"];
+    getEffectiveFormat: ReturnType<typeof useSheetProperties>["getEffectiveFormat"];
+    isHiddenRow: ReturnType<typeof useSheetProperties>["isHiddenRow"];
+};
+export declare const useOnInsertAutoSum: ({ getEffectiveValue, getEffectiveFormat, isHiddenRow, }: useOnInsertAutoSumProps) => (sheetId: number, activeCell: import("@rowsncolumns/grid").CellInterface, functionName?: "SUM" | "AVERAGE" | "COUNT" | "MAX" | "MIN") => void;
+export {};
+//# sourceMappingURL=use-on-insert-autosum.d.ts.map

package/dist/esm/hooks/use-on-insert-autosum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-insert-autosum.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-insert-autosum.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,KAAK,uBAAuB,GAAG;IAC7B,iBAAiB,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC9E,kBAAkB,EAAE,UAAU,CAC5B,OAAO,kBAAkB,CAC1B,CAAC,oBAAoB,CAAC,CAAC;IACxB,WAAW,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,aAAa,CAAC,CAAC;CACnE,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,yDAIhC,uBAAuB,kJAwIzB,CAAC"}