@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-calculation-process-array.d.ts

@@ -0,0 +1,20 @@
+import type { Calculator } from "@rowsncolumns/calculator";
+import type { CellCoordinate, CellNode, StaticNode } from "@rowsncolumns/dag";
+import type { FormulaResultArray } from "@rowsncolumns/fast-formula-parser";
+import type { CellData, CellFormat, ErrorValue } from "@rowsncolumns/spreadsheet";
+import type { CalculationOperation, CalculationResult, UseCalculationProps } from "./use-calculation";
+type ProcessArrayProps = {
+    locale?: string;
+    getCalculator(): Calculator;
+    getUserEnteredValue: UseCalculationProps["getUserEnteredValue"];
+    getCellData: UseCalculationProps["getCellData"];
+    getSheetId: UseCalculationProps["getSheetId"];
+    getComputationCache(): Map<string, CalculationResult | ErrorValue>;
+};
+export declare const useCalculationProcessArray: <T extends CellData>({ locale, getCalculator, getUserEnteredValue, getCellData, getSheetId, getComputationCache, }: ProcessArrayProps) => readonly [(result: FormulaResultArray, position: CellCoordinate, results: Map<string, [CellCoordinate, CalculationResult, formatting?: CellFormat]>, getDependents: (position: CellCoordinate) => (CellNode | StaticNode)[]) => readonly [boolean, CalculationOperation[]], ({ position, shouldRemoveArrayReference, getDependents, }: {
+    position: CellCoordinate;
+    shouldRemoveArrayReference?: boolean;
+    getDependents: (position: CellCoordinate) => (CellNode | StaticNode)[];
+}) => Map<string, [CellCoordinate, CalculationResult, formatting?: CellFormat | undefined]>, (position: CellCoordinate) => readonly [Map<string, [CellCoordinate, CalculationResult, formatting?: CellFormat | undefined]>, CalculationOperation[]]];
+export {};
+//# sourceMappingURL=use-calculation-process-array.d.ts.map

package/dist/cjs/hooks/use-calculation-process-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-calculation-process-array.d.ts","sourceRoot":"","sources":["../../../hooks/use-calculation-process-array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,KAAK,EAEV,kBAAkB,EACnB,MAAM,mCAAmC,CAAC;AAE3C,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EACV,UAAU,EACX,MAAM,2BAA2B,CAAC;AAcnC,OAAO,KAAK,EACV,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAE3B,KAAK,iBAAiB,GAAG;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,IAAI,UAAU,CAAC;IAC5B,mBAAmB,EAAE,mBAAmB,CAAC,qBAAqB,CAAC,CAAC;IAChE,WAAW,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;IAChD,UAAU,EAAE,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAC9C,mBAAmB,IAAI,GAAG,CAAC,MAAM,EAAE,iBAAiB,GAAG,UAAU,CAAC,CAAC;CACpE,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,QAAQ,EAAE,+FAO5D,iBAAiB,wBA+CN,kBAAkB,YAChB,cAAc,WACf,GAAG,CACV,MAAM,EACN,CAAC,cAAc,EAAE,iBAAiB,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,CAC7D,iBACc,CAAC,QAAQ,EAAE,cAAc,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,4GAgMrE;IACD,QAAQ,EAAE,cAAc,CAAC;IACzB,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,aAAa,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAAC;CACxE,uGA2GU,cAAc,8HA+C5B,CAAC"}

package/dist/cjs/hooks/use-calculation-process-array.js

@@ -0,0 +1,331 @@
+import { __read, __values } from "tslib";
+import { tokenize as formulaTokenizer } from "@rowsncolumns/calculator";
+import { isEqualCells } from "@rowsncolumns/grid";
+import { useCallback } from "react";
+import { parseFilterSourceRange } from "../api/filter-range";
+import { collisionDetection, generateCollisionError, isCellWithinCellRange, isEqualCellRange, isEqualPosition, iterateCellsInCellRange, iterateCellsInCellRangeWithResults, } from "../api/range";
+import { SheetCell } from "../sheet-cell";
+export var useCalculationProcessArray = function (_a) {
+    var locale = _a.locale, getCalculator = _a.getCalculator, getUserEnteredValue = _a.getUserEnteredValue, getCellData = _a.getCellData, getSheetId = _a.getSheetId, getComputationCache = _a.getComputationCache;
+    var isCellBlocked = useCallback(function (cell, anchor) {
+        var userValue = getUserEnteredValue(cell.sheetId, cell.rowIndex, cell.columnIndex);
+        if (userValue !== undefined) {
+            return true;
+        }
+        var parent = getCalculator().getClosestArrayParentCell(cell);
+        if (parent && isEqualPosition(parent, anchor)) {
+            return false;
+        }
+        return Boolean(parent);
+    }, [getCalculator, getUserEnteredValue]);
+    var detectArrayCollision = useCallback(function (anchor, range) {
+        var e_1, _a;
+        if (!range) {
+            return [false, undefined];
+        }
+        try {
+            for (var _b = __values(iterateCellsInCellRange(range)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                if (rowIndex === anchor.rowIndex &&
+                    columnIndex === anchor.columnIndex) {
+                    continue;
+                }
+                var cell = {
+                    sheetId: anchor.sheetId,
+                    rowIndex: rowIndex,
+                    columnIndex: columnIndex,
+                };
+                if (isCellBlocked(cell, anchor)) {
+                    return [true, cell];
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return [false, undefined];
+    }, [isCellBlocked]);
+    var processArrayResults = useCallback(function (result, position, results, getDependents) {
+        var e_2, _a;
+        var arrayReference = getCalculator().getArrayRange(position);
+        var _b = __read(detectArrayCollision(position, arrayReference), 2), collides = _b[0], collidingCell = _b[1];
+        var collidingCellRange = collidingCell && getCalculator().getArrayRangeOfCell(collidingCell);
+        var isCollidingCellInRangeOfCurrentCell = collidingCell &&
+            isEqualCellRange(getCalculator().getArrayRangeOfCell(collidingCell), getCalculator().getArrayRangeOfCell(position));
+        var recomputeOperations = [];
+        // Create a sheet cell
+        var sheetCell = new SheetCell();
+        var sourceSheetCell = new SheetCell();
+        var anchorFormula = getUserEnteredValue(position.sheetId, position.rowIndex, position.columnIndex);
+        var filterSourceRange = parseFilterSourceRange(anchorFormula, position.sheetId, getSheetId, formulaTokenizer);
+        var getFilterFormatting = function (columnIndex) {
+            if (!filterSourceRange) {
+                return undefined;
+            }
+            var sourceColumnIndex = filterSourceRange.startColumnIndex +
+                (columnIndex - position.columnIndex);
+            if (sourceColumnIndex < filterSourceRange.startColumnIndex ||
+                sourceColumnIndex > filterSourceRange.endColumnIndex) {
+                return undefined;
+            }
+            var sourceCellData = getCellData(filterSourceRange.sheetId, filterSourceRange.startRowIndex, sourceColumnIndex);
+            var sourceNumberFormat = sourceSheetCell
+                .assign(filterSourceRange.sheetId, {
+                rowIndex: filterSourceRange.startRowIndex,
+                columnIndex: sourceColumnIndex,
+            }, sourceCellData, { locale: locale })
+                .getNumberFormat();
+            return sourceNumberFormat
+                ? { numberFormat: sourceNumberFormat }
+                : undefined;
+        };
+        if (arrayReference) {
+            try {
+                for (var _c = __values(iterateCellsInCellRangeWithResults(arrayReference, result)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var _e = __read(_d.value, 3), rowIndex = _e[0], columnIndex = _e[1], value = _e[2];
+                    var preserveStringLiteral = typeof value === "string";
+                    var effectiveValue = sheetCell
+                        .assign(position.sheetId, {
+                        rowIndex: rowIndex,
+                        columnIndex: columnIndex,
+                    }, undefined, { locale: locale })
+                        .setEffectiveValue(value, false, preserveStringLiteral)
+                        .getEffectiveValue();
+                    var newPosition = {
+                        rowIndex: rowIndex,
+                        columnIndex: columnIndex,
+                        sheetId: getSheetId(arrayReference.sheet),
+                    };
+                    var cellKey = getCalculator().makeKey(newPosition);
+                    var isParentCell = isEqualPosition(position, newPosition);
+                    /**
+                     * When array cells are being filled,
+                     * We have to skip cells that are spilling
+                     * over other bounds
+                     *
+                     * 1. Check if colliding cell and the current array cell share the same range
+                     *  Yes => Fill
+                     *  No => Skip
+                     * 2. Verify if the newly generated cell is inside the colliding cell's range
+                     *  Yes => Skip
+                     *  No => fill
+                     */
+                    var shouldSkipFilling = collidingCell
+                        ? !isCollidingCellInRangeOfCurrentCell &&
+                            isCellWithinCellRange(newPosition, collidingCellRange)
+                        : false;
+                    var isCollidingCell = isEqualCells(collidingCell, {
+                        rowIndex: rowIndex,
+                        columnIndex: columnIndex,
+                    });
+                    var hasDependents = getDependents(newPosition).length > 0;
+                    if (collides && collidingCell) {
+                        if (isParentCell) {
+                            var errorValue = generateCollisionError(collidingCell);
+                            // Add it to computation cache
+                            getComputationCache().set(cellKey, errorValue);
+                            results.set(cellKey, [newPosition, errorValue]);
+                        }
+                        else if (shouldSkipFilling ||
+                            isCollidingCell ||
+                            getUserEnteredValue(position.sheetId, rowIndex, columnIndex) !==
+                                undefined) {
+                            // Do not clear all
+                            continue;
+                        }
+                        else {
+                            if (hasDependents) {
+                                recomputeOperations.push({
+                                    type: "add",
+                                    position: newPosition,
+                                    value: undefined,
+                                });
+                            }
+                            // // Add it to computation cache
+                            getComputationCache().set(cellKey, undefined);
+                            results.set(cellKey, [newPosition, undefined]);
+                        }
+                    }
+                    else {
+                        // Add it to computation cache
+                        getComputationCache().set(cellKey, effectiveValue);
+                        // Add to results
+                        var filterFormatting = getFilterFormatting(columnIndex);
+                        results.set(cellKey, [newPosition, value, filterFormatting]);
+                        // Do not add parent cell to recompute
+                        if (!isParentCell && hasDependents) {
+                            // Recompute
+                            recomputeOperations.push({
+                                type: "add",
+                                position: newPosition,
+                                value: String(value),
+                            });
+                        }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        return [collides, recomputeOperations];
+    }, [
+        locale,
+        getCalculator,
+        getComputationCache,
+        getUserEnteredValue,
+        getCellData,
+        getSheetId,
+        detectArrayCollision,
+    ]);
+    /**
+     * Call when you want to reset an array formula
+     * @param position
+     * @returns
+     */
+    var createArraySideEffectsAndGetResults = useCallback(function (_a) {
+        var position = _a.position, _b = _a.shouldRemoveArrayReference, shouldRemoveArrayReference = _b === void 0 ? true : _b, getDependents = _a.getDependents;
+        var arrayResults = new Map();
+        var createSideEffects = function (position) {
+            var e_3, _a;
+            var isArrayFormula = getCalculator().isArray(position);
+            // Remove array references
+            if (isArrayFormula) {
+                var arrayRange = getCalculator().getArrayRange(position);
+                var _b = __read(collisionDetection(position, arrayRange, getUserEnteredValue), 2), collides = _b[0], collidingCell = _b[1];
+                var collidingCellRange = collidingCell && getCalculator().getArrayRangeOfCell(collidingCell);
+                var isCollidingCellInRangeOfCurrentCell = collidingCell &&
+                    isEqualCellRange(getCalculator().getArrayRangeOfCell(collidingCell), getCalculator().getArrayRangeOfCell(position));
+                if (arrayRange) {
+                    var _loop_1 = function (rowIndex, columnIndex) {
+                        var newPosition = {
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                            sheetId: position.sheetId,
+                        };
+                        var key = getCalculator().makeKey(newPosition);
+                        var isParentCell = isEqualPosition(position, newPosition);
+                        var isCollidingCell = isEqualCells(collidingCell, {
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                        });
+                        // Check if user has entered a value, if so skip
+                        var hasUserEnteredValue = function () {
+                            return !!getUserEnteredValue(newPosition.sheetId, newPosition.rowIndex, newPosition.columnIndex);
+                        };
+                        var shouldSkipFilling = collidingCell
+                            ? (!isCollidingCellInRangeOfCurrentCell &&
+                                isCellWithinCellRange(newPosition, collidingCellRange)) ||
+                                hasUserEnteredValue()
+                            : hasUserEnteredValue();
+                        if (collides &&
+                            collidingCell &&
+                            (isParentCell || isCollidingCell)) {
+                            return "continue";
+                        }
+                        else if (isParentCell || shouldSkipFilling) {
+                            return "continue";
+                        }
+                        else {
+                            // Mark cell as dirty
+                            if (getDependents(newPosition).length) {
+                                getCalculator().markAsDirty(newPosition);
+                            }
+                            // Cache
+                            getComputationCache().set(key, undefined);
+                            // Add to results
+                            arrayResults.set(key, [newPosition, undefined]);
+                        }
+                    };
+                    try {
+                        for (var _c = __values(iterateCellsInCellRange(arrayRange)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var _e = __read(_d.value, 2), rowIndex = _e[0], columnIndex = _e[1];
+                            _loop_1(rowIndex, columnIndex);
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    // Removes array reference from graph
+                    if (shouldRemoveArrayReference) {
+                        getCalculator().removeArrayReferences(position);
+                    }
+                }
+            }
+        };
+        createSideEffects(position);
+        // If its part of a array range, make it dirty
+        var arrayParentCell = getCalculator().getClosestArrayParentCell(position);
+        // Pipeline function that returns array needs to be
+        // cleared immediately if parent cells becomes dirty
+        // THis is because pipeline functions could be async
+        // So user do not have to wait for the next async response
+        // to check if array is in conflict
+        if (arrayParentCell) {
+            if (getCalculator().isPipelineFunction(arrayParentCell)) {
+                createSideEffects(arrayParentCell);
+            }
+            getCalculator().markAsDirty(arrayParentCell);
+        }
+        return arrayResults;
+    }, [getCalculator, getComputationCache, getUserEnteredValue]);
+    // Mark all array cells as dirty
+    var getErrorResultsFromArrayPosition = useCallback(function (position) {
+        var e_4, _a;
+        var isArrayFormula = getCalculator().isArray(position);
+        var arrayResults = new Map();
+        var recomputeOperations = [];
+        if (isArrayFormula) {
+            var arrayRange = getCalculator().getArrayRange(position);
+            if (arrayRange) {
+                try {
+                    for (var _b = __values(iterateCellsInCellRange(arrayRange)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                        var newPosition = {
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                            sheetId: position.sheetId,
+                        };
+                        var isParentCell = isEqualPosition(position, newPosition);
+                        var key = getCalculator().makeKey(newPosition);
+                        if (!isParentCell) {
+                            // Cache
+                            getComputationCache().set(key, undefined);
+                            arrayResults.set(key, [newPosition, undefined]);
+                            // Mark cell as dirty
+                            recomputeOperations.push({
+                                type: "add",
+                                position: newPosition,
+                            });
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            }
+        }
+        return [arrayResults, recomputeOperations];
+    }, [getCalculator, getComputationCache]);
+    return [
+        processArrayResults,
+        createArraySideEffectsAndGetResults,
+        getErrorResultsFromArrayPosition,
+    ];
+};

package/dist/cjs/hooks/use-calculation-queue.d.ts

@@ -0,0 +1,10 @@
+import type { CalculationOperation, useCalculation } from "./use-calculation";
+type UseCalculationQueueProps = {
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+};
+export declare const useCalculationQueue: ({ enqueueCalculation, }: UseCalculationQueueProps) => {
+    enqueue: (op: CalculationOperation) => void;
+    processQueue: () => void;
+};
+export {};
+//# sourceMappingURL=use-calculation-queue.d.ts.map

package/dist/cjs/hooks/use-calculation-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-calculation-queue.d.ts","sourceRoot":"","sources":["../../../hooks/use-calculation-queue.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE9E,KAAK,wBAAwB,GAAG;IAC9B,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;CAC7E,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,yBAEjC,wBAAwB;kBAEQ,oBAAoB;;CAStD,CAAC"}

package/dist/cjs/hooks/use-calculation-queue.js

@@ -0,0 +1,15 @@
+import { DEFAULT_ARRAY } from "@rowsncolumns/spreadsheet";
+import { useCallback, useRef } from "react";
+export var useCalculationQueue = function (_a) {
+    var enqueueCalculation = _a.enqueueCalculation;
+    var queueRef = useRef(DEFAULT_ARRAY);
+    var enqueue = useCallback(function (op) {
+        var _a;
+        (_a = queueRef.current) === null || _a === void 0 ? void 0 : _a.push(op);
+    }, []);
+    var processQueue = useCallback(function () {
+        queueRef.current.forEach(function (op) { return enqueueCalculation(op); });
+        queueRef.current.length = 0;
+    }, [enqueueCalculation]);
+    return { enqueue: enqueue, processQueue: processQueue };
+};

package/dist/cjs/hooks/use-calculation-worker.d.ts

@@ -0,0 +1,37 @@
+import type { CalculationWorkerClientOptions, WorkerSheetMetadata } from "@rowsncolumns/calculation-worker";
+import type { IterativeCalculationOptions } from "@rowsncolumns/common-types";
+import type { NamedRange, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseCalculationProps } from "./use-calculation";
+import type { useCalculation } from "./use-calculation";
+type UseCalculationHookReturn = ReturnType<typeof useCalculation>;
+export type CalculationStats = {
+    queuedCount: number;
+    inFlightCount: number;
+    completedCount: number;
+    deferredCount: number;
+};
+export type WorkerPerfEvent = {
+    type: "worker-batch";
+    phase: "start" | "plan-built" | "worker-dispatch" | "worker-complete" | "worker-runtime-complete" | "first-result" | "complete";
+    size: number;
+    batchId: string;
+    timestamp: number;
+    duration?: number;
+};
+export type UseCalculationWorkerProps = UseCalculationProps & {
+    sheets: WorkerSheetMetadata[];
+    worker?: Worker;
+    createWorker?: () => Worker;
+    workerLogger?: CalculationWorkerClientOptions["logger"];
+    activeSheetId?: number;
+    tables?: TableView[];
+    namedRanges?: NamedRange[];
+    onDemandFormulaPattern?: string;
+    coalesceDelayMs?: number;
+    iterativeCalculation?: IterativeCalculationOptions;
+    onPerformanceEvent?(event: WorkerPerfEvent): void;
+    enablePerformanceLogging?: boolean;
+};
+export declare const useCalculationWorker: (props: UseCalculationWorkerProps) => UseCalculationHookReturn;
+export {};
+//# sourceMappingURL=use-calculation-worker.d.ts.map

package/dist/cjs/hooks/use-calculation-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-calculation-worker.d.ts","sourceRoot":"","sources":["../../../hooks/use-calculation-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,8BAA8B,EAQ9B,mBAAmB,EACpB,MAAM,kCAAkC,CAAC;AAU1C,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,4BAA4B,CAAC;AAkBpC,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAWnC,OAAO,KAAK,EAIV,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,KAAK,wBAAwB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAElE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EACD,OAAO,GACP,YAAY,GACZ,iBAAiB,GACjB,iBAAiB,GACjB,yBAAyB,GACzB,cAAc,GACd,UAAU,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAyEF,MAAM,MAAM,yBAAyB,GAAG,mBAAmB,GAAG;IAC5D,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,8BAA8B,CAAC,QAAQ,CAAC,CAAC;IACxD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,2BAA2B,CAAC;IACnD,kBAAkB,CAAC,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAClD,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,CAAC;AA8KF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,yBAAyB,KAC/B,wBAg7DF,CAAC"}