@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/use-on-move-selection.js

@@ -0,0 +1,383 @@
+import { areaInsideArea } from "@rowsncolumns/grid";
+import { getSelectedTableColumnFromSelection, isSelectionACell, } from "@rowsncolumns/spreadsheet";
+import { isNil, iterateCellsInRange, rescopeSheetRangesOnMove, } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { processSideEffectDependentCells } from "../api/dependency";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { shiftPivotsOnMove } from "../api/pivot-range";
+import { SheetCell } from "../sheet-cell";
+import { moveRange } from "./../api/selection";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+import { useOnMoveTableColumns } from "./use-on-move-table-columns";
+export const useOnMoveSelection = ({ rowCount, columnCount, tables, locale, cellXfsRegistry, sharedStringRegistry, getDependents, getActiveCell, onChangeTables, onChangeSheets, onChangeNamedRanges, onChangeDataValidations, onChangeConditionalFormats, onChangePivotTables, onChangeSheetData, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, isArrayFormula, getDataValidationById, onCommand, }) => {
+    const canEditCellRange = useCanEditCellRange();
+    const onMoveTableColumns = useOnMoveTableColumns({
+        rowCount,
+        columnCount,
+        locale,
+        getDependents,
+        onChangeTables,
+        onChangeSheetData,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        createHistory,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+    });
+    return useCallback((sheetId, from, to) => {
+        if (!canEditCellRange(sheetId, to.range)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        // Check if we are moving columns
+        // within table
+        const [sourceTable, sourceColumns] = getSelectedTableColumnFromSelection(from, tables);
+        const [destinationTable] = getSelectedTableColumnFromSelection(to, tables);
+        if (sourceTable &&
+            destinationTable &&
+            sourceColumns &&
+            sourceTable.id === destinationTable.id) {
+            const colStartIndex = sourceTable.range.startColumnIndex +
+                sourceTable.columns.indexOf(sourceColumns[0]);
+            const len = sourceColumns.length;
+            const movedColumns = len === 1
+                ? [colStartIndex]
+                : Array.from({ length: len }).map((_, index) => colStartIndex + index);
+            // Stream the intent: the engine reorders the column cells over the table's full row band
+            // (which a windowed UI can't read) + the table headers.
+            onCommand?.({
+                command: "move-table-columns",
+                sheetId,
+                tableId: sourceTable.id,
+                columns: movedColumns,
+                referenceColumnIndex: to.range.startColumnIndex,
+            });
+            return onMoveTableColumns(sheetId, sourceTable, movedColumns, to.range.startColumnIndex);
+        }
+        enqueueStructureChange?.({
+            kind: "invalidate-range",
+            sheetId,
+            startRowIndex: Math.max(1, Math.min(from.range.startRowIndex, to.range.startRowIndex)),
+            endRowIndex: Math.min(rowCount, Math.max(from.range.endRowIndex, to.range.endRowIndex)),
+            startColumnIndex: Math.max(1, Math.min(from.range.startColumnIndex, to.range.startColumnIndex)),
+            endColumnIndex: Math.min(columnCount, Math.max(from.range.endColumnIndex, to.range.endColumnIndex)),
+        });
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        const saveHistory = createHistory();
+        const rowDelta = to.range.startRowIndex - from.range.startRowIndex;
+        const columnDelta = to.range.startColumnIndex - from.range.startColumnIndex;
+        // Verify if we are moving a table
+        const table = tables?.find((table) => table.sheetId === sheetId && areaInsideArea(table.range, from.range));
+        // Sheet cell
+        const sheetCell = new SheetCell();
+        // Move named ranges if necessary
+        onChangeNamedRanges?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const namedRange of draft) {
+                    if (namedRange.range?.sheetId === sheetId &&
+                        areaInsideArea(namedRange.range, from.range)) {
+                        // Update range
+                        namedRange.range = moveRange(namedRange.range, from.range, to.range);
+                    }
+                }
+            });
+            saveHistory({
+                namedRanges: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Move tables if necessary
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    if (table.sheetId === sheetId &&
+                        areaInsideArea(table.range, from.range)) {
+                        // Update range
+                        table.range = moveRange(table.range, from.range, to.range);
+                        // Update filter and sort specs
+                        if (table.filterSpecs) {
+                            for (const spec of table.filterSpecs) {
+                                spec.columnIndex =
+                                    to.range.startColumnIndex +
+                                        (spec.columnIndex - from.range.startColumnIndex);
+                            }
+                        }
+                    }
+                }
+            });
+            saveHistory({
+                tables: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Move data validations. Rules are range-scoped, so the scopes must
+        // travel with the moved cells (Excel/Sheets carry a rule to the
+        // destination of a move): a rule range that travelled entirely shifts,
+        // a partially-overlapped range keeps its scope and gains the shifted
+        // overlap. Untouched rules produce no patches and no history entry.
+        onChangeDataValidations?.((prevValidations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
+                for (const rule of draft) {
+                    const nextRanges = rescopeSheetRangesOnMove(rule.ranges ?? [], sheetId, from.range, to.range);
+                    if (nextRanges) {
+                        rule.ranges = nextRanges;
+                    }
+                }
+            });
+            if (!patches.length) {
+                return prevValidations;
+            }
+            saveHistory({
+                dataValidations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Move pivot tables whose source / pivotRange / targetPosition sits
+        // inside the moved area.
+        onChangePivotTables?.((prevPivots) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevPivots, (draft) => {
+                shiftPivotsOnMove(draft, sheetId, from.range, to.range);
+            });
+            saveHistory({
+                pivotTables: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Move conditional formats — same re-scoping contract as data
+        // validations above.
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                for (const rule of draft) {
+                    const nextRanges = rescopeSheetRangesOnMove(rule.ranges ?? [], sheetId, from.range, to.range);
+                    if (nextRanges) {
+                        rule.ranges = nextRanges;
+                    }
+                }
+            });
+            if (!patches.length) {
+                return prevConditionalFormats;
+            }
+            saveHistory({
+                conditionalFormats: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update hidden rows if any
+        // Move banded ranges
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    const hiddenRows = new Set();
+                    const activeBasicFilter = sheet.basicFilter &&
+                        areaInsideArea(sheet.basicFilter.range, from.range)
+                        ? sheet.basicFilter
+                        : undefined;
+                    const activeTable = table ?? activeBasicFilter;
+                    if (!isNil(activeTable)) {
+                        const { range } = activeTable;
+                        if (!sheet.rowMetadata) {
+                            sheet.rowMetadata = [];
+                        }
+                        for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                            const isHidden = sheet.rowMetadata?.[rowIndex]?.hiddenByFilter;
+                            if (isHidden) {
+                                sheet.rowMetadata[rowIndex].hiddenByFilter = false;
+                                hiddenRows.add(rowIndex);
+                            }
+                        }
+                        // Requires  2 loops
+                        for (const rowIndex of hiddenRows) {
+                            const newRowIndex = to.range.startRowIndex +
+                                (rowIndex - from.range.startRowIndex);
+                            if (!sheet.rowMetadata?.[newRowIndex]) {
+                                sheet.rowMetadata[newRowIndex] = {};
+                            }
+                            sheet.rowMetadata[newRowIndex].hiddenByFilter = true;
+                        }
+                    }
+                    // Move basic filter
+                    if (sheet.basicFilter && activeBasicFilter) {
+                        // Update range
+                        sheet.basicFilter.range = moveRange(sheet.basicFilter.range, from.range, to.range);
+                        // Update filter and sort specs
+                        if (sheet.basicFilter.filterSpecs) {
+                            for (const spec of sheet.basicFilter.filterSpecs) {
+                                spec.columnIndex =
+                                    to.range.startColumnIndex +
+                                        (spec.columnIndex - from.range.startColumnIndex);
+                            }
+                        }
+                    }
+                    // Move merges
+                    if (sheet.merges) {
+                        for (let i = 0; i < sheet.merges.length; i++) {
+                            const merge = sheet.merges[i];
+                            // Merge is inside this area
+                            if (areaInsideArea(merge, from.range)) {
+                                sheet.merges[i] = {
+                                    startRowIndex: (merge.startRowIndex += rowDelta),
+                                    endRowIndex: (merge.endRowIndex += rowDelta),
+                                    startColumnIndex: (merge.startColumnIndex += columnDelta),
+                                    endColumnIndex: (merge.endColumnIndex += columnDelta),
+                                };
+                            }
+                        }
+                    }
+                }
+            });
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const movedKeys = new Set();
+                // Update formulas
+                for (const [rowIndex, columnIndex] of iterateCellsInRange(from.range)) {
+                    // Process dependents
+                    processSideEffectDependentCells({
+                        draft,
+                        rowIndex,
+                        columnIndex,
+                        sheetId,
+                        columnDelta,
+                        enqueueGraphOperation,
+                        enqueueCalculation,
+                        getDependents,
+                        recalcCells,
+                        rowDelta,
+                        sourceRange: from.range,
+                        movedKeys,
+                        locale,
+                        rowCount,
+                        columnCount,
+                    });
+                }
+                // Move values
+                const selectedRowValues = [];
+                for (let rowIndex = from.range.startRowIndex; rowIndex <= from.range.endRowIndex; rowIndex++) {
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    const start = from.range.startColumnIndex;
+                    const end = start +
+                        from.range.endColumnIndex -
+                        from.range.startColumnIndex +
+                        1;
+                    selectedRowValues.push(currentSheet[rowIndex].values.slice(start, end));
+                    for (let columnIndex = from.range.startColumnIndex; columnIndex <= from.range.endColumnIndex; columnIndex++) {
+                        // Add sheet cell
+                        sheetCell.assign(sheetId, { rowIndex, columnIndex }, currentSheet[rowIndex].values[columnIndex], {
+                            locale,
+                            cellXfsRegistry,
+                            sharedStringRegistry,
+                            getDataValidationById,
+                        });
+                        // Clear cell, preserves dataValidationResult
+                        sheetCell.deleteContents();
+                        sheetCell.deleteUserEnteredFormat();
+                        // Assign
+                        currentSheet[rowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                        // Register cell
+                        cellXfsRegistry?.registerCellXfs(sheetCell);
+                    }
+                }
+                let rowIdx = 0;
+                for (let rowIndex = to.range.startRowIndex; rowIndex <= to.range.endRowIndex; rowIndex++) {
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    let idx = 0;
+                    for (let columnIndex = to.range.startColumnIndex; columnIndex <= to.range.endColumnIndex; columnIndex++) {
+                        currentSheet[rowIndex].values[columnIndex] =
+                            selectedRowValues[rowIdx][idx];
+                        // Mark all to range cells as dirty
+                        // Only looks for formula cells
+                        if (getDependents({ sheetId, rowIndex, columnIndex }).length ||
+                            // Check if source formula was an array array
+                            isArrayFormula({
+                                sheetId,
+                                rowIndex: rowIndex - rowDelta,
+                                columnIndex: columnIndex - columnDelta,
+                            })) {
+                            enqueueCalculation({
+                                type: "add",
+                                position: {
+                                    sheetId,
+                                    rowIndex,
+                                    columnIndex,
+                                },
+                            });
+                            // Add to recalc cells
+                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                sheetId,
+                                rowIndex,
+                                columnIndex,
+                            });
+                        }
+                        idx++;
+                    }
+                    rowIdx++;
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: {
+                    undo: getActiveCell(),
+                    redo: {
+                        rowIndex: to.range.startRowIndex,
+                        columnIndex: to.range.startColumnIndex,
+                    },
+                },
+                selections: {
+                    undo: isSelectionACell([from]) ? undefined : [from],
+                    redo: isSelectionACell([to]) ? undefined : [to],
+                },
+            });
+            return nextState;
+        });
+        // History
+        cellXfsRegistry?.getPatches(saveHistory);
+        // Stream the move to an engine consumer. The UI is windowed and doesn't hold the source
+        // cells, so it can't compute the move — it sends the intent and the engine relocates the
+        // range (clearing the source) and recomputes dependents. Object/merge range-shifts handled
+        // above ride their own channels; the cell move is the data-bearing intent the engine owns.
+        onCommand?.({
+            command: "move-range",
+            sheetId,
+            from: from.range,
+            to: to.range,
+        });
+    }, [
+        rowCount,
+        columnCount,
+        tables,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        onMoveTableColumns,
+        getDependents,
+        onChangeTables,
+        onChangeSheets,
+        onChangeNamedRanges,
+        onChangeDataValidations,
+        onChangeConditionalFormats,
+        onChangePivotTables,
+        onChangeSheetData,
+        getActiveCell,
+        createHistory,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        enqueueStructureChange,
+        canEditCellRange,
+        isArrayFormula,
+        getDataValidationById,
+        onCommand,
+    ]);
+};

package/dist/esm/hooks/use-on-move-sheet.d.ts

@@ -0,0 +1,12 @@
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnMoveSheetProps<T extends CellData, S extends Sheet> = {
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnMoveSheet: <T extends CellData, S extends Sheet>({ onChangeSheets, createHistory, onCommand, }: UseOnMoveSheetProps<T, S>) => (sheetId: number, currentPosition: number, newPosition: number) => void;
+export {};
+//# sourceMappingURL=use-on-move-sheet.d.ts.map

package/dist/esm/hooks/use-on-move-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-move-sheet.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-move-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,mBAAmB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC9D,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAIjE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,eAId,MAAM,mBAAmB,MAAM,eAAe,MAAM,SAwEjE,CAAC"}

package/dist/esm/hooks/use-on-move-sheet.js

@@ -0,0 +1,65 @@
+import { sortSheetsByIndex } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { useCanEditSheet, useCanEditWorkbook } from "./use-can-edit-cellrange";
+export const useOnMoveSheet = ({ onChangeSheets, createHistory, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    const canEditWorkbook = useCanEditWorkbook();
+    return useCallback((sheetId, currentPosition, newPosition) => {
+        // Exit early
+        if (currentPosition === -1 || currentPosition === newPosition) {
+            return;
+        }
+        if (!canEditWorkbook()) {
+            console.debug("Workbook is structurally protected, cannot move a sheet.");
+            return;
+        }
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        const saveHistory = createHistory();
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sortedSheets = sortSheetsByIndex(draft);
+                const sheetToMove = sortedSheets[currentPosition];
+                const oldIndex = sheetToMove.index;
+                const newIndex = sortedSheets[newPosition].index;
+                // Determine the direction of movement
+                const isMovingDown = newPosition > currentPosition;
+                // Update indices of affected sheets
+                draft.forEach((sheet, arrayIndex) => {
+                    const currentIndex = sheet.index ?? arrayIndex;
+                    if (sheet.sheetId === sheetId) {
+                        sheet.index = newIndex;
+                    }
+                    else if (!isMovingDown &&
+                        currentIndex < oldIndex &&
+                        currentIndex >= newIndex) {
+                        sheet.index = currentIndex + 1;
+                    }
+                    else if (isMovingDown &&
+                        currentIndex > oldIndex &&
+                        currentIndex <= newIndex) {
+                        sheet.index = currentIndex - 1;
+                    }
+                    else if (sheet.index === undefined) {
+                        // Set index for sheets that didn't have one before
+                        sheet.index = arrayIndex;
+                    }
+                });
+            });
+            // Save history
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        onCommand?.({
+            command: "move-sheet",
+            sheetId,
+            currentPosition,
+            newPosition,
+        });
+    }, [onChangeSheets, createHistory, canEditSheet, canEditWorkbook, onCommand]);
+};

package/dist/esm/hooks/use-on-move-table-columns.d.ts

@@ -0,0 +1,21 @@
+import type { CellData, TableView } from "@rowsncolumns/spreadsheet";
+import type { useCalculation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnMoveTableColumns<T extends CellData> = {
+    rowCount: number;
+    columnCount: number;
+    locale?: string;
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueStructureChange?: ReturnType<typeof useCalculation>["enqueueStructureChange"];
+    enqueueGraphOperation: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    onChangeTables: UseSpreadsheetProps<T>["onChangeTables"];
+    onChangeConditionalFormats?: UseSpreadsheetProps<T>["onChangeConditionalFormats"];
+    onChangeDataValidations?: UseSpreadsheetProps<T>["onChangeDataValidations"];
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+};
+export declare const useOnMoveTableColumns: <T extends CellData>({ rowCount, columnCount, locale, createHistory, onChangeSheetData, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, getDependents, }: UseOnMoveTableColumns<T>) => (sheetId: number, table: TableView, columns: number[], referenceColumnIndex: number) => void;
+export {};
+//# sourceMappingURL=use-on-move-table-columns.d.ts.map

package/dist/esm/hooks/use-on-move-table-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-move-table-columns.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-move-table-columns.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,QAAQ,EAGR,SAAS,EACV,MAAM,2BAA2B,CAAC;AAUnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,qBAAqB,CAAC,CAAC,SAAS,QAAQ,IAAI;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,sBAAsB,CAAC,EAAE,UAAU,CACjC,OAAO,cAAc,CACtB,CAAC,wBAAwB,CAAC,CAAC;IAC5B,qBAAqB,EAAE,UAAU,CAC/B,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,cAAc,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IACzD,0BAA0B,CAAC,EAAE,mBAAmB,CAC9C,CAAC,CACF,CAAC,4BAA4B,CAAC,CAAC;IAChC,uBAAuB,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC;IAC5E,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;CACnE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,6NAavD,qBAAqB,CAAC,CAAC,CAAC,eAGZ,MAAM,SACR,SAAS,WACP,MAAM,EAAE,wBACK,MAAM,SA6RjC,CAAC"}