@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-spreadsheet-state.js

@@ -0,0 +1,2038 @@
+import { __assign, __read, __rest, __values } from "tslib";
+import { isCellNode } from "@rowsncolumns/dag";
+import { isCellWithinBounds } from "@rowsncolumns/grid";
+import { createNewSheet, DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, useGetCellDimensions, useGetColumnWidth, useGetContentfulRangeAroundCell, useGetEffectiveValuesFromRange, useGetRowHeight, } from "@rowsncolumns/spreadsheet";
+import { useFonts } from "@rowsncolumns/spreadsheet";
+import { defaultSpreadsheetTheme, useCallbackRef, useSpreadsheetTheme, } from "@rowsncolumns/spreadsheet";
+import { findMatchingBandProperty, getCurrentLocale, isNil, setDefaultEnableAtFormula, uuid, } from "@rowsncolumns/utils";
+import { enableMapSet, enablePatches, setUseStrictShallowCopy } from "immer";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { getAutoFillValues as defaultGetAutoFillValues } from "../api/fill";
+import { getGeneratedSheetName } from "../generated-names";
+import { SheetCell } from "../sheet-cell";
+import { useCalculation } from "./use-calculation";
+import { useCalculationInitialize } from "./use-calculation-initialize";
+import { useCalculationWorker } from "./use-calculation-worker";
+import { useCellXfsRegistry } from "./use-cellxfs-registry";
+import { useComments } from "./use-comments";
+import { useCitations } from "./use-citations";
+import { useConditionalFormattingRules } from "./use-conditional-formatting-rules";
+import { useDataValidationRules } from "./use-data-validation-rules";
+import { useIndent } from "./use-indent";
+import { useNamedRange } from "./use-named-range";
+import { useOnAutoResize } from "./use-on-autoresize";
+import { useOnBandedRanges } from "./use-on-banded-ranges";
+import { useOnCalculationBegin } from "./use-on-calculation-begin";
+import { useOnCalculationSuccess } from "./use-on-calculation-success";
+import { useOnChange } from "./use-on-change";
+import { useOnChangeBatch } from "./use-on-change-batch";
+import { useOnChangeBatchStream } from "./use-on-change-batch-stream";
+import { useOnChangeDecimals } from "./use-on-change-decimals";
+import { useOnChangeFormatting } from "./use-on-change-formatting";
+import { useOnChangeSheetTabcolor } from "./use-on-change-sheet-tabcolor";
+import { useOnChangeTheme } from "./use-on-change-theme";
+import { useOnClearFormatting } from "./use-on-clear-formatting";
+import { useOnCopy } from "./use-on-copy";
+import { useOnCreateNamedRange } from "./use-on-create-named-range";
+import { useOnCreateNewSheet } from "./use-on-create-sheet";
+import { useOnDelete } from "./use-on-delete";
+import { useOnDeleteCellsShiftLeft } from "./use-on-delete-cells-shift-left";
+import { useOnDeleteCellsShiftUp } from "./use-on-delete-cells-shift-up";
+import { useOnDeleteColumn } from "./use-on-delete-column";
+import { useOnDeleteNamedRange } from "./use-on-delete-named-range";
+import { useOnDeleteRow } from "./use-on-delete-row";
+import { useOnDeleteSheet } from "./use-on-delete-sheet";
+import { useOnDeleteTableRow } from "./use-on-delete-table-row";
+import { useOnDragnDrop } from "./use-on-drag-n-drop";
+import { useOnDuplicateSheet } from "./use-on-duplicate-sheet";
+import { useOnEmbeds } from "./use-on-embeds";
+import { useSlicers } from "./use-slicers";
+import { useOnFill } from "./use-on-fill";
+import { useOnFillRange } from "./use-on-fill-range";
+import { useOnFilterTable } from "./use-on-filter-table";
+import { useOnFindReplace } from "./use-on-find-replace";
+import { useOnFreeze } from "./use-on-freeze";
+import { useOnCollapseColumnGroup } from "./use-on-collapse-column-group";
+import { useOnCollapseRowGroup } from "./use-on-collapse-row-group";
+import { useOnExpandColumnGroup } from "./use-on-expand-column-group";
+import { useOnExpandRowGroup } from "./use-on-expand-row-group";
+import { useOnGroupColumns } from "./use-on-group-columns";
+import { useOnGroupRows } from "./use-on-group-rows";
+import { useOnSetOutlineDepth } from "./use-on-set-outline-depth";
+import { useOnHideColumn } from "./use-on-hide-column";
+import { useOnHideRow } from "./use-on-hide-row";
+import { useOnUngroupColumns } from "./use-on-ungroup-columns";
+import { useOnUngroupRows } from "./use-on-ungroup-rows";
+import { useOnShowHideSheet } from "./use-on-hide-show-sheet";
+import { useOnImportCSV } from "./use-on-import-csv";
+import { useOnImportCSVLegacy } from "./use-on-import-csv-legacy";
+import { useOnImportExcelFile } from "./use-on-import-excel";
+import { useOnInsertAutoSum } from "./use-on-insert-autosum";
+import { useOnInsertCellsShiftDown } from "./use-on-insert-cells-shift-down";
+import { useOnInsertCellsShiftRight } from "./use-on-insert-cells-shift-right";
+import { useOnInsertCheckbox } from "./use-on-insert-checkbox";
+import { useOnInsertColumn } from "./use-on-insert-column";
+import { useOnInsertDate } from "./use-on-insert-date";
+import { useOnInsertDateTime } from "./use-on-insert-date-time";
+import { useOnInsertImage } from "./use-on-insert-image";
+import { useOnInsertLink } from "./use-on-insert-link";
+import { useOnInsertNote } from "./use-on-insert-note";
+import { useOnInsertRow } from "./use-on-insert-row";
+import { useOnInsertTableRow } from "./use-on-insert-table-row";
+import { useOnInsertTime } from "./use-on-insert-time";
+import { useOnMergeUnMergeCells } from "./use-on-merge-unmerge-cells";
+import { useOnMoveColumns } from "./use-on-move-columns";
+import { useOnMoveRows } from "./use-on-move-rows";
+import { useOnMoveSelection } from "./use-on-move-selection";
+import { useOnMoveSheet } from "./use-on-move-sheet";
+import { useOnPaste } from "./use-on-paste";
+import { useOnProtectRange } from "./use-on-protect-range";
+import { useOnProtectSheet } from "./use-on-protect-sheet";
+import { useOnRenameSheet } from "./use-on-rename-sheet";
+import { useOnRequestCalculateWrapper } from "./use-on-request-calculate-wrapper";
+import { useOnRequestConditionalFormat } from "./use-on-request-conditional-format";
+import { useOnRequestDataValidation } from "./use-on-request-data-validation";
+import { useOnRequestDefineNamedRange } from "./use-on-request-define-named-range";
+import { useOnRequestDeleteSheet } from "./use-on-request-delete-sheet";
+import { useOnRequestEditTable } from "./use-on-request-edit-table";
+import { useOnRequestFormatCells } from "./use-on-request-format-cells";
+import { useOnRequestInsertImage } from "./use-on-request-insert-image";
+import { useOnRequestInsertLink } from "./use-on-request-insert-link";
+import { useOnRequestResize } from "./use-on-request-resize";
+import { useOnRequestUpdateNamedRange } from "./use-on-request-update-named-range";
+import { useOnResize } from "./use-on-resize";
+import { useOnResizeTable } from "./use-on-resize-table";
+import { useOnShowColumn } from "./use-on-show-column";
+import { useOnShowRow } from "./use-on-show-row";
+import { useOnSortColumn } from "./use-on-sort-column";
+import { useOnSortRange } from "./use-on-sort-range";
+import { useOnSortTable } from "./use-on-sort-table";
+import { useOnTable } from "./use-on-table";
+import { useOnTraceDependentsPrecedents } from "./use-on-trace-dependents-precedents";
+import { useOnUpdateNamedRange } from "./use-on-update-named-range";
+import { useOnUpdateNote } from "./use-on-update-note";
+import { useOnUpdateSheet } from "./use-on-update-sheet";
+import { usePaintFormat } from "./use-paint-format";
+import { useSelectNextPrevSheet } from "./use-select-next-prev-sheet";
+import { useSheetObserver } from "./use-sheet-observer";
+import { useSheetProperties } from "./use-sheet-properties";
+import { useSheetState } from "./use-sheet-state";
+import { useSheetDataSubscriber } from "./use-sheetdata-subscriber";
+import { useSplitTextToColumns } from "./use-split-text-to-columns";
+import { useOnLocaleChange } from "./use-on-locale-change";
+import { useOnRemoveDuplicates } from "./use-on-remove-duplicates";
+import { useSharedStringRegistry } from "./use-ss-registry";
+import { useStructuredReference } from "./use-structured-reference";
+import { useUndoRedo } from "./use-undo-redo";
+import { useUndoRedoActions } from "./use-undo-redo-actions";
+// Immer
+enablePatches();
+enableMapSet();
+setUseStrictShallowCopy(true);
+// Formulas whose result depends on row visibility (hidden / filtered
+// rows) and therefore must recalc when visibility changes even though
+// no cell value changed.
+var SUBTOTAL_FORMULA_PATTERN = /SUBTOTAL\s*\(/i;
+/**
+ * Banding for a table whose bandedRange was never materialised. Documents imported
+ * before the importers resolved built-in table style names persist only the theme
+ * name (e.g. "TableStyleMedium2"). Mirrors the importers' resolution: the built-in
+ * palette plus the stripe-toggle trim — row stripes off keeps only the header/total
+ * -row visuals, column stripes off drops the column banding.
+ */
+export var deriveBuiltInTableBanding = function (table) {
+    if (!table.theme) {
+        return undefined;
+    }
+    var showRowStripes = table.showRowStripes !== false;
+    var showColumnStripes = table.showColumnStripes === true;
+    var banded = findMatchingBandProperty(table.theme, showRowStripes, showColumnStripes);
+    if (!banded) {
+        return undefined;
+    }
+    if (!showRowStripes && banded.rowProperties) {
+        var _a = banded.rowProperties, headerColor = _a.headerColor, headerBorder = _a.headerBorder, totalRowColor = _a.totalRowColor, totalRowBorder = _a.totalRowBorder;
+        if (headerColor || headerBorder || totalRowColor || totalRowBorder) {
+            banded.rowProperties = {
+                headerColor: headerColor,
+                headerBorder: headerBorder,
+                totalRowColor: totalRowColor,
+                totalRowBorder: totalRowBorder,
+            };
+        }
+        else {
+            banded.rowProperties = undefined;
+        }
+    }
+    if (!showColumnStripes) {
+        banded.columnProperties = undefined;
+    }
+    if (!banded.rowProperties && !banded.columnProperties) {
+        return undefined;
+    }
+    return banded;
+};
+/**
+ * Use Spreadsheet Hook
+ * @param param0
+ * @returns
+ */
+export var useSpreadsheetState = function (_a) {
+    var 
+    // Sheets
+    sheets = _a.sheets, onChangeSheets = _a.onChangeSheets, 
+    // Theme
+    _b = _a.theme, 
+    // Theme
+    theme = _b === void 0 ? defaultSpreadsheetTheme : _b, 
+    // Functions
+    functions = _a.functions, 
+    // OnDemand formula pattern
+    onDemandFormulaPattern = _a.onDemandFormulaPattern, _c = _a.enableLazyCalculation, enableLazyCalculation = _c === void 0 ? true : _c, 
+    // Conditional formats
+    conditionalFormats = _a.conditionalFormats, 
+    // Data validations
+    dataValidations = _a.dataValidations, 
+    // Tables
+    tables = _a.tables, namedRanges = _a.namedRanges, 
+    // Flag for excel import history change
+    enableExcelImportHistory = _a.enableExcelImportHistory, enableExcelfileDragDrop = _a.enableExcelfileDragDrop, onChangeTables = _a.onChangeTables, onChangeNamedRanges = _a.onChangeNamedRanges, onChangeCharts = _a.onChangeCharts, onChangeEmbeds = _a.onChangeEmbeds, onChangeProtectedRanges = _a.onChangeProtectedRanges, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, onChangeBandedRanges = _a.onChangeBandedRanges, onChangePivotTables = _a.onChangePivotTables, 
+    // Grid data
+    sheetData = _a.sheetData, onChangeSheetData = _a.onChangeSheetData, 
+    // Calculator
+    onChangeDependencyGraph = _a.onChangeDependencyGraph, 
+    // History
+    onChangeHistory = _a.onChangeHistory, 
+    // Semantic command stream
+    onCommandProp = _a.onCommand, 
+    // Theme
+    onChangeTheme = _a.onChangeTheme, 
+    // error handler
+    onError = _a.onError, 
+    // Get auto fill values
+    _d = _a.getAutoFillValues, 
+    // Get auto fill values
+    rawGetAutoFillValues = _d === void 0 ? defaultGetAutoFillValues : _d, 
+    // User-defined autofill lists
+    customAutofillLists = _a.customAutofillLists, 
+    // For calculations
+    getEffectiveStructuredValue = _a.getEffectiveStructuredValue, 
+    // Dark theme classname
+    _e = _a.darkThemeClassName, 
+    // Dark theme classname
+    darkThemeClassName = _e === void 0 ? "rnc-dark" : _e, 
+    // Color mode
+    colorMode = _a.colorMode, 
+    // Google fonts that will be loaded
+    // on-demand
+    fonts = _a.fonts, 
+    // Drag and drop
+    _f = _a.enableDragnDrop, 
+    // Drag and drop
+    enableDragnDrop = _f === void 0 ? true : _f, 
+    // Enable undo/redo functionality
+    _g = _a.enabledUndoRedo, 
+    // Enable undo/redo functionality
+    enabledUndoRedo = _g === void 0 ? true : _g, 
+    // Current locale
+    _h = _a.locale, 
+    // Current locale
+    locale = _h === void 0 ? getCurrentLocale() : _h, 
+    // Templates for auto-generated names (sheets, tables, table columns)
+    generatedNamesProp = _a.generatedNames, _j = _a.enableAtFormula, enableAtFormula = _j === void 0 ? false : _j, 
+    // Preserve data formatting like color, font style on paste
+    preserveFormattingOnPaste = _a.preserveFormattingOnPaste, 
+    // Trigger manual recalculation
+    _k = _a.recalculateOnOpen, 
+    // Trigger manual recalculation
+    recalculateOnOpen = _k === void 0 ? false : _k, 
+    // Protect formulas
+    protectFormulas = _a.protectFormulas, 
+    // Max limits
+    maxRowCount = _a.maxRowCount, maxColumnCount = _a.maxColumnCount, maxSheetCount = _a.maxSheetCount, 
+    // ID Creation strategy
+    idCreationStrategy = _a.idCreationStrategy, 
+    // File size limit
+    fileSizeLimit = _a.fileSizeLimit, 
+    // Hydrated registry passed in by user
+    cellXfs = _a.cellXfs, cellStyles = _a.cellStyles, onChangeCellXfs = _a.onChangeCellXfs, 
+    // Shared strings
+    sharedStrings = _a.sharedStrings, onChangeSharedStrings = _a.onChangeSharedStrings, 
+    // Callback when new fonts are requested
+    onRequestFonts = _a.onRequestFonts, 
+    // Slicers
+    onChangeSlicers = _a.onChangeSlicers, 
+    // Citations
+    citations = _a.citations, onChangeCitations = _a.onChangeCitations, 
+    // Create calculation worker
+    createCalculationWorker = _a.createCalculationWorker, 
+    // Calculation mode
+    _l = _a.calculationMode, 
+    // Calculation mode
+    calculationMode = _l === void 0 ? "single" : _l, iterativeCalculation = _a.iterativeCalculation, onIterativeCalculationEnabled = _a.onIterativeCalculationEnabled, 
+    // Stream callbacks
+    onStreamStart = _a.onStreamStart, onStreamProgress = _a.onStreamProgress, onStreamEnd = _a.onStreamEnd, 
+    // Custom modal functions
+    onConfirm = _a.onConfirm, onPrompt = _a.onPrompt, 
+    /**
+     * Optional HTML sanitizer for clipboard paste operations.
+     * Called before parsing HTML from clipboard to prevent XSS attacks.
+     * Use with DOMPurify or similar library.
+     */
+    sanitizeHtml = _a.sanitizeHtml;
+    /**
+     * Sheets
+     */
+    var _m = useSheetState({
+        sheets: sheets,
+        onChangeSheets: onChangeSheets,
+    }), activeSheetId = _m.activeSheetId, activeCell = _m.activeCell, selections = _m.selections, activeCellBySheetId = _m.activeCellBySheetId, selectionsBySheetId = _m.selectionsBySheetId, onChangeActiveCell = _m.onChangeActiveCell, onChangeActiveSheet = _m.onChangeActiveSheet, onChangeSelections = _m.onChangeSelections;
+    // Load default fonts
+    useFonts(fonts);
+    // Disable @ formula
+    useEffect(function () {
+        SheetCell.setDefaultEnableAtFormula(enableAtFormula);
+        setDefaultEnableAtFormula(enableAtFormula);
+    }, [enableAtFormula]);
+    // Auto resize
+    var getFinalColumnWidth = useGetColumnWidth();
+    var getFinalRowHeight = useGetRowHeight();
+    var sharedStringRegistry = useSharedStringRegistry(sharedStrings !== null && sharedStrings !== void 0 ? sharedStrings : undefined, onChangeSharedStrings);
+    // CellXfs CellFormat registry
+    var cellXfsRegistry = useCellXfsRegistry(cellXfs, onChangeCellXfs);
+    // Themes
+    var _o = useSpreadsheetTheme({
+        theme: theme,
+        darkThemeClassName: darkThemeClassName,
+        colorMode: colorMode,
+    }), isDarkMode = _o.isDarkMode, spreadsheetColors = __rest(_o, ["isDarkMode"]);
+    // Consumers commonly pass an inline `onCommand` (a fresh function every
+    // render). Roughly 40 derived callbacks list `onCommand` in their
+    // `useCallback` deps (onSplitTextToColumns, onChangeFormatting, onPaste, …),
+    // so an unstable emitter gives every one of them a new identity each render —
+    // which cascades into a CanvasGrid re-render loop ("Maximum update depth
+    // exceeded"). Stabilize the identity via `useCallbackRef`, but preserve
+    // undefined-ness so the `if (onCommand)` presence checks in those hooks still
+    // short-circuit when no emitter was supplied.
+    var onCommandStable = useCallbackRef(onCommandProp);
+    var onCommand = onCommandProp ? onCommandStable : undefined;
+    // Consumers commonly pass `generatedNames` as an inline object literal with
+    // inline arrow functions (fresh identities every render). Stabilize it the
+    // same way as `onCommand` above: constant-identity wrappers that always
+    // delegate to the latest formatters, so the `useCallback`s that list
+    // `generatedNames` in their deps never see a new identity. Preserve
+    // undefined-ness so the default (no prop) stays a stable no-op.
+    var generatedNameSheet = useCallbackRef(generatedNamesProp === null || generatedNamesProp === void 0 ? void 0 : generatedNamesProp.sheet);
+    var generatedNameSheetCopy = useCallbackRef(generatedNamesProp === null || generatedNamesProp === void 0 ? void 0 : generatedNamesProp.sheetCopy);
+    var generatedNameTable = useCallbackRef(generatedNamesProp === null || generatedNamesProp === void 0 ? void 0 : generatedNamesProp.table);
+    var generatedNameTableCopy = useCallbackRef(generatedNamesProp === null || generatedNamesProp === void 0 ? void 0 : generatedNamesProp.tableCopy);
+    var generatedNameTableColumn = useCallbackRef(generatedNamesProp === null || generatedNamesProp === void 0 ? void 0 : generatedNamesProp.tableColumn);
+    var generatedNamesStable = useMemo(function () { return ({
+        sheet: generatedNameSheet,
+        sheetCopy: generatedNameSheetCopy,
+        table: generatedNameTable,
+        tableCopy: generatedNameTableCopy,
+        tableColumn: generatedNameTableColumn,
+    }); }, [
+        generatedNameSheet,
+        generatedNameSheetCopy,
+        generatedNameTable,
+        generatedNameTableCopy,
+        generatedNameTableColumn,
+    ]);
+    var generatedNames = generatedNamesProp ? generatedNamesStable : undefined;
+    // Get current active cell
+    var getActiveCell = useCallbackRef(useCallback(function () { return activeCell; }, [activeCell]));
+    // Get current active cell
+    var getSelections = useCallbackRef(useCallback(function () { return selections; }, [selections]));
+    // Extract row count and column count
+    var _p = useMemo(function () {
+        var _a;
+        var sheet = sheets.find(function (sheet) { return sheet.sheetId === activeSheetId; });
+        // For collaboration mode
+        // when someone deletes a sheet
+        if (!sheet) {
+            var sheetLen = sheets.length;
+            return createNewSheet((_a = idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("sheet")) !== null && _a !== void 0 ? _a : uuid(), getGeneratedSheetName(sheetLen + 1, generatedNames), maxRowCount, maxColumnCount, false);
+        }
+        return sheet;
+    }, [
+        activeSheetId,
+        idCreationStrategy,
+        sheets,
+        maxRowCount,
+        maxColumnCount,
+        generatedNames,
+    ]), _q = _p.rowCount, _rowCount = _q === void 0 ? DEFAULT_ROW_COUNT : _q, _r = _p.columnCount, _columnCount = _r === void 0 ? DEFAULT_COLUMN_COUNT : _r, frozenColumnCount = _p.frozenColumnCount, frozenRowCount = _p.frozenRowCount, rowMetadata = _p.rowMetadata, columnMetadata = _p.columnMetadata, merges = _p.merges, showGridLines = _p.showGridLines, showRowColHeaders = _p.showRowColHeaders, zoomScale = _p.zoomScale, basicFilter = _p.basicFilter;
+    // Accept defaults
+    var rowCount = _rowCount !== null && _rowCount !== void 0 ? _rowCount : DEFAULT_ROW_COUNT;
+    var columnCount = _columnCount !== null && _columnCount !== void 0 ? _columnCount : DEFAULT_ROW_COUNT;
+    // Check if cell is merged
+    var isMergedCell = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var _a;
+        var sheet = sheets.find(function (sheet) { return sheet.sheetId === sheetId; });
+        if (sheet) {
+            return (_a = sheet.merges) === null || _a === void 0 ? void 0 : _a.some(function (range) {
+                return isCellWithinBounds({ rowIndex: rowIndex, columnIndex: columnIndex }, range);
+            });
+        }
+        return false;
+    }, [sheets]);
+    /**
+     * Get banded ranges from table. A table with no materialised bandedRange falls back
+     * to its built-in theme name — documents imported before the importers resolved
+     * built-in table styles persist only the name, and the grid paints tables
+     * exclusively from bandedRange, so without the fallback they render unstyled.
+     */
+    var bandedRanges = useMemo(function () {
+        return tables === null || tables === void 0 ? void 0 : tables.filter(function (_a) {
+            var sheetId = _a.sheetId;
+            return sheetId === activeSheetId;
+        }).map(function (table) {
+            var _a;
+            var banded = (_a = table.bandedRange) !== null && _a !== void 0 ? _a : deriveBuiltInTableBanding(table);
+            if (isNil(banded)) {
+                return undefined;
+            }
+            return __assign({ bandedRangeId: "".concat(table.id, "-").concat(table.theme), 
+                // Add sheet Id to range
+                range: __assign(__assign({}, table.range), { sheetId: activeSheetId }) }, banded);
+        }).filter(function (band) { return !isNil(band); });
+    }, [tables, activeSheetId]);
+    var getCellDimensions = useGetCellDimensions();
+    var getCurrentRowHeight = useGetRowHeight();
+    var getContentfulRangeAroundCell = useGetContentfulRangeAroundCell();
+    /**
+     * Forward-reference for `getPrecedents` so `useSheetProperties` can call
+     * it from inside `getEffectiveFormat` without depending on hook order
+     * (the calculator hook initialises after sheet-properties).
+     */
+    var getPrecedentsRef = useRef(undefined);
+    var getPrecedentsForward = useCallback(function (cell) { var _a, _b; return (_b = (_a = getPrecedentsRef.current) === null || _a === void 0 ? void 0 : _a.call(getPrecedentsRef, cell)) !== null && _b !== void 0 ? _b : []; }, []);
+    // Sheet properties
+    var _s = useSheetProperties({
+        getEffectiveStructuredValue: getEffectiveStructuredValue,
+        conditionalFormats: conditionalFormats,
+        sheetData: sheetData,
+        sheets: sheets,
+        activeSheetId: activeSheetId,
+        cellXfs: cellXfs,
+        cellXfsRegistry: cellXfsRegistry,
+        cellStyles: cellStyles !== null && cellStyles !== void 0 ? cellStyles : undefined,
+        protectFormulas: protectFormulas,
+        dataValidations: dataValidations,
+        sharedStrings: sharedStrings,
+        locale: locale,
+        getPrecedents: getPrecedentsForward,
+    }), getDataRowCount = _s.getDataRowCount, getNonEmptyRowCount = _s.getNonEmptyRowCount, getNonEmptyColumnCount = _s.getNonEmptyColumnCount, getDataColumnCount = _s.getDataColumnCount, getSheetId = _s.getSheetId, getSheetName = _s.getSheetName, getSheetCount = _s.getSheetCount, getSheetIndex = _s.getSheetIndex, getSheetProperties = _s.getSheetProperties, getCellData = _s.getCellData, getMentionsFromCell = _s.getMentionsFromCell, getTextFormatRuns = _s.getTextFormatRuns, getEffectiveValue = _s.getEffectiveValue, getEffectiveValueForCalculation = _s.getEffectiveValueForCalculation, getUserEnteredValue = _s.getUserEnteredValue, getUserEnteredValueStable = _s.getUserEnteredValueStable, getConditionalFormatFormula = _s.getConditionalFormatFormula, getDataValidationFormula = _s.getDataValidationFormula, getDataValidation = _s.getDataValidation, getDataValidationById = _s.getDataValidationById, getActiveSheetId = _s.getActiveSheetId, getUserEnteredFormat = _s.getUserEnteredFormat, getEffectiveFormat = _s.getEffectiveFormat, getFormattedValue = _s.getFormattedValue, getSeriesValuesFromRange = _s.getSeriesValuesFromRange, getFormattingFromRange = _s.getFormattingFromRange, getUserEnteredValuesFromRange = _s.getUserEnteredValuesFromRange, getFormulasFromRange = _s.getFormulasFromRange, getDomainValuesFromRange = _s.getDomainValuesFromRange, getColumnarDataFromRange = _s.getColumnarDataFromRange, isColumnHidden = _s.isColumnHidden, isHiddenRow = _s.isHiddenRow, isHiddenByFilterRow = _s.isHiddenByFilterRow, getSheetRowCount = _s.getSheetRowCount, getSheetColumnCount = _s.getSheetColumnCount, getColumnWidth = _s.getColumnWidth, getRowHeight = _s.getRowHeight, getEffectiveExtendedValue = _s.getEffectiveExtendedValue, getUserEnteredExtendedValue = _s.getUserEnteredExtendedValue, getFrozenRowCount = _s.getFrozenRowCount, getErrorValue = _s.getErrorValue;
+    // Subscriber
+    useSheetDataSubscriber({ sheetData: sheetData });
+    var _t = useSelectNextPrevSheet({
+        onChangeActiveSheet: onChangeActiveSheet,
+        sheets: sheets,
+    }), onSelectNextSheet = _t.onSelectNextSheet, onSelectPreviousSheet = _t.onSelectPreviousSheet;
+    // Get structured reference
+    var onStructuredReference = useStructuredReference({
+        tables: tables,
+        sheetId: activeSheetId,
+        getSheetName: getSheetName,
+    });
+    // Named ranges
+    var onNamedRange = useNamedRange({
+        namedRanges: namedRanges,
+        getSheetName: getSheetName,
+    });
+    // calculation success
+    var onCalculationSuccess = useOnCalculationSuccess({
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getDataValidationById: getDataValidationById,
+        onChangeSheetData: onChangeSheetData,
+        getPrecedents: function (source) {
+            return getPrecedents(source);
+        },
+        createHistory: function () {
+            return createHistoryWithoutPointer();
+        },
+        getSheetId: getSheetId,
+    });
+    // Being calculation
+    var onCalculationBegin = useOnCalculationBegin({
+        onChangeSheetData: onChangeSheetData,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+    });
+    // Sheet mneta data for worker
+    var sheetsMetadata = useMemo(function () {
+        return sheets.map(function (sheet) {
+            var _a, _b;
+            return {
+                id: sheet.sheetId,
+                name: sheet.title,
+                rowCount: (_a = sheet.rowCount) !== null && _a !== void 0 ? _a : undefined,
+                columnCount: (_b = sheet.columnCount) !== null && _b !== void 0 ? _b : undefined,
+            };
+        });
+    }, [sheets]);
+    // Worker-based calculation hook
+    var workerCalculation = useCalculationWorker({
+        locale: locale,
+        sheets: sheetsMetadata,
+        tables: tables,
+        namedRanges: namedRanges,
+        createWorker: createCalculationWorker,
+        getActiveSheetId: getActiveSheetId,
+        activeSheetId: activeSheetId,
+        onSuccess: onCalculationSuccess,
+        onBeginCalculation: onCalculationBegin,
+        getSheetName: getSheetName,
+        getSheetCount: getSheetCount,
+        getSheetIndex: getSheetIndex,
+        onStructuredReference: onStructuredReference,
+        getSheetId: getSheetId,
+        onNamedRange: onNamedRange,
+        getSheetProperties: getSheetProperties,
+        getEffectiveValue: getEffectiveValueForCalculation,
+        getUserEnteredValue: getUserEnteredValueStable,
+        getConditionalFormatFormula: getConditionalFormatFormula,
+        getDataValidationFormula: getDataValidationFormula,
+        onDemandFormulaPattern: onDemandFormulaPattern,
+        enableLazyCalculation: enableLazyCalculation,
+        onChangeStaticReference: function (nodes) { return onChangeStaticReference(nodes); },
+        onChangeDependencyGraph: onChangeDependencyGraph,
+        iterativeCalculation: iterativeCalculation,
+        // Not implemented yet in worker level..
+        // Worker has no access to underlying cell data in the sheet
+        getCellData: getCellData,
+        getEffectiveStructuredValue: getEffectiveStructuredValue,
+        enabled: calculationMode === "worker",
+    });
+    // Single-threaded calculation hook
+    var singleCalculation = useCalculation({
+        locale: locale,
+        getActiveSheetId: getActiveSheetId,
+        onSuccess: onCalculationSuccess,
+        onBeginCalculation: onCalculationBegin,
+        getSheetName: getSheetName,
+        getSheetCount: getSheetCount,
+        onStructuredReference: onStructuredReference,
+        getSheetId: getSheetId,
+        onNamedRange: onNamedRange,
+        namedRanges: namedRanges,
+        getSheetProperties: getSheetProperties,
+        getEffectiveValue: getEffectiveValueForCalculation,
+        activeSheetId: activeSheetId,
+        getSheetIndex: getSheetIndex,
+        getUserEnteredValue: getUserEnteredValueStable,
+        getConditionalFormatFormula: getConditionalFormatFormula,
+        getDataValidationFormula: getDataValidationFormula,
+        functions: functions,
+        onDemandFormulaPattern: onDemandFormulaPattern,
+        enableLazyCalculation: enableLazyCalculation,
+        onChangeStaticReference: function (nodes) { return onChangeStaticReference(nodes); },
+        onChangeDependencyGraph: onChangeDependencyGraph,
+        getCellData: getCellData,
+        getEffectiveStructuredValue: getEffectiveStructuredValue,
+        iterativeCalculation: iterativeCalculation,
+        isRowHidden: isHiddenRow,
+        isRowHiddenByFilter: isHiddenByFilterRow,
+        enabled: calculationMode !== "worker",
+    });
+    // Use the appropriate calculation hook based on mode
+    var _u = calculationMode === "worker" ? workerCalculation : singleCalculation, enqueueCalculation = _u.enqueueCalculation, enqueueGraphOperation = _u.enqueueGraphOperation, enqueueStructureChange = _u.enqueueStructureChange, clearRangeCache = _u.clearRangeCache, onRequestCalculateWithoutFormatting = _u.onRequestCalculate, getPrecedents = _u.getPrecedents, getDependents = _u.getDependents, getPrecedentsFromFormulaString = _u.getPrecedentsFromFormulaString, getGraphNodes = _u.getGraphNodes, getGraphNodesInSheet = _u.getGraphNodesInSheet, addStaticReference = _u.addStaticReference, addFormulaToGraph = _u.addFormulaToGraph, removeStaticReference = _u.removeStaticReference, onResetCalculator = _u.onResetCalculator, getDependencyGraph = _u.getDependencyGraph, updateDependencyGraph = _u.updateDependencyGraph, isArrayFormula = _u.isArrayFormula, applyNamedRanges = _u.applyNamedRanges;
+    // Bind the forward-ref so `useSheetProperties.getEffectiveFormat` can walk
+    // precedents now that the calculator is initialised.
+    getPrecedentsRef.current = getPrecedents;
+    /**
+     * Row visibility changed (filter applied/cleared, rows hidden or
+     * unhidden). Cell values are untouched so the dependency graph has
+     * nothing dirty — but SUBTOTAL reads row visibility, so re-run every
+     * SUBTOTAL formula in the workbook.
+     */
+    var onRowVisibilityChange = useCallback(function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(getGraphNodes().values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var node = _c.value;
+                if (!isCellNode(node)) {
+                    continue;
+                }
+                var position = node.position;
+                var userEnteredValue = getUserEnteredValueStable(position.sheetId, position.rowIndex, position.columnIndex);
+                if (typeof userEnteredValue === "string" &&
+                    SUBTOTAL_FORMULA_PATTERN.test(userEnteredValue)) {
+                    enqueueCalculation({ type: "dirty", position: position, force: true });
+                }
+            }
+        }
+        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; }
+        }
+    }, [getGraphNodes, enqueueCalculation, getUserEnteredValueStable]);
+    // Sheet data observer
+    var onChangeStaticReference = useSheetObserver({
+        onAddStaticReference: addStaticReference,
+        onRemoveStaticReference: removeStaticReference,
+    }).onChangeStaticReference;
+    // Intercept request calculate to inject formatting
+    var onRequestCalculate = useOnRequestCalculateWrapper({
+        locale: locale,
+        sheetData: sheetData,
+        getPrecedentsFromFormulaString: getPrecedentsFromFormulaString,
+        getSheetId: getSheetId,
+        cellXfsRegistry: cellXfsRegistry,
+        onRequestCalculate: onRequestCalculateWithoutFormatting,
+        getEffectiveFormat: getEffectiveFormat,
+    });
+    // Calculation initialize
+    var _v = useCalculationInitialize({
+        recalculateOnOpen: recalculateOnOpen,
+        sheetData: sheetData,
+        conditionalFormats: conditionalFormats,
+        dataValidations: dataValidations,
+        activeSheetId: activeSheetId,
+        iterativeCalculation: iterativeCalculation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        onResetCalculator: onResetCalculator,
+        getDataValidationById: getDataValidationById,
+        namedRanges: namedRanges,
+        applyNamedRanges: applyNamedRanges,
+    }), calculateNow = _v.calculateNow, evaluateConditionalFormatting = _v.evaluateConditionalFormatting, evaluateDataValidations = _v.evaluateDataValidations, evaluateConditionalFormattingForViewport = _v.evaluateConditionalFormattingForViewport, evaluateDataValidationsForViewport = _v.evaluateDataValidationsForViewport, clearEvaluatedCellsCache = _v.clearEvaluatedCellsCache, onViewPortChange = _v.onViewPortChange, reevaluateDerivationsForCells = _v.reevaluateDerivationsForCells;
+    // Undo redo action manager
+    var _w = useUndoRedoActions({
+        sheetId: activeSheetId,
+        onChangeActiveCell: onChangeActiveCell,
+        onChangeActiveSheet: onChangeActiveSheet,
+        onChangeSelections: onChangeSelections,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeCharts: onChangeCharts,
+        onChangeEmbeds: onChangeEmbeds,
+        onChangeTables: onChangeTables,
+        onChangeNamedRanges: onChangeNamedRanges,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        onChangeProtectedRanges: onChangeProtectedRanges,
+        onChangePivotTables: onChangePivotTables,
+        onChangeCellXfs: onChangeCellXfs,
+        onChangeTheme: onChangeTheme,
+        onChangeSlicers: onChangeSlicers,
+        onChangeCitations: onChangeCitations,
+        enqueueCalculation: enqueueCalculation,
+        onChangeSharedStrings: onChangeSharedStrings,
+        clearRangeCache: clearRangeCache,
+    }), onRedoAction = _w.onRedoAction, onUndoAction = _w.onUndoAction, applyPatch = _w.applyPatch;
+    // Undo manager
+    var _x = useUndoRedo({
+        isEnabled: enabledUndoRedo,
+        onUndoAction: onUndoAction,
+        onRedoAction: onRedoAction,
+        onChangeHistory: onChangeHistory,
+    }), createHistory = _x.createHistory, createHistoryWithoutPointer = _x.createHistoryWithoutPointer, onRedo = _x.onRedo, onUndo = _x.onUndo, canUndo = _x.canUndo, canRedo = _x.canRedo, onClearHistory = _x.onClearHistory;
+    var onChangeSpreadsheetTheme = useOnChangeTheme({
+        createHistory: createHistory,
+        onChangeTheme: onChangeTheme,
+        onCommand: onCommand,
+    });
+    // Sheet color
+    var onChangeSheetTabColor = useOnChangeSheetTabcolor({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    // Sheet name
+    var onRenameSheet = useOnRenameSheet({
+        locale: locale,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeSheetData: onChangeSheetData,
+        onChangeActiveCell: onChangeActiveCell,
+        getActiveCell: getActiveCell,
+        getGraphNodes: getGraphNodes,
+        getPrecedents: getPrecedents,
+        onCommand: onCommand,
+    });
+    // Confirm delete sheet
+    var onRequestDeleteSheet = useOnRequestDeleteSheet();
+    // Sheet delete
+    var onDeleteSheet = useOnDeleteSheet({
+        sheets: sheets,
+        createHistory: createHistory,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeActiveSheet: onChangeActiveSheet,
+        enqueueGraphOperation: enqueueGraphOperation,
+        onCommand: onCommand,
+    });
+    // Show hide sheet
+    var _y = useOnShowHideSheet({
+        sheetId: activeSheetId,
+        sheets: sheets,
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+        onChangeActiveSheet: onChangeActiveSheet,
+        onCommand: onCommand,
+    }), onHideSheet = _y.onHideSheet, onShowSheet = _y.onShowSheet;
+    // Protect sheet
+    var _z = useOnProtectSheet({
+        idCreationStrategy: idCreationStrategy,
+        onChangeProtectedRanges: onChangeProtectedRanges,
+        createHistory: createHistory,
+        onCommand: onCommand,
+    }), onProtectSheet = _z.onProtectSheet, onUnProtectSheet = _z.onUnProtectSheet;
+    // Move sheet
+    var onMoveSheet = useOnMoveSheet({
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+        onCommand: onCommand,
+    });
+    // New sheet
+    var onCreateNewSheet = useOnCreateNewSheet({
+        sheets: sheets,
+        maxRowCount: maxRowCount,
+        maxColumnCount: maxColumnCount,
+        idCreationStrategy: idCreationStrategy,
+        createHistory: createHistory,
+        onChangeActiveSheet: onChangeActiveSheet,
+        onChangeSheets: onChangeSheets,
+        maxSheetCount: maxSheetCount,
+        sheetId: activeSheetId,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    // Update sheet
+    var onUpdateSheet = useOnUpdateSheet({
+        sheets: sheets,
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+    });
+    // Request add rows
+    var onRequestAddRows = useCallback(function (sheetId, additionalRowCount) {
+        return onUpdateSheet === null || onUpdateSheet === void 0 ? void 0 : onUpdateSheet(sheetId, {
+            rowCount: (rowCount !== null && rowCount !== void 0 ? rowCount : DEFAULT_ROW_COUNT) + additionalRowCount,
+        });
+    }, [rowCount, onUpdateSheet]);
+    // Duplicate sheet
+    var onDuplicateSheet = useOnDuplicateSheet({
+        locale: locale,
+        maxSheetCount: maxSheetCount,
+        sheets: sheets,
+        idCreationStrategy: idCreationStrategy,
+        createHistory: createHistory,
+        enqueueGraphOperation: enqueueGraphOperation,
+        onChangeActiveSheet: onChangeActiveSheet,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeCharts: onChangeCharts,
+        onChangeEmbeds: onChangeEmbeds,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    // Hide column
+    var onHideColumn = useOnHideColumn({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        getSelections: getSelections,
+        getActiveCell: getActiveCell,
+        onChangeActiveCell: onChangeActiveCell,
+        onChangeSelections: onChangeSelections,
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+        onCommand: onCommand,
+    });
+    // Show column
+    var onShowColumn = useOnShowColumn({
+        rowCount: rowCount,
+        onChangeActiveCell: onChangeActiveCell,
+        onChangeSelections: onChangeSelections,
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+        onCommand: onCommand,
+    });
+    // Hide row
+    var onHideRow = useOnHideRow({
+        columnCount: columnCount,
+        rowCount: rowCount,
+        getSelections: getSelections,
+        getActiveCell: getActiveCell,
+        onChangeActiveCell: onChangeActiveCell,
+        onChangeSelections: onChangeSelections,
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+        onCommand: onCommand,
+        onRowVisibilityChange: onRowVisibilityChange,
+    });
+    // Show row
+    var onShowRow = useOnShowRow({
+        columnCount: columnCount,
+        onChangeActiveCell: onChangeActiveCell,
+        onChangeSelections: onChangeSelections,
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+        onCommand: onCommand,
+        onRowVisibilityChange: onRowVisibilityChange,
+    });
+    // Outline (row/column grouping) handlers. All eight share the same
+    // shape: take a sheetId + the relevant indices, mutate metadata via
+    // immer with history saved.
+    var onGroupRows = useOnGroupRows({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    var onUngroupRows = useOnUngroupRows({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    var onCollapseRowGroup = useOnCollapseRowGroup({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    var onExpandRowGroup = useOnExpandRowGroup({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    var onGroupColumns = useOnGroupColumns({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    var onUngroupColumns = useOnUngroupColumns({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    var onCollapseColumnGroup = useOnCollapseColumnGroup({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    var onExpandColumnGroup = useOnExpandColumnGroup({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    var onSetOutlineDepth = useOnSetOutlineDepth({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onCommand: onCommand,
+    });
+    // onChange handler
+    var onChange = useOnChange({
+        tables: tables,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getDataValidationById: getDataValidationById,
+        isMergedCell: isMergedCell,
+        onChangeSheetData: onChangeSheetData,
+        onChangeTables: onChangeTables,
+        onChangeSheets: onChangeSheets,
+        enqueueCalculation: enqueueCalculation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        createHistory: createHistory,
+        getDependents: getDependents,
+        getUserEnteredValue: getUserEnteredValueStable,
+        getTextFormatRuns: getTextFormatRuns,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    // onChange batch
+    var onChangeBatch = useOnChangeBatch({
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getDataValidationById: getDataValidationById,
+        getUserEnteredValue: getUserEnteredValueStable,
+        getDependents: getDependents,
+        enqueueGraphOperation: enqueueGraphOperation,
+        getSheetName: getSheetName,
+        enqueueCalculation: enqueueCalculation,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        getFormattedValue: getFormattedValue,
+        getCellDimensions: getCellDimensions,
+        getRowHeight: getCurrentRowHeight,
+        isMergedCell: isMergedCell,
+        tables: tables,
+        createHistory: createHistory,
+        onChangeCitations: onChangeCitations,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    // onChange handler
+    var onDelete = useOnDelete({
+        locale: locale,
+        rowCount: rowCount,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getDataValidationById: getDataValidationById,
+        getDependents: getDependents,
+        getDataRowCount: getDataRowCount,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeCitations: onChangeCitations,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeActiveCell: onChangeActiveCell,
+        isArrayFormula: isArrayFormula,
+        getRowHeight: getCurrentRowHeight,
+        onCommand: onCommand,
+    });
+    // Formatting change
+    var _0 = useOnChangeFormatting({
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        getDataValidationById: getDataValidationById,
+        isMergedCell: isMergedCell,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+        getFormattedValue: getFormattedValue,
+        enqueueCalculation: enqueueCalculation,
+        getCellDimensions: getCellDimensions,
+        getRowHeight: getCurrentRowHeight,
+        onCommand: onCommand,
+    }), onChangeFormatting = _0.onChangeFormatting, onChangeBorder = _0.onChangeBorder, onRepeatFormatting = _0.onRepeatFormatting;
+    // Paint formatting
+    var _1 = usePaintFormat({
+        onChangeSelections: onChangeSelections,
+        onChangeFormatting: onChangeFormatting,
+        getEffectiveFormat: getEffectiveFormat,
+    }), isPaintFormatActive = _1.isPaintFormatActive, paintFormat = _1.paintFormat, onApplyPaintFormat = _1.onApplyPaintFormat, onSavePaintFormat = _1.onSavePaintFormat;
+    // Selection interceptor
+    // for paint format
+    var onChangeSelectionsInterceptor = useCallback(function (sheetId, selections, finishedSelection) {
+        if (isPaintFormatActive && finishedSelection) {
+            onApplyPaintFormat(sheetId, activeCell, selections);
+        }
+        else {
+            onChangeSelections(sheetId, selections);
+        }
+    }, [isPaintFormatActive, activeCell, onApplyPaintFormat, onChangeSelections]);
+    // Formatting clear
+    var onClearFormatting = useOnClearFormatting({
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        getDataValidationById: getDataValidationById,
+        onChangeSheetData: onChangeSheetData,
+        createHistory: createHistory,
+        onCommand: onCommand,
+    });
+    // Locale change - regenerate formatted values and normalize validation rules
+    var onChangeLocale = useOnLocaleChange({
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        onChangeSheetData: onChangeSheetData,
+        createHistory: createHistoryWithoutPointer,
+        dataValidations: dataValidations,
+        onChangeDataValidations: onChangeDataValidations,
+        conditionalFormats: conditionalFormats,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+    });
+    // Merge unmerge
+    var _2 = useOnMergeUnMergeCells({
+        locale: locale,
+        merges: merges,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        onChangeSelections: onChangeSelections,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeSheetData: onChangeSheetData,
+        enqueueCalculation: enqueueCalculation,
+        onCommand: onCommand,
+    }), onMergeCells = _2.onMergeCells, onUnMergeCells = _2.onUnMergeCells;
+    // Resize
+    var onResize = useOnResize({
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+        getActiveCell: getActiveCell,
+        getCellDimensions: getCellDimensions,
+        getRowHeight: getFinalRowHeight,
+        isMergedCell: isMergedCell,
+        onCommand: onCommand,
+    });
+    // Decimals
+    // Formatting change
+    var onChangeDecimals = useOnChangeDecimals({
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        getDataValidationById: getDataValidationById,
+        onChangeSheetData: onChangeSheetData,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        onCommand: onCommand,
+    });
+    // Wrap user-supplied or default getAutoFillValues so it always sees
+    // the host-supplied customAutofillLists, without making consumers
+    // remember to thread the param themselves.
+    var getAutoFillValues = useCallback(function (props) {
+        var _a;
+        return rawGetAutoFillValues(__assign(__assign({}, props), { customAutofillLists: (_a = props.customAutofillLists) !== null && _a !== void 0 ? _a : customAutofillLists }));
+    }, [rawGetAutoFillValues, customAutofillLists]);
+    // Fill
+    var onFill = useOnFill({
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getDataValidationById: getDataValidationById,
+        getCellData: getCellData,
+        getAutoFillValues: getAutoFillValues,
+        getEffectiveValue: getEffectiveValue,
+        getFormattedValue: getFormattedValue,
+        getSheetName: getSheetName,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        onChangeSheetData: onChangeSheetData,
+        onChangeDataValidations: onChangeDataValidations,
+        createHistory: createHistory,
+        onCommand: onCommand,
+    });
+    // Delete row
+    var onDeleteRow = useOnDeleteRow({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getActiveCell: getActiveCell,
+        getSelections: getSelections,
+        getDependents: getDependents,
+        getGraphNodes: getGraphNodes,
+        getGraphNodesInSheet: getGraphNodesInSheet,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeSheetData: onChangeSheetData,
+        onChangeActiveCell: onChangeActiveCell,
+        onChangeSelections: onChangeSelections,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        onChangeCitations: onChangeCitations,
+        onChangePivotTables: onChangePivotTables,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+    });
+    // Delete row
+    var onDeleteColumn = useOnDeleteColumn({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getSelections: getSelections,
+        getActiveCell: getActiveCell,
+        getDependents: getDependents,
+        getGraphNodes: getGraphNodes,
+        getGraphNodesInSheet: getGraphNodesInSheet,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeSheetData: onChangeSheetData,
+        onChangeActiveCell: onChangeActiveCell,
+        onChangeSelections: onChangeSelections,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        onChangeCitations: onChangeCitations,
+        onChangePivotTables: onChangePivotTables,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+    });
+    // Delete cells shift up
+    var onDeleteCellsShiftUp = useOnDeleteCellsShiftUp({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getActiveCell: getActiveCell,
+        getSelections: getSelections,
+        getDependents: getDependents,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeSheetData: onChangeSheetData,
+        onCommand: onCommand,
+    });
+    // Delete cells shift left
+    var onDeleteCellsShiftLeft = useOnDeleteCellsShiftLeft({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getActiveCell: getActiveCell,
+        getSelections: getSelections,
+        getDependents: getDependents,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeSheetData: onChangeSheetData,
+        onCommand: onCommand,
+    });
+    // Insert cells shift right
+    var onInsertCellsShiftRight = useOnInsertCellsShiftRight({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getActiveCell: getActiveCell,
+        getSelections: getSelections,
+        getDependents: getDependents,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeSheetData: onChangeSheetData,
+        onCommand: onCommand,
+    });
+    // Delete cells shift up
+    var onInsertCellsShiftDown = useOnInsertCellsShiftDown({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getActiveCell: getActiveCell,
+        getSelections: getSelections,
+        getDependents: getDependents,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeSheetData: onChangeSheetData,
+        onCommand: onCommand,
+    });
+    // Insert row
+    var onInsertRow = useOnInsertRow({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        maxRowCount: maxRowCount,
+        cellXfsRegistry: cellXfsRegistry,
+        getActiveCell: getActiveCell,
+        getSelections: getSelections,
+        getDependents: getDependents,
+        getGraphNodes: getGraphNodes,
+        getGraphNodesInSheet: getGraphNodesInSheet,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeSheetData: onChangeSheetData,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        onChangeCitations: onChangeCitations,
+        onChangePivotTables: onChangePivotTables,
+        onChangeTables: onChangeTables,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+    });
+    // Insert column
+    var onInsertColumn = useOnInsertColumn({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        tables: tables,
+        maxColumnCount: maxColumnCount,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getDependents: getDependents,
+        getGraphNodes: getGraphNodes,
+        getGraphNodesInSheet: getGraphNodesInSheet,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeSheetData: onChangeSheetData,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        onChangeCitations: onChangeCitations,
+        onChangePivotTables: onChangePivotTables,
+        getActiveCell: getActiveCell,
+        getSelections: getSelections,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    // Move columns
+    var onMoveColumns = useOnMoveColumns({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        getActiveCell: getActiveCell,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeSheetData: onChangeSheetData,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        getDependents: getDependents,
+        getDataRowCount: getDataRowCount,
+        onCommand: onCommand,
+    });
+    // Move rows
+    var onMoveRows = useOnMoveRows({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        getActiveCell: getActiveCell,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeSheetData: onChangeSheetData,
+        onChangeTables: onChangeTables,
+        onChangeNamedRanges: onChangeNamedRanges,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        getDependents: getDependents,
+        getNonEmptyColumnCount: getNonEmptyColumnCount,
+        onCommand: onCommand,
+    });
+    // Move selection
+    var onMoveSelection = useOnMoveSelection({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        createHistory: createHistory,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeNamedRanges: onChangeNamedRanges,
+        onChangeDataValidations: onChangeDataValidations,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangePivotTables: onChangePivotTables,
+        getDependents: getDependents,
+        getActiveCell: getActiveCell,
+        isArrayFormula: isArrayFormula,
+        tables: tables,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        onCommand: onCommand,
+    });
+    // Sort column
+    var onSortColumn = useOnSortColumn({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        sharedStringRegistry: sharedStringRegistry,
+        onChangeSheetData: onChangeSheetData,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        enqueueGraphOperation: enqueueGraphOperation,
+        createHistory: createHistory,
+        isHiddenRow: isHiddenRow,
+        getDependents: getDependents,
+        getFrozenRowCount: getFrozenRowCount,
+        getSheetName: getSheetName,
+        getEffectiveFormat: getEffectiveFormat,
+        theme: theme,
+        onCommand: onCommand,
+    });
+    // Sort range
+    var onSortTable = useOnSortTable({
+        locale: locale,
+        sharedStringRegistry: sharedStringRegistry,
+        onChangeSheetData: onChangeSheetData,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        getDependents: getDependents,
+        createHistory: createHistory,
+        onChangeTables: onChangeTables,
+        onChangeSheets: onChangeSheets,
+        getActiveCell: getActiveCell,
+        isHiddenRow: isHiddenRow,
+        getFrozenRowCount: getFrozenRowCount,
+        getSheetName: getSheetName,
+        getEffectiveFormat: getEffectiveFormat,
+        theme: theme,
+        onCommand: onCommand,
+    });
+    // Sort range
+    var _3 = __read(useOnFilterTable({
+        theme: theme,
+        createHistory: createHistory,
+        onChangeTables: onChangeTables,
+        onChangeSheets: onChangeSheets,
+        getEffectiveValue: getEffectiveValue,
+        getFormattedValue: getFormattedValue,
+        getEffectiveFormat: getEffectiveFormat,
+        conditionalFormats: conditionalFormats,
+        getActiveCell: getActiveCell,
+        getSheetName: getSheetName,
+        onRequestCalculate: onRequestCalculateWithoutFormatting,
+        onCommand: onCommand,
+        onRowVisibilityChange: onRowVisibilityChange,
+    }), 2), onFilterTable = _3[0], onDeleteFilter = _3[1];
+    // Resize table
+    var onResizeTable = useOnResizeTable({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        tables: tables,
+        basicFilter: basicFilter,
+        getActiveCell: getActiveCell,
+        createHistory: createHistory,
+        onChangeTables: onChangeTables,
+        onChangeSheetData: onChangeSheetData,
+        enqueueCalculation: enqueueCalculation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        getFormattedValue: getFormattedValue,
+        getDependents: getDependents,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    // Copy
+    var onCopy = useOnCopy({
+        theme: theme,
+        merges: merges,
+        tables: tables,
+        bandedRanges: bandedRanges,
+        cellXfs: cellXfs,
+        sharedStrings: sharedStrings,
+        getEffectiveFormat: getEffectiveFormat,
+        getFormattedValue: getFormattedValue,
+        getColumnWidth: getColumnWidth,
+        getRowHeight: getRowHeight,
+        isColumnHidden: isColumnHidden,
+        isHiddenRow: isHiddenRow,
+        getCellData: getCellData,
+    });
+    // Paste
+    var onPaste = useOnPaste({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        locale: locale,
+        sheetData: sheetData,
+        getDataValidationById: getDataValidationById,
+        preserveFormatting: preserveFormattingOnPaste,
+        maxColumnCount: maxColumnCount,
+        maxRowCount: maxRowCount,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        tables: tables,
+        isHiddenByFilterRow: isHiddenByFilterRow,
+        onRequestFonts: onRequestFonts,
+        idCreationStrategy: idCreationStrategy,
+        getDependents: getDependents,
+        getActiveCell: getActiveCell,
+        getSheetName: getSheetName,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        enqueueGraphOperation: enqueueGraphOperation,
+        createHistory: createHistory,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeSelections: onChangeSelections,
+        onChangeTables: onChangeTables,
+        onChangeEmbeds: onChangeEmbeds,
+        onChangeActiveCell: onChangeActiveCell,
+        getUserEnteredValue: getUserEnteredValue,
+        onChangeDataValidations: onChangeDataValidations,
+        onError: onError,
+        citations: citations,
+        onChangeCitations: onChangeCitations,
+        sanitizeHtml: sanitizeHtml,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    // Create table
+    var _4 = useOnTable({
+        locale: locale,
+        rowCount: rowCount,
+        columnCount: columnCount,
+        tables: tables,
+        basicFilter: basicFilter,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        theme: theme,
+        idCreationStrategy: idCreationStrategy,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        onChangeSheets: onChangeSheets,
+        onChangeSheetData: onChangeSheetData,
+        createHistory: createHistory,
+        onChangeTables: onChangeTables,
+        getFormattedValue: getFormattedValue,
+        getEffectiveValue: getEffectiveValue,
+        onRequestCalculate: onRequestCalculate,
+        getDependents: getDependents,
+        enqueueGraphOperation: enqueueGraphOperation,
+        getContentfulRangeAroundCell: getContentfulRangeAroundCell,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    }), onCreateTable = _4.onCreateTable, onRemoveTable = _4.onRemoveTable, onUpdateTable = _4.onUpdateTable, onCreateBasicFilter = _4.onCreateBasicFilter, onInsertTableColumn = _4.onInsertTableColumn, onDeleteTableColumn = _4.onDeleteTableColumn;
+    // Insert table row
+    var onInsertTableRow = useOnInsertTableRow({
+        rowCount: rowCount,
+        columnCount: columnCount,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueStructureChange: enqueueStructureChange,
+        getActiveCell: getActiveCell,
+        getDependents: getDependents,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+    });
+    // Delete table row
+    var onDeleteTableRow = useOnDeleteTableRow({
+        columnCount: columnCount,
+        rowCount: rowCount,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        enqueueStructureChange: enqueueStructureChange,
+        getDependents: getDependents,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeDataValidations: onChangeDataValidations,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+    });
+    // Fill range
+    var onFillRange = useOnFillRange({
+        onFill: onFill,
+    });
+    // Embeds
+    var _5 = useOnEmbeds({
+        onChangeEmbeds: onChangeEmbeds,
+        createHistory: createHistory,
+        onCommand: onCommand,
+    }), onDeleteEmbed = _5.onDeleteEmbed, onMoveEmbed = _5.onMoveEmbed, onResizeEmbed = _5.onResizeEmbed, onCreateEmbed = _5.onCreateEmbed, onRequestEditEmbed = _5.onRequestEditEmbed;
+    // Slicers
+    var _6 = useSlicers({
+        onChangeSlicers: onChangeSlicers,
+        createHistory: createHistory,
+        onCommand: onCommand,
+    }), onDeleteSlicer = _6.onDeleteSlicer, onMoveSlicer = _6.onMoveSlicer, onResizeSlicer = _6.onResizeSlicer, onCreateSlicer = _6.onCreateSlicer, onUpdateSlicer = _6.onUpdateSlicer, onRequestEditSlicer = _6.onRequestEditSlicer;
+    // Show modal dialog for table editor
+    var onRequestEditTable = useOnRequestEditTable();
+    // Show modal dialog for table editor
+    var onRequestDefineNamedRange = useOnRequestDefineNamedRange({
+        namedRanges: namedRanges,
+    });
+    // Show modal dialog for table editor
+    var onRequestUpdateNamedRange = useOnRequestUpdateNamedRange();
+    // Update named range
+    var onUpdateNamedRange = useOnUpdateNamedRange({
+        locale: locale,
+        getDependents: getDependents,
+        getActiveCell: getActiveCell,
+        enqueueCalculation: enqueueCalculation,
+        createHistory: createHistory,
+        onChangeNamedRanges: onChangeNamedRanges,
+        onChangeSheetData: onChangeSheetData,
+        onCommand: onCommand,
+    });
+    // Update named range
+    var onCreateNamedRange = useOnCreateNamedRange({
+        enqueueCalculation: enqueueCalculation,
+        createHistory: createHistory,
+        onChangeNamedRanges: onChangeNamedRanges,
+        onCommand: onCommand,
+    });
+    // Delete named range
+    var onDeleteNamedRange = useOnDeleteNamedRange({
+        getDependents: getDependents,
+        enqueueCalculation: enqueueCalculation,
+        createHistory: createHistory,
+        onChangeNamedRanges: onChangeNamedRanges,
+        onCommand: onCommand,
+    });
+    // Freeze rows and columns
+    var _7 = __read(useOnFreeze({
+        createHistory: createHistory,
+        onChangeSheets: onChangeSheets,
+        onChangeEmbeds: onChangeEmbeds,
+        onChangeCharts: onChangeCharts,
+        onCommand: onCommand,
+    }), 2), onFreezeRow = _7[0], onFreezeColumn = _7[1];
+    // Request insert image
+    var onRequestInsertImage = useOnRequestInsertImage();
+    // Insert image
+    var onInsertImage = useOnInsertImage({
+        locale: locale,
+        idCreationStrategy: idCreationStrategy,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        onChangeSheetData: onChangeSheetData,
+        onChangeEmbeds: onChangeEmbeds,
+        onCommand: onCommand,
+    });
+    // Request insert image
+    var onRequestInsertLink = useOnRequestInsertLink();
+    // Insert link
+    var _8 = __read(useOnInsertLink({
+        locale: locale,
+        sharedStringRegistry: sharedStringRegistry,
+        cellXfsRegistry: cellXfsRegistry,
+        getSheetId: getSheetId,
+        getDataValidationById: getDataValidationById,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        onChangeSheetData: onChangeSheetData,
+        onCommand: onCommand,
+    }), 3), onInsertLink = _8[0], onRemoveLink = _8[1], onSelectLink = _8[2];
+    // Insert checkbox
+    var onInsertCheckbox = useOnInsertCheckbox({
+        locale: locale,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        onChangeSheetData: onChangeSheetData,
+        onCommand: onCommand,
+    });
+    // Banded range
+    var _9 = useOnBandedRanges({
+        createHistory: createHistory,
+        onChangeBandedRanges: onChangeBandedRanges,
+        onCommand: onCommand,
+    }), onAddBandedRange = _9.onAddBandedRange, onRemoveBandedRange = _9.onRemoveBandedRange;
+    // Notes
+    var onUpdateNote = useOnUpdateNote({
+        locale: locale,
+        createHistory: createHistory,
+        onChangeSheetData: onChangeSheetData,
+        onCommand: onCommand,
+    });
+    // Insert note
+    var onInsertNote = useOnInsertNote();
+    // Sort range
+    var onSortRange = useOnSortRange({
+        locale: locale,
+        sharedStringRegistry: sharedStringRegistry,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        enqueueGraphOperation: enqueueGraphOperation,
+        onChangeSheetData: onChangeSheetData,
+        getDependents: getDependents,
+        isHiddenRow: isHiddenRow,
+        getFrozenRowCount: getFrozenRowCount,
+        getSheetName: getSheetName,
+        getEffectiveFormat: getEffectiveFormat,
+        theme: theme,
+    });
+    // Protect range
+    var _10 = useOnProtectRange({
+        idCreationStrategy: idCreationStrategy,
+        createHistory: createHistory,
+        onChangeProtectedRanges: onChangeProtectedRanges,
+        onCommand: onCommand,
+    }), onProtectRange = _10.onProtectRange, onUnProtectRange = _10.onUnProtectRange;
+    // Indent
+    var _11 = useIndent({
+        locale: locale,
+        createHistory: createHistory,
+        onChangeSheetData: onChangeSheetData,
+        enqueueCalculation: enqueueCalculation,
+        cellXfsRegistry: cellXfsRegistry,
+        getDataValidationById: getDataValidationById,
+        onCommand: onCommand,
+    }), onIncreaseIndent = _11.onIncreaseIndent, onDecreaseIndent = _11.onDecreaseIndent, onChangeIndent = _11.onChangeIndent;
+    var onAutoResize = useOnAutoResize({
+        onChangeSheets: onChangeSheets,
+        createHistory: createHistory,
+        getActiveCell: getActiveCell,
+        getRowHeight: getFinalRowHeight,
+        getColumnWidth: getFinalColumnWidth,
+        getCellDimensions: getCellDimensions,
+        isMergedCell: isMergedCell,
+        onCommand: onCommand,
+    });
+    // Request format cells
+    var onRequestFormatCells = useOnRequestFormatCells();
+    // Resize row, col dialog
+    var onRequestResize = useOnRequestResize();
+    // Insert time
+    var onInsertTime = useOnInsertTime({
+        locale: locale,
+    });
+    // Insert date
+    var onInsertDate = useOnInsertDate({
+        locale: locale,
+    });
+    // Insert datetime
+    var onInsertDateTime = useOnInsertDateTime({
+        locale: locale,
+    });
+    // Insert date
+    var onInsertAutoSum = useOnInsertAutoSum({
+        getEffectiveFormat: getEffectiveFormat,
+        getEffectiveValue: getEffectiveValue,
+        isHiddenRow: isHiddenRow,
+    });
+    // Request conditional format
+    var onRequestConditionalFormat = useOnRequestConditionalFormat();
+    var getEffectiveValuesFromRange = useGetEffectiveValuesFromRange();
+    /**
+     * Batch stream
+     */
+    var onChangeBatchStream = useOnChangeBatchStream({
+        locale: locale,
+        getDataValidationById: getDataValidationById,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        getEffectiveValuesFromRange: getEffectiveValuesFromRange,
+        getFormattedValue: getFormattedValue,
+        getCellDimensions: getCellDimensions,
+        getRowHeight: getCurrentRowHeight,
+        isMergedCell: isMergedCell,
+        onRequestCalculate: onRequestCalculateWithoutFormatting,
+        getPrecedentsFromFormulaString: getPrecedentsFromFormulaString,
+        getSheetId: getSheetId,
+        cellXfsRegistry: cellXfsRegistry,
+        enqueueCalculation: enqueueCalculation,
+        onStreamStart: onStreamStart,
+        onStreamProgress: onStreamProgress,
+        onStreamEnd: onStreamEnd,
+    });
+    // Conditional format actions
+    var _12 = useConditionalFormattingRules({
+        enqueueCalculation: enqueueCalculation,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        createHistory: createHistory,
+    }), onCreateConditionalFormattingRule = _12.onCreateConditionalFormattingRule, onUpdateConditionalFormattingRule = _12.onUpdateConditionalFormattingRule, onDeleteConditionalFormattingRule = _12.onDeleteConditionalFormattingRule, onPreviewConditionalFormattingRule = _12.onPreviewConditionalFormattingRule;
+    // Data validations
+    var _13 = useDataValidationRules({
+        locale: locale,
+        onChangeDataValidations: onChangeDataValidations,
+        onChangeSheetData: onChangeSheetData,
+        enqueueCalculation: enqueueCalculation,
+        createHistory: createHistory,
+        getEffectiveValuesFromRange: getEffectiveValuesFromRange,
+        getSheetName: getSheetName,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+    }), onCreateDataValidationRule = _13.onCreateDataValidationRule, onUpdateDataValidationRule = _13.onUpdateDataValidationRule, onDeleteDataValidationRule = _13.onDeleteDataValidationRule, onDeleteDataValidationRules = _13.onDeleteDataValidationRules;
+    // Request datavalidation
+    var onRequestDataValidation = useOnRequestDataValidation({
+        onCreateDataValidationRule: onCreateDataValidationRule,
+    });
+    // Find replace
+    var onFindReplace = useOnFindReplace({
+        locale: locale,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        enqueueStructureChange: enqueueStructureChange,
+        onChangeSheetData: onChangeSheetData,
+        sharedStringRegistry: sharedStringRegistry,
+        onCommand: onCommand,
+    });
+    // Read excel file
+    var _14 = useOnImportExcelFile({
+        enableExcelImportHistory: enableExcelImportHistory,
+        onRequestFonts: onRequestFonts,
+        onChangeHistory: onChangeHistory,
+        onChangeCharts: onChangeCharts,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeTables: onChangeTables,
+        onChangeEmbeds: onChangeEmbeds,
+        onChangeConditionalFormats: onChangeConditionalFormats,
+        onChangeCellXfs: onChangeCellXfs,
+        onChangeNamedRanges: onChangeNamedRanges,
+        onChangeDataValidations: onChangeDataValidations,
+        onCreateDataValidationRule: onCreateDataValidationRule,
+        onChangeTheme: onChangeTheme,
+        onClearHistory: onClearHistory,
+        evaluateConditionalFormatting: evaluateConditionalFormatting,
+        evaluateDataValidations: evaluateDataValidations,
+        clearRangeCache: clearRangeCache,
+        onChangeSharedStrings: onChangeSharedStrings,
+        onChangeSlicers: onChangeSlicers,
+        // Phase D1 — wire pivot tables through the import path
+        onChangePivotTables: onChangePivotTables,
+        onConfirm: onConfirm,
+        onPrompt: onPrompt,
+    }), importExcelFile = _14.importExcelFile, isImportingExcelfile = _14.isImportingExcelfile, generateStatePatches = _14.generateStatePatches;
+    // Read csv file
+    var importCSVFile = useOnImportCSV({
+        sheetId: activeSheetId,
+        activeCell: activeCell,
+        rowCount: rowCount,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeSharedStrings: onChangeSharedStrings,
+        onChangeCellXfs: onChangeCellXfs,
+        createHistory: createHistory,
+        sharedStringRegistry: sharedStringRegistry,
+        enabledSharedStrings: sharedStringRegistry.active,
+        enableCellXfsRegistry: cellXfsRegistry.active,
+        enqueueCalculation: enqueueCalculation,
+        clearRangeCache: clearRangeCache,
+        getDependents: getDependents,
+    }).importCSVFile;
+    // Legacy Read csv file
+    var importCSVFileLegacy = useOnImportCSVLegacy({
+        sheetId: activeSheetId,
+        activeCell: activeCell,
+        rowCount: rowCount,
+        onChangeSheetData: onChangeSheetData,
+        onChangeSheets: onChangeSheets,
+        onChangeSharedStrings: onChangeSharedStrings,
+        createHistory: createHistory,
+        sharedStringRegistry: sharedStringRegistry,
+        enabledSharedStrings: sharedStringRegistry.active,
+        enqueueCalculation: enqueueCalculation,
+        getDependents: getDependents,
+    }).importCSVFile;
+    // Drag n drop files
+    var _15 = useOnDragnDrop({
+        sheetId: activeSheetId,
+        locale: locale,
+        fileSizeLimit: fileSizeLimit,
+        enableExcelfileDragDrop: enableExcelfileDragDrop,
+        importExcelFile: importExcelFile,
+        importCSVFile: importCSVFile,
+        onChangeActiveCell: onChangeActiveCell,
+        getActiveCell: getActiveCell,
+        onChangeSheetData: onChangeSheetData,
+        onChangeEmbeds: onChangeEmbeds,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        onError: onError,
+        calculateNow: calculateNow,
+        onIterativeCalculationEnabled: onIterativeCalculationEnabled,
+        enable: enableDragnDrop,
+        enableCellXfsRegistry: cellXfsRegistry.active,
+        enabledSharedStrings: sharedStringRegistry.active,
+        onConfirm: onConfirm,
+        onPrompt: onPrompt,
+    }), onDragOver = _15.onDragOver, onDrop = _15.onDrop, onInsertFile = _15.onInsertFile;
+    // Split text to columns
+    var onSplitTextToColumns = useSplitTextToColumns({
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        onChangeSheetData: onChangeSheetData,
+        locale: locale,
+        getFormattedValue: getFormattedValue,
+        onChangeSelections: onChangeSelections,
+        onCommand: onCommand,
+    });
+    // Remove duplicates
+    var onRemoveDuplicates = useOnRemoveDuplicates({
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        onChangeSheetData: onChangeSheetData,
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        getFormattedValue: getFormattedValue,
+        onCommand: onCommand,
+    });
+    // Trace dependents and precedents
+    var _16 = useOnTraceDependentsPrecedents({
+        getDependents: getDependents,
+        getPrecedents: getPrecedents,
+    }), arrows = _16.arrows, onRemoveArrows = _16.onRemoveArrows, onTraceDependents = _16.onTraceDependents, onTracePrecedents = _16.onTracePrecedents;
+    // Comments
+    var _17 = useComments({
+        onChangeSheetData: onChangeSheetData,
+        createHistory: createHistory,
+        locale: locale,
+    }), onInsertComment = _17.onInsertComment, onRemoveComment = _17.onRemoveComment;
+    // Citations
+    var _18 = useCitations({
+        onChangeSheetData: onChangeSheetData,
+        onChangeCitations: onChangeCitations,
+        createHistory: createHistory,
+        locale: locale,
+    }), onCreateCitation = _18.onCreateCitation, onUpdateCitation = _18.onUpdateCitation, onRemoveCitationFromCell = _18.onRemoveCitationFromCell, onDeleteCitation = _18.onDeleteCitation;
+    return {
+        activeCellBySheetId: activeCellBySheetId,
+        selectionsBySheetId: selectionsBySheetId,
+        activeCell: activeCell,
+        activeSheetId: activeSheetId,
+        selections: selections,
+        showGridLines: showGridLines,
+        showRowColHeaders: showRowColHeaders,
+        zoomScale: zoomScale,
+        rowCount: rowCount,
+        columnCount: columnCount,
+        frozenColumnCount: frozenColumnCount,
+        frozenRowCount: frozenRowCount,
+        rowMetadata: rowMetadata,
+        columnMetadata: columnMetadata,
+        merges: merges,
+        bandedRanges: bandedRanges,
+        basicFilter: basicFilter,
+        spreadsheetColors: spreadsheetColors,
+        isDarkMode: isDarkMode,
+        canUndo: canUndo,
+        canRedo: canRedo,
+        getDataRowCount: getDataRowCount,
+        getDataColumnCount: getDataColumnCount,
+        onRedo: onRedo,
+        onUndo: onUndo,
+        applyPatch: applyPatch,
+        getCellData: getCellData,
+        getMentionsFromCell: getMentionsFromCell,
+        getTextFormatRuns: getTextFormatRuns,
+        getSheetName: getSheetName,
+        getSheetId: getSheetId,
+        getUserEnteredFormat: getUserEnteredFormat,
+        getEffectiveFormat: getEffectiveFormat,
+        getSeriesValuesFromRange: getSeriesValuesFromRange,
+        getDomainValuesFromRange: getDomainValuesFromRange,
+        getUserEnteredValuesFromRange: getUserEnteredValuesFromRange,
+        getFormattingFromRange: getFormattingFromRange,
+        getFormulasFromRange: getFormulasFromRange,
+        getEffectiveValue: getEffectiveValue,
+        getUserEnteredValue: getUserEnteredValue,
+        getFormattedValue: getFormattedValue,
+        createHistory: createHistory,
+        onRequestCalculate: onRequestCalculate,
+        enqueueCalculation: enqueueCalculation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        addFormulaToGraph: addFormulaToGraph,
+        calculateNow: calculateNow,
+        evaluateConditionalFormatting: evaluateConditionalFormatting,
+        evaluateConditionalFormattingForViewport: evaluateConditionalFormattingForViewport,
+        evaluateDataValidations: evaluateDataValidations,
+        evaluateDataValidationsForViewport: evaluateDataValidationsForViewport,
+        clearEvaluatedCellsCache: clearEvaluatedCellsCache,
+        onViewPortChange: onViewPortChange,
+        reevaluateDerivationsForCells: reevaluateDerivationsForCells,
+        onChangeActiveCell: onChangeActiveCell,
+        onChangeSelections: onChangeSelectionsInterceptor,
+        onChangeActiveSheet: onChangeActiveSheet,
+        onSelectNextSheet: onSelectNextSheet,
+        onSelectPreviousSheet: onSelectPreviousSheet,
+        onChange: onChange,
+        onChangeBatch: onChangeBatch,
+        onChangeBatchStream: onChangeBatchStream,
+        onChangeFormatting: onChangeFormatting,
+        onRepeatFormatting: onRepeatFormatting,
+        onClearFormatting: onClearFormatting,
+        onMergeCells: onMergeCells,
+        onUnMergeCells: onUnMergeCells,
+        onResize: onResize,
+        onChangeBorder: onChangeBorder,
+        onChangeDecimals: onChangeDecimals,
+        onChangeSheetTabColor: onChangeSheetTabColor,
+        onRenameSheet: onRenameSheet,
+        onRequestDeleteSheet: onRequestDeleteSheet,
+        onDeleteSheet: onDeleteSheet,
+        onDelete: onDelete,
+        onHideSheet: onHideSheet,
+        onShowSheet: onShowSheet,
+        onProtectSheet: onProtectSheet,
+        onUnProtectSheet: onUnProtectSheet,
+        onMoveSheet: onMoveSheet,
+        onCreateNewSheet: onCreateNewSheet,
+        onUpdateSheet: onUpdateSheet,
+        onDuplicateSheet: onDuplicateSheet,
+        onHideColumn: onHideColumn,
+        onShowColumn: onShowColumn,
+        onHideRow: onHideRow,
+        onShowRow: onShowRow,
+        onGroupRows: onGroupRows,
+        onUngroupRows: onUngroupRows,
+        onCollapseRowGroup: onCollapseRowGroup,
+        onExpandRowGroup: onExpandRowGroup,
+        onGroupColumns: onGroupColumns,
+        onUngroupColumns: onUngroupColumns,
+        onCollapseColumnGroup: onCollapseColumnGroup,
+        onExpandColumnGroup: onExpandColumnGroup,
+        onSetOutlineDepth: onSetOutlineDepth,
+        onFill: onFill,
+        onFillRange: onFillRange,
+        onMoveEmbed: onMoveEmbed,
+        onResizeEmbed: onResizeEmbed,
+        onDeleteEmbed: onDeleteEmbed,
+        onCreateEmbed: onCreateEmbed,
+        onRequestEditEmbed: onRequestEditEmbed,
+        onMoveSlicer: onMoveSlicer,
+        onResizeSlicer: onResizeSlicer,
+        onDeleteSlicer: onDeleteSlicer,
+        onCreateSlicer: onCreateSlicer,
+        onUpdateSlicer: onUpdateSlicer,
+        onRequestEditSlicer: onRequestEditSlicer,
+        onDeleteRow: onDeleteRow,
+        onDeleteColumn: onDeleteColumn,
+        onDeleteCellsShiftUp: onDeleteCellsShiftUp,
+        onDeleteCellsShiftLeft: onDeleteCellsShiftLeft,
+        onInsertCellsShiftRight: onInsertCellsShiftRight,
+        onInsertCellsShiftDown: onInsertCellsShiftDown,
+        onInsertRow: onInsertRow,
+        onInsertColumn: onInsertColumn,
+        onMoveColumns: onMoveColumns,
+        onMoveRows: onMoveRows,
+        onMoveSelection: onMoveSelection,
+        onSortColumn: onSortColumn,
+        onSortTable: onSortTable,
+        onFilterTable: onFilterTable,
+        onDeleteFilter: onDeleteFilter,
+        onResizeTable: onResizeTable,
+        onInsertTableColumn: onInsertTableColumn,
+        onInsertTableRow: onInsertTableRow,
+        onDeleteTableColumn: onDeleteTableColumn,
+        onDeleteTableRow: onDeleteTableRow,
+        onCopy: onCopy,
+        onPaste: onPaste,
+        onCreateBasicFilter: onCreateBasicFilter,
+        onCreateTable: onCreateTable,
+        onRemoveTable: onRemoveTable,
+        onRequestEditTable: onRequestEditTable,
+        onUpdateTable: onUpdateTable,
+        onRequestDefineNamedRange: onRequestDefineNamedRange,
+        onRequestUpdateNamedRange: onRequestUpdateNamedRange,
+        onUpdateNamedRange: onUpdateNamedRange,
+        onCreateNamedRange: onCreateNamedRange,
+        onDeleteNamedRange: onDeleteNamedRange,
+        onDragOver: onDragOver,
+        onDrop: onDrop,
+        onInsertFile: onInsertFile,
+        onFreezeColumn: onFreezeColumn,
+        onFreezeRow: onFreezeRow,
+        onChangeSpreadsheetTheme: onChangeSpreadsheetTheme,
+        onAddBandedRange: onAddBandedRange,
+        onRemoveBandedRange: onRemoveBandedRange,
+        onUpdateNote: onUpdateNote,
+        onInsertNote: onInsertNote,
+        onSortRange: onSortRange,
+        onProtectRange: onProtectRange,
+        onUnProtectRange: onUnProtectRange,
+        getNonEmptyRowCount: getNonEmptyRowCount,
+        getNonEmptyColumnCount: getNonEmptyColumnCount,
+        getSheetRowCount: getSheetRowCount,
+        getSheetColumnCount: getSheetColumnCount,
+        onIncreaseIndent: onIncreaseIndent,
+        onDecreaseIndent: onDecreaseIndent,
+        onChangeIndent: onChangeIndent,
+        onRequestResize: onRequestResize,
+        onAutoResize: onAutoResize,
+        getColumnarDataFromRange: getColumnarDataFromRange,
+        onInsertTime: onInsertTime,
+        onInsertDate: onInsertDate,
+        onInsertDateTime: onInsertDateTime,
+        onRequestInsertLink: onRequestInsertLink,
+        onInsertLink: onInsertLink,
+        onRemoveLink: onRemoveLink,
+        onSelectLink: onSelectLink,
+        onRequestInsertImage: onRequestInsertImage,
+        onInsertImage: onInsertImage,
+        onInsertCheckbox: onInsertCheckbox,
+        onRequestFormatCells: onRequestFormatCells,
+        onRequestConditionalFormat: onRequestConditionalFormat,
+        onCreateConditionalFormattingRule: onCreateConditionalFormattingRule,
+        onUpdateConditionalFormattingRule: onUpdateConditionalFormattingRule,
+        onDeleteConditionalFormattingRule: onDeleteConditionalFormattingRule,
+        onPreviewConditionalFormattingRule: onPreviewConditionalFormattingRule,
+        onRequestDataValidation: onRequestDataValidation,
+        onDeleteDataValidationRules: onDeleteDataValidationRules,
+        onDeleteDataValidationRule: onDeleteDataValidationRule,
+        onCreateDataValidationRule: onCreateDataValidationRule,
+        onUpdateDataValidationRule: onUpdateDataValidationRule,
+        getDependencyGraph: getDependencyGraph,
+        updateDependencyGraph: updateDependencyGraph,
+        onFindReplace: onFindReplace,
+        onInsertAutoSum: onInsertAutoSum,
+        // cell format registry
+        cellXfsRegistry: cellXfsRegistry,
+        onChangeCellXfs: onChangeCellXfs,
+        // shared strings registry
+        sharedStringRegistry: sharedStringRegistry,
+        // Import excel file
+        importExcelFile: importExcelFile,
+        isImportingExcelfile: isImportingExcelfile,
+        generateStatePatches: generateStatePatches,
+        // Import csv
+        importCSVFile: importCSVFile,
+        importCSVFileLegacy: importCSVFileLegacy,
+        // Paint format
+        paintFormat: paintFormat,
+        onSavePaintFormat: onSavePaintFormat,
+        isPaintFormatActive: isPaintFormatActive,
+        onApplyPaintFormat: onApplyPaintFormat,
+        // Sheet properties
+        getSheetProperties: getSheetProperties,
+        getEffectiveExtendedValue: getEffectiveExtendedValue,
+        getUserEnteredExtendedValue: getUserEnteredExtendedValue,
+        // Error value
+        getErrorValue: getErrorValue,
+        // Split
+        onSplitTextToColumns: onSplitTextToColumns,
+        // Remove duplicates
+        onRemoveDuplicates: onRemoveDuplicates,
+        // Add rows
+        onRequestAddRows: onRequestAddRows,
+        // Dependents
+        getDependents: getDependents,
+        // Precedents
+        getPrecedents: getPrecedents,
+        // Data validation
+        getDataValidation: getDataValidation,
+        // Trace dependents and precendents
+        arrows: arrows,
+        onRemoveArrows: onRemoveArrows,
+        onTraceDependents: onTraceDependents,
+        onTracePrecedents: onTracePrecedents,
+        onClearHistory: onClearHistory,
+        // Locale change
+        onChangeLocale: onChangeLocale,
+        // Comments
+        onInsertComment: onInsertComment,
+        onRemoveComment: onRemoveComment,
+        // Citations
+        onCreateCitation: onCreateCitation,
+        onUpdateCitation: onUpdateCitation,
+        onRemoveCitationFromCell: onRemoveCitationFromCell,
+        onDeleteCitation: onDeleteCitation,
+    };
+};