@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/spreadsheet-interface.js

@@ -0,0 +1,2787 @@
+import { __assign, __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
+import { tokenize as defaultTokenizer } from "@rowsncolumns/calculator";
+import { isCellCoordinate, isCellNode, isCellRangeNode, isStaticNode, } from "@rowsncolumns/dag";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { defaultSpreadsheetTheme, } from "@rowsncolumns/spreadsheet";
+import { addressToCell, canUseDOM, cellToAddress, DEFAULT_ACTIVE_CELL, DEFAULT_COLUMN_COUNT, DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_COUNT, DEFAULT_ROW_HEIGHT, generateSelectionsFromFormula, getCellEffectiveFormat, getCellEffectiveValue, getCellFormattedValue, getCellUserEnteredFormat, getCellUserEnteredValue, getColumnIndexFromColumnName, getExtendedValueBool, getExtendedValueError, getExtendedValueFormula, getExtendedValueNumber, getExtendedValueString, isAreasEqual, isCellWithinBounds, isNil, iterateCellsInRange, pointToPixel, } from "@rowsncolumns/utils";
+import { enableMapSet, enablePatches, produceWithPatches } from "immer";
+import { buildConditionalFormatExpression } from "../api/conditional-format";
+import { isConditionalFormatFormulaRule } from "../api/conditional-format";
+import { buildDataValidationExpression } from "../api/data-validation";
+import { isDataValidationFormulaRule } from "../api/data-validation";
+import { getAutoFillValues } from "../api/fill";
+import { formulaToRelativeReference } from "../api/formula";
+import { createSheetDraft, deriveCellFromPrecedents } from "../api/immer-utils";
+import { defaultCellCoords, isStyleReference, SheetCell } from "../sheet-cell";
+import { CellXfsRegistry } from "../cellxfs-registry";
+import { SharedStringRegistry } from "../shared-string-registry";
+import { getSharedStringRuns, getSharedStringText } from "../types";
+import { applyFill } from "./apply-fill";
+import { autoResize } from "./auto-resize";
+import { CalculationInterface } from "./calculation-interface";
+import { changeBatch } from "./change-batch";
+import { changeBatchStream } from "./change-batch-stream";
+import { changeBorder } from "./change-border";
+import { changeCalculatedColumn } from "./change-calculated-column";
+import { changeDecimals } from "./change-decimals";
+import { changeFormatting } from "./change-formatting";
+import { changeSheetTabcolor } from "./change-sheet-tabcolor";
+import { changeTableColumn } from "./change-table-column";
+import { changeTheme } from "./change-theme";
+import { isChartsAvailable, safeCreateChart, safeDeleteChart, safeMoveChart, safeResizeChart, safeUpdateChart, } from "./chart-extensions";
+import { createBatchCitations, createCitation, deleteCitation, removeCitationFromCell, updateCitation, } from "./citations";
+import { clearFormatting } from "./clear-formatting";
+import { createConditionalFormattingRule, deleteConditionalFormattingRule, previewConditionalFormattingRule, updateConditionalFormattingRule, } from "./conditional-formatting-rules";
+import { createTable } from "./create-table";
+import { createDataValidationRule, deleteDataValidationRule, deleteDataValidationRules, updateDataValidationRule, } from "./data-validation-rules";
+import { deleteCells } from "./delete-cells";
+import { deleteCellsShiftLeft } from "./delete-cells-shift-left";
+import { deleteCellsShiftUp } from "./delete-cells-shift-up";
+import { deleteColumn } from "./delete-column";
+import { deleteRow } from "./delete-row";
+import { deleteSheet } from "./delete-sheet";
+import { deleteTableColumn } from "./delete-table-column";
+import { deleteTableRow } from "./delete-table-row";
+import { duplicateSheet } from "./duplicate-sheet";
+import { createEmbed, deleteEmbed, moveEmbed, resizeEmbed, updateEmbed, } from "./embeds";
+import { freezeColumn, freezeRow } from "./freeze";
+import { hideColumns } from "./hide-column";
+import { hideRows } from "./hide-row";
+import { decreaseIndent, increaseIndent } from "./indent";
+import { insertColumn, insertTableColumn } from "./insert-column";
+import { insertNote } from "./insert-note";
+import { insertRow } from "./insert-row";
+import { insertTableRow } from "./insert-table-row";
+import { createNamedRange, deleteNamedRange } from "./named-range-operations";
+import { createNewSheet } from "./new-sheet";
+import { safeCreatePivotTable, safeDeletePivotTable } from "./pivot-extensions";
+import { removeTable } from "./remove-table";
+import { removeDuplicates } from "./remove-duplicates";
+import { resize } from "./resize";
+import { updateSheet } from "./update-sheet";
+import { updateTable } from "./update-table";
+// Enable patches
+enablePatches();
+enableMapSet();
+// lib/canvas-adapter.ts
+var canvasLib = null;
+export var createCanvas = function (width, height) {
+    if (canUseDOM) {
+        // Browser environment (Storybook)
+        var canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        return canvas;
+    }
+    else {
+        // Node environment
+        if (!canvasLib) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                canvasLib = require("canvas");
+            }
+            catch (e) {
+                // Fallback: return a minimal mock canvas for SSR/build compatibility
+                console.warn("canvas not available, using mock canvas");
+                return {
+                    width: width,
+                    height: height,
+                    getContext: function () { return ({
+                        font: "",
+                        measureText: function () { return ({ width: 0 }); },
+                    }); },
+                };
+            }
+        }
+        return canvasLib.createCanvas(width, height);
+    }
+};
+/**
+ * Backend auto-sizer for measuring text dimensions in Node.js
+ */
+var BackendAutoSizer = /** @class */ (function () {
+    function BackendAutoSizer() {
+        this.canvas = createCanvas(0, 0);
+        this.ctx = this.canvas.getContext("2d");
+        this.currentFontSize = 12;
+    }
+    BackendAutoSizer.prototype.setFont = function (_a) {
+        var _b = _a.fontFamily, fontFamily = _b === void 0 ? "Arial" : _b, _c = _a.fontSize, fontSize = _c === void 0 ? 12 : _c, _d = _a.fontWeight, fontWeight = _d === void 0 ? "" : _d, _e = _a.fontStyle, fontStyle = _e === void 0 ? "" : _e, _f = _a.scale, scale = _f === void 0 ? 1 : _f;
+        this.currentFontSize = fontSize * scale;
+        var font = "".concat(fontStyle, " ").concat(fontWeight, " ").concat(this.currentFontSize, "px ").concat(fontFamily)
+            .trim()
+            .replace(/\s+/g, " ");
+        this.ctx.font = font;
+    };
+    BackendAutoSizer.prototype.reset = function () {
+        this.setFont({});
+    };
+    BackendAutoSizer.prototype.measureText = function (text, shouldWrap, maxWidth) {
+        var e_1, _a;
+        if (shouldWrap === void 0) { shouldWrap = false; }
+        if (!text)
+            return null;
+        var metrics = this.ctx.measureText(text);
+        var width = metrics.width;
+        var height = this.currentFontSize * 1.2; // Line height approximation
+        if (shouldWrap && maxWidth && width > maxWidth) {
+            // Simple word wrapping calculation
+            var words = text.split(" ");
+            var lines = 1;
+            var currentLineWidth = 0;
+            try {
+                for (var words_1 = __values(words), words_1_1 = words_1.next(); !words_1_1.done; words_1_1 = words_1.next()) {
+                    var word = words_1_1.value;
+                    var wordWidth = this.ctx.measureText(word + " ").width;
+                    if (currentLineWidth + wordWidth > maxWidth) {
+                        lines++;
+                        currentLineWidth = wordWidth;
+                    }
+                    else {
+                        currentLineWidth += wordWidth;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (words_1_1 && !words_1_1.done && (_a = words_1.return)) _a.call(words_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            height = this.currentFontSize * 1.2 * lines;
+            width = maxWidth;
+        }
+        return { width: width, height: height };
+    };
+    return BackendAutoSizer;
+}());
+// Generic state change function
+var stateChangeFunction = function (getter, setter) {
+    return function (action) {
+        if (typeof action === "function") {
+            // If action is a function, call it with current state
+            setter(action(getter()));
+        }
+        else {
+            // If action is a value, set it directly
+            setter(action);
+        }
+    };
+};
+/**
+ * Spreadsheet Interface for SSR
+ *
+ * const spreadsheet = new Spreadsheet()
+ */
+var Spreadsheet = /** @class */ (function () {
+    function Spreadsheet(options) {
+        var _this = this;
+        this._sheets = [];
+        this._sheetData = {};
+        this._tables = [];
+        this._charts = [];
+        this._embeds = [];
+        this._pivotTables = [];
+        this._citations = [];
+        this._namedRanges = [];
+        this._dataValidations = [];
+        this._conditionalFormats = [];
+        this._locale = "en";
+        this._patches = [];
+        this._cellXfs = new Map();
+        this._activeSheetId = 1;
+        this._autoSizer = new BackendAutoSizer();
+        this.scale = 1;
+        this.skipDag = false;
+        this.cellHorizontalSpacing = 5;
+        this.cellVerticalSpacing = 5;
+        this.resizeStrategy = "full";
+        this.minRowDimension = DEFAULT_ROW_HEIGHT;
+        this.minColumnDimension = DEFAULT_COLUMN_WIDTH;
+        this._sharedStrings = new Map();
+        this.onChangeSheets = stateChangeFunction(function () { return _this.sheets; }, // Getter function
+        function (value) { return (_this.sheets = value); });
+        this.onChangeSheetData = stateChangeFunction(function () { return _this.sheetData; }, function (value) { return (_this.sheetData = value); });
+        this.onChangeTables = stateChangeFunction(function () { return _this.tables; }, function (value) { return (_this.tables = value); });
+        this.onChangeCharts = stateChangeFunction(function () { return _this.charts; }, function (value) { return (_this.charts = value); });
+        this.onChangeEmbeds = stateChangeFunction(function () { return _this.embeds; }, function (value) { return (_this.embeds = value); });
+        this.onChangeNamedRanges = stateChangeFunction(function () { return _this.namedRanges; }, function (value) { return (_this.namedRanges = value); });
+        this.onChangeSharedStrings = stateChangeFunction(function () { return _this.sharedStrings; }, function (value) { return (_this.sharedStrings = value); });
+        this.onChangeDataValidations = stateChangeFunction(function () { return _this.dataValidations; }, function (value) { return (_this.dataValidations = value); });
+        this.onChangeConditionalFormats = stateChangeFunction(function () { return _this.conditionalFormats; }, function (value) { return (_this.conditionalFormats = value); });
+        this.onChangeCellXfs = stateChangeFunction(function () { return _this.cellXfs; }, function (value) {
+            _this.cellXfs = value;
+        });
+        this.onChangeActiveSheet = stateChangeFunction(function () { return _this.activeSheetId; }, function (value) { return (_this.activeSheetId = value); });
+        this.onChangePivotTables = stateChangeFunction(function () { return _this.pivotTables; }, // Getter function
+        function (value) { return (_this.pivotTables = value); });
+        this.onChangeCitations = stateChangeFunction(function () { return _this.citations; }, function (value) { return (_this.citations = value); });
+        this.createHistory = function () { return function (patches) {
+            _this._patches.push(patches);
+        }; };
+        this.enqueueCalculation = function (_operation) { };
+        this.enqueueGraphOperation = function (_operation) { };
+        this.enqueueStructureChange = function (_change) { };
+        this.onRequestCalculate = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, []];
+            });
+        }); };
+        this.getActiveCell = function () { return defaultCellCoords; };
+        this.getSelections = function () { return []; };
+        this.getDependents = function (source, includeSource) {
+            return _this._calculationInterface.getDependents(source).filter(function (node) {
+                if (isStaticNode(node)) {
+                    return true;
+                }
+                if (!includeSource && isCellRangeNode(node)) {
+                    return !isAreasEqual(node.position, source);
+                }
+                if (!includeSource && isCellCoordinate(source) && isCellNode(node)) {
+                    var cellNode = node;
+                    return (cellNode.position.rowIndex !== source.rowIndex ||
+                        cellNode.position.columnIndex !== source.columnIndex);
+                }
+                return true;
+            });
+        };
+        this.onChangeSelections = function () { return []; };
+        this.getContentfulRangeAroundCell = function (sheetId, startCell) {
+            return {
+                startRowIndex: startCell.rowIndex,
+                endRowIndex: startCell.rowIndex,
+                startColumnIndex: startCell.columnIndex,
+                endColumnIndex: startCell.columnIndex,
+            };
+        };
+        this.onChangeActiveCell = function () { return []; };
+        this.getEffectiveValue = function (sheetId, rowIndex, columnIndex, _property) {
+            var _a, _b, _c, _d, _e, _f;
+            var cellData = (_d = (_c = (_b = (_a = _this.sheetData) === null || _a === void 0 ? void 0 : _a[sheetId]) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex];
+            // Check for shared strings
+            var sharedStringValue = _this.getSharedStringValue(cellData);
+            if (sharedStringValue !== undefined) {
+                return sharedStringValue;
+            }
+            var effectiveValue = getCellEffectiveValue(cellData);
+            if (!effectiveValue) {
+                return undefined;
+            }
+            return ((_f = (_e = getExtendedValueBool(effectiveValue)) !== null && _e !== void 0 ? _e : getExtendedValueNumber(effectiveValue)) !== null && _f !== void 0 ? _f : getExtendedValueString(effectiveValue));
+        };
+        this.getEffectiveValueForCalculation = function (sheetId, rowIndex, columnIndex, property) {
+            var _a, _b, _c, _d, _e, _f;
+            var cellData = _this.getCellData(sheetId, rowIndex, columnIndex);
+            if (property) {
+                return (_a = _this._getEffectiveStructuredValue) === null || _a === void 0 ? void 0 : _a.call(_this, (_b = getCellEffectiveValue(cellData)) === null || _b === void 0 ? void 0 : _b.structuredValue, property);
+            }
+            var effectiveValue = getCellEffectiveValue(cellData);
+            var errorValue = getExtendedValueError(effectiveValue);
+            if (errorValue) {
+                return new FormulaError(errorValue.name, errorValue.message);
+            }
+            var hyperlink = _this.getHyperlinkText(_this.getHyperLink(sheetId, rowIndex, columnIndex));
+            return ((_f = (_d = (_c = hyperlink !== null && hyperlink !== void 0 ? hyperlink : _this.getEffectiveValue(sheetId, rowIndex, columnIndex)) !== null && _c !== void 0 ? _c : hyperlink) !== null && _d !== void 0 ? _d : (_e = _this._getEffectiveStructuredValue) === null || _e === void 0 ? void 0 : _e.call(_this, effectiveValue === null || effectiveValue === void 0 ? void 0 : effectiveValue.structuredValue)) !== null && _f !== void 0 ? _f : effectiveValue === null || effectiveValue === void 0 ? void 0 : effectiveValue.structuredValue);
+        };
+        this.getUserEnteredValue = function (sheetId, rowIndex, columnIndex) {
+            var cellData = _this.getCellData(sheetId, rowIndex, columnIndex);
+            var sharedStringValue = _this.getSharedStringValue(cellData);
+            if (sharedStringValue !== undefined) {
+                return { sv: sharedStringValue };
+            }
+            return getCellUserEnteredValue(cellData);
+        };
+        this.getUserEnteredStringValue = function (sheetId, rowIndex, columnIndex) {
+            var formulaValue = _this.getFormulaValue(sheetId, rowIndex, columnIndex);
+            if (formulaValue) {
+                return formulaValue;
+            }
+            var userEnteredValue = _this.getUserEnteredValue(sheetId, rowIndex, columnIndex);
+            var stringValue = getExtendedValueString(userEnteredValue);
+            if (stringValue) {
+                return stringValue;
+            }
+            return undefined;
+        };
+        this.getFormulaValue = function (sheetId, rowIndex, columnIndex) {
+            var userEnteredValue = _this.getUserEnteredValue(sheetId, rowIndex, columnIndex);
+            return getExtendedValueFormula(userEnteredValue);
+        };
+        this.getFormattedValue = function (sheetId, rowIndex, columnIndex) {
+            var cellData = _this.getCellData(sheetId, rowIndex, columnIndex);
+            var sharedStringValue = _this.getSharedStringValue(cellData);
+            if (sharedStringValue !== undefined) {
+                return sharedStringValue;
+            }
+            return getCellFormattedValue(cellData);
+        };
+        this.getSheetId = function (sheetName, options) {
+            var _a;
+            var fallbackToActiveSheet = (_a = options === null || options === void 0 ? void 0 : options.fallbackToActiveSheet) !== null && _a !== void 0 ? _a : true;
+            var sheet = _this.sheets.find(function (sheet) { return sheet.title === sheetName; });
+            if (sheet) {
+                return sheet.sheetId;
+            }
+            return fallbackToActiveSheet ? _this.activeSheetId : undefined;
+        };
+        this.getSheetIdOrActive = function (sheetName) {
+            var _a;
+            return ((_a = _this.getSheetId(sheetName, { fallbackToActiveSheet: true })) !== null && _a !== void 0 ? _a : _this.activeSheetId);
+        };
+        this.getSheetName = function (sheetId) {
+            var _a;
+            return (_a = _this.getSheet(sheetId)) === null || _a === void 0 ? void 0 : _a.name;
+        };
+        this.getDataValidationById = function (id) {
+            var _a;
+            return (_a = _this.dataValidations) === null || _a === void 0 ? void 0 : _a.find(function (rule) { return rule.id === id; });
+        };
+        this.getConditionalFormatFormula = function (sheetId, rowIndex, columnIndex, conditionalFormatId) {
+            var e_2, _a;
+            var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            var rule = (_b = _this.conditionalFormats) === null || _b === void 0 ? void 0 : _b.find(function (candidate) { return candidate.id === conditionalFormatId; });
+            if (!rule) {
+                return undefined;
+            }
+            var formulaValue = isConditionalFormatFormulaRule(rule)
+                ? buildConditionalFormatExpression(rule, (_j = cellToAddress({
+                    rowIndex: (_e = (_d = (_c = rule === null || rule === void 0 ? void 0 : rule.ranges) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.startRowIndex) !== null && _e !== void 0 ? _e : 1,
+                    columnIndex: (_h = (_g = (_f = rule === null || rule === void 0 ? void 0 : rule.ranges) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.startColumnIndex) !== null && _h !== void 0 ? _h : 1,
+                }, false, false)) !== null && _j !== void 0 ? _j : "A1", _this.locale)
+                : undefined;
+            if (!formulaValue || !rule.ranges.length) {
+                return formulaValue;
+            }
+            var masterCell = {
+                rowIndex: rule.ranges[0].startRowIndex,
+                columnIndex: rule.ranges[0].startColumnIndex,
+            };
+            var activeSheetName = (_k = _this.getSheetName(sheetId)) !== null && _k !== void 0 ? _k : "";
+            try {
+                for (var _m = __values(rule.ranges), _o = _m.next(); !_o.done; _o = _m.next()) {
+                    var range = _o.value;
+                    if (sheetId === range.sheetId &&
+                        isCellWithinBounds({ rowIndex: rowIndex, columnIndex: columnIndex }, range)) {
+                        return ((_l = formulaToRelativeReference(formulaValue, masterCell, { rowIndex: rowIndex, columnIndex: columnIndex }, activeSheetName, {
+                            ignoreCircular: true,
+                            preserveAbsolutes: true,
+                            ignoreReferenceError: true,
+                        })) !== null && _l !== void 0 ? _l : "");
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        };
+        this.getDataValidationFormula = function (sheetId, rowIndex, columnIndex) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            var cellData = _this.getCellData(sheetId, rowIndex, columnIndex);
+            var dataValidation = cellData === null || cellData === void 0 ? void 0 : cellData.dataValidation;
+            if (typeof dataValidation === "string" ||
+                typeof dataValidation === "number") {
+                dataValidation = _this.getDataValidationById(dataValidation);
+            }
+            var record = dataValidation;
+            var formulaValue = isDataValidationFormulaRule(record)
+                ? buildDataValidationExpression(record, (_g = cellToAddress({
+                    rowIndex: (_c = (_b = (_a = record === null || record === void 0 ? void 0 : record.ranges) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.startRowIndex) !== null && _c !== void 0 ? _c : 1,
+                    columnIndex: (_f = (_e = (_d = record === null || record === void 0 ? void 0 : record.ranges) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.startColumnIndex) !== null && _f !== void 0 ? _f : 1,
+                }, false, false)) !== null && _g !== void 0 ? _g : "A1", _this.locale)
+                : undefined;
+            if (formulaValue && ((_h = record === null || record === void 0 ? void 0 : record.ranges) === null || _h === void 0 ? void 0 : _h.length)) {
+                var masterCell = {
+                    rowIndex: record.ranges[0].startRowIndex,
+                    columnIndex: record.ranges[0].startColumnIndex,
+                };
+                var activeSheetName = (_j = _this.getSheetName(sheetId)) !== null && _j !== void 0 ? _j : "";
+                return ((_k = formulaToRelativeReference(formulaValue, masterCell, { rowIndex: rowIndex, columnIndex: columnIndex }, activeSheetName, {
+                    ignoreCircular: true,
+                    preserveAbsolutes: true,
+                    ignoreReferenceError: true,
+                })) !== null && _k !== void 0 ? _k : "");
+            }
+            return formulaValue;
+        };
+        this.getFinalUserEnteredValue = function (position) {
+            var conditionalFormatId = position.conditionalFormatId, dataValidationId = position.dataValidationId;
+            if (!isNil(conditionalFormatId)) {
+                return _this.getConditionalFormatFormula(position.sheetId, position.rowIndex, position.columnIndex, conditionalFormatId);
+            }
+            if (!isNil(dataValidationId)) {
+                return _this.getDataValidationFormula(position.sheetId, position.rowIndex, position.columnIndex);
+            }
+            return _this.getFormulaValue(position.sheetId, position.rowIndex, position.columnIndex);
+        };
+        this.getPrecedents = function (source, includeSource) {
+            return _this._calculationInterface.getPrecedents(source).filter(function (node) {
+                if (isStaticNode(node)) {
+                    return true;
+                }
+                if (!includeSource &&
+                    isCellCoordinate(node.position) &&
+                    isCellCoordinate(source)) {
+                    return (node.position.rowIndex !== source.rowIndex ||
+                        node.position.columnIndex !== source.columnIndex);
+                }
+                if (includeSource &&
+                    !isCellCoordinate(node.position) &&
+                    !isCellCoordinate(source)) {
+                    return !isAreasEqual(node.position, source);
+                }
+                return true;
+            });
+        };
+        this.collectFormulaOperations = function () {
+            var e_3, _a, e_4, _b;
+            var _c, _d, _e, _f;
+            var operations = [];
+            var sheetCell = new SheetCell();
+            for (var sheetIdKey in _this.sheetData) {
+                var sheetId = Number(sheetIdKey);
+                try {
+                    for (var _g = (e_3 = void 0, __values((_d = (_c = _this.sheetData[sheetId]) === null || _c === void 0 ? void 0 : _c.entries()) !== null && _d !== void 0 ? _d : [])), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var _j = __read(_h.value, 2), rowIndex = _j[0], value = _j[1];
+                        try {
+                            for (var _k = (e_4 = void 0, __values((_f = (_e = value === null || value === void 0 ? void 0 : value.values) === null || _e === void 0 ? void 0 : _e.entries()) !== null && _f !== void 0 ? _f : [])), _l = _k.next(); !_l.done; _l = _k.next()) {
+                                var _m = __read(_l.value, 2), columnIndex = _m[0], cellData = _m[1];
+                                if (!cellData) {
+                                    continue;
+                                }
+                                sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData);
+                                if (sheetCell.formula) {
+                                    operations.push({
+                                        type: "add",
+                                        position: { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex },
+                                        value: sheetCell.formula,
+                                    });
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_l && !_l.done && (_b = _k.return)) _b.call(_k);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+            return operations;
+        };
+        this.getEffectiveValuesFromRange = function (address) {
+            var _a = __read(address.split("!"), 2), sheetToken = _a[0], rangeToken = _a[1];
+            var hasExplicitSheet = Boolean(rangeToken);
+            var sheetName = hasExplicitSheet ? sheetToken : undefined;
+            var sheetId = sheetName ? _this.getSheetId(sheetName) : _this.activeSheetId;
+            var rangeAddress = hasExplicitSheet ? rangeToken : sheetToken;
+            if (!sheetId || !rangeAddress) {
+                return [];
+            }
+            var sheet = _this.getSheet(sheetId);
+            var _b = __read(rangeAddress.split(":"), 2), startRef = _b[0], endRef = _b[1];
+            var startCell = addressToCell(startRef, {
+                position: "start",
+                rowCount: sheet.rowCount,
+                columnCount: sheet.columnCount,
+            });
+            var endCell = addressToCell(endRef !== null && endRef !== void 0 ? endRef : startRef, {
+                position: "end",
+                rowCount: sheet.rowCount,
+                columnCount: sheet.columnCount,
+            });
+            if (!startCell || !endCell) {
+                return [];
+            }
+            var values = [];
+            for (var row = startCell.rowIndex; row <= endCell.rowIndex; row += 1) {
+                for (var col = startCell.columnIndex; col <= endCell.columnIndex; col += 1) {
+                    var value = _this.getEffectiveValue(sheetId, row, col);
+                    values.push({
+                        userEnteredValue: value == null ? "" : String(value),
+                    });
+                }
+            }
+            return values;
+        };
+        this.applyCalculationResults = function (results) {
+            var _a;
+            var sheetCell = new SheetCell();
+            var saveHistory = _this.createHistory();
+            var cellXfsRegisry = _this.cellXfsRegistry;
+            (_a = _this.onChangeSheetData) === null || _a === void 0 ? void 0 : _a.call(_this, function (prevSheetData) {
+                var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                    var e_5, _a;
+                    var _b;
+                    try {
+                        for (var results_1 = __values(results), results_1_1 = results_1.next(); !results_1_1.done; results_1_1 = results_1.next()) {
+                            var _c = __read(results_1_1.value, 3), position = _c[0], result = _c[1], formatting = _c[2];
+                            var rowIndex = position.rowIndex, columnIndex = position.columnIndex, sheetId = position.sheetId, conditionalFormatId = position.conditionalFormatId, dataValidationId = position.dataValidationId;
+                            var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                            var cellData = (_b = currentSheet[rowIndex].values) === null || _b === void 0 ? void 0 : _b[columnIndex];
+                            sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                                getRangeValues: _this.getEffectiveValuesFromRange,
+                                locale: _this.locale,
+                                cellXfsRegistry: cellXfsRegisry,
+                                getDataValidationById: _this.getDataValidationById,
+                            });
+                            sheetCell.hideLoading();
+                            if (!isNil(conditionalFormatId)) {
+                                sheetCell.setConditionalFormatResult(conditionalFormatId, result);
+                            }
+                            else if (!isNil(dataValidationId)) {
+                                sheetCell.setDataValidationResult(result);
+                            }
+                            else {
+                                var preserveStringLiteral = typeof result === "string";
+                                sheetCell.setEffectiveValue(result, false, preserveStringLiteral);
+                                // Calculator-supplied formatting (e.g. spilled FILTER results)
+                                // is persisted as user-entered so the renderer respects it
+                                // without walking precedents. Effective number format from
+                                // precedents is derived at render time and not written here.
+                                if (formatting) {
+                                    for (var type in formatting) {
+                                        sheetCell.setUserEnteredFormat(type, formatting[type]);
+                                    }
+                                }
+                                var derivedCell = deriveCellFromPrecedents(sheetCell.formula, _this.getPrecedents(position), draft, sheetId, _this.locale, _this.cellXfsRegistry);
+                                if (derivedCell) {
+                                    sheetCell.processDerivedCell(derivedCell);
+                                }
+                            }
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            cellXfsRegisry === null || cellXfsRegisry === void 0 ? void 0 : cellXfsRegisry.registerCellXfs(sheetCell);
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (results_1_1 && !results_1_1.done && (_a = results_1.return)) _a.call(results_1);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                saveHistory({
+                    sheetData: { patches: patches, inversePatches: inversePatches },
+                    disableRecalc: true,
+                });
+                return nextState;
+            });
+            cellXfsRegisry === null || cellXfsRegisry === void 0 ? void 0 : cellXfsRegisry.getPatches(saveHistory);
+        };
+        /**
+         * Get dimension of a single cell
+         * Similar to use-sizer.ts getCellDimensions
+         */
+        this.getCellDimensions = function (sheetId, rowIndex, columnIndex, axis, options) {
+            var _a, _b;
+            if (axis === void 0) { axis = "y"; }
+            var _c = options !== null && options !== void 0 ? options : {}, textOverride = _c.textOverride, textFormatOverride = _c.textFormatOverride, shouldWrapOverride = _c.shouldWrapOverride;
+            var text = textOverride !== null && textOverride !== void 0 ? textOverride : _this.getFormattedValue(sheetId, rowIndex, columnIndex);
+            if (!text)
+                return { width: 0, height: 0 };
+            var textFormat = textFormatOverride !== null && textFormatOverride !== void 0 ? textFormatOverride : _this.getCellTextFormat(sheetId, rowIndex, columnIndex);
+            // Rich-text runs carry their own font sizes; the tallest run sets the
+            // line box (Excel scales a row to the largest glyph in a mixed line).
+            // Headless heuristic, mirroring the Rust engine's refit: the whole cell
+            // measures under the tallest font rather than per-segment metrics.
+            var runs = textFormatOverride == null
+                ? _this.getCellTextFormatRuns(sheetId, rowIndex, columnIndex)
+                : undefined;
+            var maxRunFontSize = runs === null || runs === void 0 ? void 0 : runs.reduce(function (acc, run) { var _a, _b; return "format" in run ? Math.max(acc, (_b = (_a = run.format) === null || _a === void 0 ? void 0 : _a.fontSize) !== null && _b !== void 0 ? _b : 0) : acc; }, 0);
+            var fitFontSize = Math.max((_a = textFormat.fontSize) !== null && _a !== void 0 ? _a : 10, maxRunFontSize !== null && maxRunFontSize !== void 0 ? maxRunFontSize : 0);
+            // Reset and set font
+            _this._autoSizer.reset();
+            var textFontSize = pointToPixel(fitFontSize);
+            _this._autoSizer.setFont({
+                fontFamily: (_b = textFormat === null || textFormat === void 0 ? void 0 : textFormat.fontFamily) !== null && _b !== void 0 ? _b : "Arial",
+                fontSize: textFontSize,
+                fontWeight: (textFormat === null || textFormat === void 0 ? void 0 : textFormat.bold) ? "bold" : "",
+                fontStyle: (textFormat === null || textFormat === void 0 ? void 0 : textFormat.italic) ? "italic" : "",
+                scale: _this.scale,
+            });
+            var shouldWrap = shouldWrapOverride !== null && shouldWrapOverride !== void 0 ? shouldWrapOverride : _this.shouldWrapCell(sheetId, rowIndex, columnIndex);
+            var columnWidth = _this.getStoredColumnWidth(sheetId, columnIndex);
+            var metrics = _this._autoSizer.measureText(text, shouldWrap, columnWidth - _this.cellHorizontalSpacing);
+            if (!metrics)
+                return { width: 0, height: 0 };
+            return {
+                width: Math.ceil(metrics.width) + _this.cellHorizontalSpacing,
+                height: Math.ceil(metrics.height) + _this.cellVerticalSpacing,
+            };
+        };
+        /**
+         * Check if a cell is merged
+         * @param sheetId
+         * @param rowIndex
+         * @param columnIndex
+         * @returns
+         */
+        this.isMergedCell = function (sheetId, rowIndex, columnIndex) {
+            var _a;
+            var sheet = _this.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;
+        };
+        /**
+         * Calculate row height based on cell content
+         * Same logic as use-sizer.ts getRowHeight
+         */
+        this.getRowHeight = function (sheetId, rowIndex, shouldExclude) {
+            var sheet = _this.getSheet(sheetId);
+            var columnCount = sheet.columnCount;
+            var visibleColumns = _this.resizeStrategy === "full" ? columnCount : 20;
+            var maxHeight = 0;
+            // Calculate for frozen columns
+            for (var i = 1; i <= sheet.frozenColumns; i++) {
+                if (_this.isHiddenColumn(sheetId, i)) {
+                    continue;
+                }
+                var height = _this.getCellDimensions(sheetId, rowIndex, i, "x").height;
+                if (height > maxHeight)
+                    maxHeight = height;
+            }
+            // Loop through visible columns
+            var start = _this.resizeStrategy === "full" ? Math.max(sheet.frozenColumns, 1) : 0;
+            while (start < visibleColumns) {
+                if (_this.isHiddenColumn(sheetId, start) || (shouldExclude === null || shouldExclude === void 0 ? void 0 : shouldExclude(start))) {
+                    start++;
+                    continue;
+                }
+                var height = _this.getCellDimensions(sheetId, rowIndex, start, "x").height;
+                if (height > maxHeight)
+                    maxHeight = height;
+                start++;
+            }
+            return Math.max(_this.minRowDimension * _this.scale, maxHeight) / _this.scale;
+        };
+        /**
+         * Calculate column width based on cell content
+         * Same logic as use-sizer.ts getColumnWidth
+         */
+        this.getColumnWidth = function (sheetId, columnIndex, options) {
+            var sheet = _this.getSheet(sheetId);
+            var rowCount = sheet.rowCount;
+            var _a = options !== null && options !== void 0 ? options : {}, rowStartIndexRegion = _a.rowStartIndexRegion, rowStopIndexRegion = _a.rowStopIndexRegion, fallbackToDefaultIfEmpty = _a.fallbackToDefaultIfEmpty;
+            var visibleRows = (rowStopIndexRegion !== null && rowStopIndexRegion !== void 0 ? rowStopIndexRegion : _this.resizeStrategy === "full") ? rowCount : 20;
+            var maxWidth = 0;
+            // Calculate for frozen rows: Frozen rows are always on the screen
+            for (var i = 1; i < sheet.frozenRows; i++) {
+                if (_this.isHiddenRow(sheetId, i)) {
+                    continue;
+                }
+                var width = _this.getCellDimensions(sheetId, i, columnIndex).width;
+                if (width > maxWidth)
+                    maxWidth = width;
+            }
+            // Loop through all visible rows
+            var start = (rowStartIndexRegion !== null && rowStartIndexRegion !== void 0 ? rowStartIndexRegion : _this.resizeStrategy === "full")
+                ? sheet.frozenRows
+                : 0;
+            while (start < visibleRows) {
+                if (_this.isHiddenRow(sheetId, start)) {
+                    start++;
+                    continue;
+                }
+                var width = _this.getCellDimensions(sheetId, start, columnIndex, "y").width;
+                if (width > maxWidth)
+                    maxWidth = width;
+                start++;
+            }
+            // This column is empty
+            if (maxWidth === 0) {
+                if (fallbackToDefaultIfEmpty) {
+                    return DEFAULT_COLUMN_WIDTH;
+                }
+                return _this.getStoredColumnWidth(sheetId, columnIndex);
+            }
+            return (Math.max(_this.minColumnDimension * _this.scale, maxWidth) / _this.scale);
+        };
+        /**
+         * Get selection from a named range variable
+         * @param variableName
+         * @returns
+         */
+        this.getSelectionFromNamedRange = function (variableName) {
+            var _a;
+            var namedRange = (_a = _this.namedRanges) === null || _a === void 0 ? void 0 : _a.find(function (range) {
+                return range.name.localeCompare(variableName, undefined, {
+                    sensitivity: "accent",
+                }) === 0;
+            });
+            // Only return selection for names with ranges
+            if (namedRange === null || namedRange === void 0 ? void 0 : namedRange.range) {
+                var sheet = _this.getSheet(namedRange.range.sheetId);
+                return {
+                    range: namedRange.range,
+                    sheetName: sheet.name,
+                };
+            }
+            // Get static or formula value
+            var result = namedRange === null || namedRange === void 0 ? void 0 : namedRange.value;
+            if (!isNil(result)) {
+                return result;
+            }
+            return undefined;
+        };
+        /**
+         * Get selections from table reference
+         * @param sheetId
+         * @param cell
+         * @param tableName
+         * @param columnNames
+         * @param thisRow
+         * @param specialItem
+         * @returns
+         */
+        this.getSelectionFromTable = function (sheetId, cell, tableName, columnNames, thisRow, specialItem) {
+            var _a, _b, _c;
+            // If there is no tablename, we need to find table based
+            // on cell
+            var table = (_a = _this.tables) === null || _a === void 0 ? void 0 : _a.find(function (table) {
+                if (tableName) {
+                    return table.title === tableName;
+                }
+                return cell
+                    ? isCellWithinBounds(cell, table.range) && table.sheetId === sheetId
+                    : true;
+            });
+            // Current row
+            var rowIndex = (cell !== null && cell !== void 0 ? cell : DEFAULT_ACTIVE_CELL).rowIndex;
+            if (table) {
+                var range = table.range;
+                var headerRow = (_b = table.headerRow) !== null && _b !== void 0 ? _b : true;
+                var totalRow = (_c = table.totalRow) !== null && _c !== void 0 ? _c : false;
+                var headerRowOffset = headerRow ? 1 : 0;
+                var totalRowOffset = totalRow ? 1 : 0;
+                var sheet = _this.getSheet(table.sheetId);
+                var sheetName = sheet.name;
+                var _d = __read(columnNames !== null && columnNames !== void 0 ? columnNames : [], 2), from = _d[0], to = _d[1];
+                var startColIndex = getColumnIndexFromColumnName(table, from);
+                var endColIndex = getColumnIndexFromColumnName(table, to);
+                var startColumnIndex = isNil(startColIndex)
+                    ? range.startColumnIndex
+                    : startColIndex;
+                var endColumnIndex = isNil(endColIndex) && isNil(startColIndex)
+                    ? range.endColumnIndex
+                    : isNil(endColIndex)
+                        ? startColumnIndex
+                        : endColIndex;
+                // Headers only
+                if (specialItem === "#Headers") {
+                    return {
+                        range: __assign(__assign({}, range), { startColumnIndex: startColumnIndex, endColumnIndex: endColumnIndex, startRowIndex: range.startRowIndex, endRowIndex: range.startRowIndex }),
+                        sheetName: sheetName,
+                    };
+                }
+                // All
+                if (specialItem === "#All") {
+                    return {
+                        range: __assign(__assign({}, range), { startColumnIndex: startColumnIndex, endColumnIndex: endColumnIndex }),
+                        sheetName: sheetName,
+                    };
+                }
+                // All
+                if (specialItem === "#Data") {
+                    return {
+                        range: __assign(__assign({}, range), { startColumnIndex: startColumnIndex, endColumnIndex: endColumnIndex, startRowIndex: range.startRowIndex + headerRowOffset, endRowIndex: range.endRowIndex - totalRowOffset }),
+                        sheetName: sheetName,
+                    };
+                }
+                if (!from && !to) {
+                    return {
+                        range: {
+                            startRowIndex: thisRow
+                                ? rowIndex
+                                : range.startRowIndex + headerRowOffset,
+                            endRowIndex: thisRow
+                                ? rowIndex
+                                : range.endRowIndex - totalRowOffset,
+                            startColumnIndex: startColumnIndex,
+                            endColumnIndex: endColumnIndex,
+                        },
+                        sheetName: sheetName,
+                    };
+                }
+                // If column is not found, lets not select anything
+                if (startColIndex === -1 || isNil(startColIndex)) {
+                    return undefined;
+                }
+                // Check if thisrow is active and current cell is in bounds
+                if (thisRow &&
+                    (rowIndex < range.startRowIndex || rowIndex > range.endRowIndex)) {
+                    return undefined;
+                }
+                return {
+                    range: __assign(__assign({}, range), { startRowIndex: thisRow
+                            ? rowIndex
+                            : range.startRowIndex + headerRowOffset, endRowIndex: thisRow ? rowIndex : range.endRowIndex - totalRowOffset, startColumnIndex: startColumnIndex, endColumnIndex: endColumnIndex }),
+                    sheetName: sheet.name,
+                };
+            }
+        };
+        /**
+         * Tokenize a string in the back-end
+         * @param value
+         * @param sheetId
+         * @param activeCell
+         * @returns
+         */
+        this.tokenize = function (value, sheetId, activeCell) {
+            var e_6, _a;
+            var _b, _c, _d;
+            var tokens = (_b = defaultTokenizer === null || defaultTokenizer === void 0 ? void 0 : defaultTokenizer(value)) !== null && _b !== void 0 ? _b : [];
+            var index = -1;
+            try {
+                for (var tokens_1 = __values(tokens), tokens_1_1 = tokens_1.next(); !tokens_1_1.done; tokens_1_1 = tokens_1.next()) {
+                    var token = tokens_1_1.value;
+                    if (token.selection) {
+                        token["index"] = ++index;
+                    }
+                    if (token.isNamedRange) {
+                        if ((_c = _this.getSelectionFromNamedRange) === null || _c === void 0 ? void 0 : _c.call(_this, token.image)) {
+                            token["index"] = ++index;
+                        }
+                        else {
+                            delete token["index"];
+                        }
+                    }
+                    if (token.structured) {
+                        if ((_d = _this.getSelectionFromTable) === null || _d === void 0 ? void 0 : _d.call(_this, sheetId, activeCell, token.tableName, token.columnNames, token.thisRow, token.specialItem)) {
+                            token["index"] = ++index;
+                        }
+                        else {
+                            delete token["index"];
+                        }
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            return tokens;
+        };
+        /**
+         * Get selections from a formula
+         * @param value
+         * @param sheetId
+         * @param activeCell
+         * @returns
+         */
+        this.getSelectionFromFormula = function (value, sheetId, activeCell) {
+            var sheet = _this.getSheet(sheetId);
+            return generateSelectionsFromFormula(value, sheetId, sheet.name, activeCell, sheet.rowCount, sheet.columnCount, function (formulaValue) {
+                return _this.tokenize(formulaValue, sheetId, activeCell);
+            }, function (id, cell, tableName, columnNames, thisRow, specialItem) {
+                return _this.getSelectionFromTable(id, cell, tableName, columnNames, thisRow, specialItem);
+            }, _this.getSelectionFromNamedRange);
+        };
+        this.getGridValuesForPivot = function (range) {
+            var _a;
+            var headers = [];
+            var rows = [];
+            for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                var row = [];
+                var isHeader = rowIndex === range.startRowIndex;
+                for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                    row.push((_a = _this.getEffectiveValue(range.sheetId, rowIndex, columnIndex)) !== null && _a !== void 0 ? _a : "");
+                }
+                if (isHeader) {
+                    headers = row;
+                }
+                else {
+                    rows.push(row);
+                }
+            }
+            return {
+                headers: headers,
+                rows: rows,
+            };
+        };
+        this._getEffectiveStructuredValue = options === null || options === void 0 ? void 0 : options.getEffectiveStructuredValue;
+        this._calculationInterface = new CalculationInterface({
+            locale: this.locale,
+            createWorker: options === null || options === void 0 ? void 0 : options.createCalculationWorker,
+            iterativeCalculation: options === null || options === void 0 ? void 0 : options.iterativeCalculation,
+            clientOnlyFunctionPattern: options === null || options === void 0 ? void 0 : options.clientOnlyFunctionPattern,
+            getSheetName: this.getSheetName,
+            getSheetId: function (sheetName) {
+                return _this.getSheetId(sheetName, { fallbackToActiveSheet: false });
+            },
+            getSheets: function () { return _this.sheets; },
+            getTables: function () { return _this.tables; },
+            getNamedRanges: function () { return _this.namedRanges; },
+            getFinalUserEnteredValue: this.getFinalUserEnteredValue,
+            getEffectiveValue: this.getEffectiveValueForCalculation,
+            getEffectiveStructuredValue: options === null || options === void 0 ? void 0 : options.getEffectiveStructuredValue,
+            onResults: this.applyCalculationResults,
+        });
+        this.enqueueCalculation = function (operation) {
+            _this._calculationInterface.enqueueCalculation(operation);
+        };
+        this.enqueueGraphOperation = function (operation) {
+            _this._calculationInterface.enqueueGraphOperation(operation);
+        };
+        this.enqueueStructureChange = function (change) {
+            _this._calculationInterface.enqueueStructureChange(change);
+        };
+    }
+    Spreadsheet.prototype.rebuildGraph = function () {
+        if (this.skipDag) {
+            return;
+        }
+        this._calculationInterface.rebuildGraph(this.collectFormulaOperations());
+        this.addConditionalFormattingToGraph();
+        this.addDataValidationsToGraph();
+    };
+    /**
+     * Add conditional formatting rules to the dependency graph.
+     * @param sheetId - Optional sheet ID to restrict to a specific sheet
+     */
+    Spreadsheet.prototype.addConditionalFormattingToGraph = function (sheetId) {
+        var e_7, _a, e_8, _b, e_9, _c;
+        var _d;
+        var restrictToSheet = typeof sheetId === "number";
+        try {
+            for (var _e = __values((_d = this.conditionalFormats) !== null && _d !== void 0 ? _d : []), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var rule = _f.value;
+                if (rule.enabled === false) {
+                    continue;
+                }
+                if (isConditionalFormatFormulaRule(rule)) {
+                    try {
+                        for (var _g = (e_8 = void 0, __values(rule.ranges)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                            var range = _h.value;
+                            if (restrictToSheet && range.sheetId !== sheetId) {
+                                continue;
+                            }
+                            try {
+                                for (var _j = (e_9 = void 0, __values(iterateCellsInRange(range))), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                    var _l = __read(_k.value, 2), rowIndex = _l[0], columnIndex = _l[1];
+                                    this.enqueueGraphOperation({
+                                        position: {
+                                            rowIndex: rowIndex,
+                                            columnIndex: columnIndex,
+                                            sheetId: range.sheetId,
+                                            conditionalFormatId: rule.id,
+                                        },
+                                        type: "add",
+                                    });
+                                }
+                            }
+                            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                            finally {
+                                try {
+                                    if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                                }
+                                finally { if (e_9) throw e_9.error; }
+                            }
+                        }
+                    }
+                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                    finally {
+                        try {
+                            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                        }
+                        finally { if (e_8) throw e_8.error; }
+                    }
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+    };
+    /**
+     * Add data validation rules to the dependency graph.
+     * @param sheetId - Optional sheet ID to restrict to a specific sheet
+     */
+    Spreadsheet.prototype.addDataValidationsToGraph = function (sheetId) {
+        var e_10, _a, e_11, _b, e_12, _c;
+        var _d;
+        var restrictToSheet = typeof sheetId === "number";
+        try {
+            for (var _e = __values((_d = this.dataValidations) !== null && _d !== void 0 ? _d : []), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var rule = _f.value;
+                if (isDataValidationFormulaRule(rule)) {
+                    try {
+                        for (var _g = (e_11 = void 0, __values(rule.ranges)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                            var range = _h.value;
+                            if (restrictToSheet && range.sheetId !== sheetId) {
+                                continue;
+                            }
+                            try {
+                                for (var _j = (e_12 = void 0, __values(iterateCellsInRange(range))), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                    var _l = __read(_k.value, 2), rowIndex = _l[0], columnIndex = _l[1];
+                                    this.enqueueGraphOperation({
+                                        position: {
+                                            rowIndex: rowIndex,
+                                            columnIndex: columnIndex,
+                                            sheetId: range.sheetId,
+                                            dataValidationId: rule.id,
+                                        },
+                                        type: "add",
+                                    });
+                                }
+                            }
+                            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                            finally {
+                                try {
+                                    if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                                }
+                                finally { if (e_12) throw e_12.error; }
+                            }
+                        }
+                    }
+                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    finally {
+                        try {
+                            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                        }
+                        finally { if (e_11) throw e_11.error; }
+                    }
+                }
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+    };
+    Object.defineProperty(Spreadsheet.prototype, "sharedStrings", {
+        get: function () {
+            return this._sharedStrings;
+        },
+        set: function (value) {
+            this._sharedStrings = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "activeSheetId", {
+        get: function () {
+            return this._activeSheetId;
+        },
+        set: function (value) {
+            this._activeSheetId = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "sheets", {
+        get: function () {
+            return this._sheets;
+        },
+        set: function (value) {
+            this._sheets = value;
+            this._calculationInterface.markMetadataDirty();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "charts", {
+        get: function () {
+            return this._charts;
+        },
+        set: function (value) {
+            this._charts = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "embeds", {
+        get: function () {
+            return this._embeds;
+        },
+        set: function (value) {
+            this._embeds = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "pivotTables", {
+        get: function () {
+            return this._pivotTables;
+        },
+        set: function (value) {
+            this._pivotTables = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "citations", {
+        get: function () {
+            return this._citations;
+        },
+        set: function (value) {
+            this._citations = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "namedRanges", {
+        get: function () {
+            return this._namedRanges;
+        },
+        set: function (value) {
+            this._namedRanges = value;
+            this._calculationInterface.markMetadataDirty();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "dataValidations", {
+        get: function () {
+            return this._dataValidations;
+        },
+        set: function (value) {
+            this._dataValidations = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "conditionalFormats", {
+        get: function () {
+            return this._conditionalFormats;
+        },
+        set: function (value) {
+            this._conditionalFormats = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "sheetData", {
+        get: function () {
+            return this._sheetData;
+        },
+        set: function (sheetData) {
+            this._sheetData = sheetData;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "tables", {
+        get: function () {
+            return this._tables;
+        },
+        set: function (value) {
+            this._tables = value;
+            this._calculationInterface.markMetadataDirty();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "locale", {
+        get: function () {
+            return this._locale;
+        },
+        set: function (value) {
+            this._locale = value;
+            this._calculationInterface.markMetadataDirty();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "cellXfs", {
+        get: function () {
+            return this._cellXfs;
+        },
+        set: function (value) {
+            this._cellXfs = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "patches", {
+        get: function () {
+            return this._patches;
+        },
+        set: function (value) {
+            this._patches = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Spreadsheet.prototype.clearPatches = function () {
+        this._patches = [];
+    };
+    Object.defineProperty(Spreadsheet.prototype, "cellXfsRegistry", {
+        get: function () {
+            return new CellXfsRegistry(this.cellXfs, this.onChangeCellXfs);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Spreadsheet.prototype, "sharedStringRegistry", {
+        get: function () {
+            return new SharedStringRegistry(this.sharedStrings, this.onChangeSharedStrings);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Spreadsheet.prototype.getSharedStringValue = function (cellData) {
+        if ((cellData === null || cellData === void 0 ? void 0 : cellData.ss) == null) {
+            return undefined;
+        }
+        var value = this.sharedStrings.get(String(cellData.ss));
+        if (value == null) {
+            return undefined;
+        }
+        // Entries may be plain strings OR rich `{text, runs}` objects — mirror the
+        // hooks' getSharedStringValue, which resolves the rich form's text.
+        return getSharedStringText(value);
+    };
+    Spreadsheet.prototype.getHyperLink = function (sheetId, rowIndex, columnIndex) {
+        var _a;
+        return (_a = this.getCellData(sheetId, rowIndex, columnIndex)) === null || _a === void 0 ? void 0 : _a.hyperlink;
+    };
+    Spreadsheet.prototype.getHyperlinkText = function (hyperlink) {
+        if (!hyperlink) {
+            return undefined;
+        }
+        if (typeof hyperlink === "string") {
+            return hyperlink;
+        }
+        if (hyperlink.kind === "external") {
+            return hyperlink.url;
+        }
+        return hyperlink.location;
+    };
+    Spreadsheet.prototype.getCellData = function (sheetId, rowIndex, columnIndex) {
+        var _a, _b, _c, _d;
+        return (_d = (_c = (_b = (_a = this.sheetData) === null || _a === void 0 ? void 0 : _a[sheetId]) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex];
+    };
+    /**
+     * Get sheet
+     * @param sheetId
+     * @returns
+     */
+    Spreadsheet.prototype.getSheet = function (sheetId) {
+        var sheet = this.sheets.find(function (sheet) { return sheet.sheetId === sheetId; });
+        return new SheetInterface(sheet);
+    };
+    Spreadsheet.prototype.flushCalculations = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._calculationInterface.flush()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Spreadsheet.prototype.calculateAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var operations;
+            return __generator(this, function (_a) {
+                operations = this.collectFormulaOperations();
+                if (!operations.length) {
+                    return [2 /*return*/, []];
+                }
+                return [2 /*return*/, this._calculationInterface.calculate(operations)];
+            });
+        });
+    };
+    Spreadsheet.prototype.calculatePending = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this._calculationInterface.flushWithResults()];
+            });
+        });
+    };
+    /**
+     * Get text format for a cell (for auto-sizing)
+     */
+    /**
+     * Rich-text runs for a cell, read off the SharedStrings entry the cell
+     * points at via `ss` (same source as the hooks' `getTextFormatRuns`).
+     */
+    Spreadsheet.prototype.getCellTextFormatRuns = function (sheetId, rowIndex, columnIndex) {
+        var cellData = this.getCellData(sheetId, rowIndex, columnIndex);
+        if ((cellData === null || cellData === void 0 ? void 0 : cellData.ss) == null)
+            return undefined;
+        return getSharedStringRuns(this.sharedStrings.get(String(cellData.ss)));
+    };
+    Spreadsheet.prototype.getCellTextFormat = function (sheetId, rowIndex, columnIndex) {
+        var _a, _b, _c, _d, _e, _f;
+        var cellData = this.getCellData(sheetId, rowIndex, columnIndex);
+        // `ef` is no longer persisted on cellData. Read `uf` first, fall back to
+        // legacy `ef` for older saved data.
+        var effectiveFormat = (_a = getCellUserEnteredFormat(cellData)) !== null && _a !== void 0 ? _a : getCellEffectiveFormat(cellData);
+        // Registry
+        if (isStyleReference(effectiveFormat)) {
+            effectiveFormat = this.cellXfsRegistry.getCellXfsFromStyleId((_b = effectiveFormat.sid) !== null && _b !== void 0 ? _b : effectiveFormat.styleId);
+        }
+        return {
+            bold: (_c = effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.textFormat) === null || _c === void 0 ? void 0 : _c.bold,
+            fontSize: (_d = effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.textFormat) === null || _d === void 0 ? void 0 : _d.fontSize,
+            fontFamily: (_e = effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.textFormat) === null || _e === void 0 ? void 0 : _e.fontFamily,
+            italic: (_f = effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.textFormat) === null || _f === void 0 ? void 0 : _f.italic,
+            shouldWrap: (effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.wrapStrategy) === "wrap",
+        };
+    };
+    Spreadsheet.prototype.shouldWrapCell = function (sheetId, rowIndex, columnIndex) {
+        var cellFormat = this.getCellTextFormat(sheetId, rowIndex, columnIndex);
+        return cellFormat === null || cellFormat === void 0 ? void 0 : cellFormat.shouldWrap;
+    };
+    /**
+     * Get column width from sheet metadata (stored width)
+     */
+    Spreadsheet.prototype.getStoredColumnWidth = function (sheetId, columnIndex) {
+        var _a, _b, _c;
+        var sheet = this.sheets.find(function (s) { return s.sheetId === sheetId; });
+        return (_c = (_b = (_a = sheet === null || sheet === void 0 ? void 0 : sheet.columnMetadata) === null || _a === void 0 ? void 0 : _a[columnIndex]) === null || _b === void 0 ? void 0 : _b.size) !== null && _c !== void 0 ? _c : DEFAULT_COLUMN_WIDTH;
+    };
+    /**
+     * Check if a column is hidden
+     */
+    Spreadsheet.prototype.isHiddenColumn = function (sheetId, columnIndex) {
+        var _a, _b, _c;
+        var sheet = this.sheets.find(function (s) { return s.sheetId === sheetId; });
+        var metadata = (_a = sheet === null || sheet === void 0 ? void 0 : sheet.columnMetadata) === null || _a === void 0 ? void 0 : _a[columnIndex];
+        return (_c = (_b = metadata === null || metadata === void 0 ? void 0 : metadata.hiddenByUser) !== null && _b !== void 0 ? _b : metadata === null || metadata === void 0 ? void 0 : metadata.hiddenByFilter) !== null && _c !== void 0 ? _c : false;
+    };
+    /**
+     * Check if a row is hidden
+     */
+    Spreadsheet.prototype.isHiddenRow = function (sheetId, rowIndex) {
+        var _a, _b, _c;
+        var sheet = this.sheets.find(function (s) { return s.sheetId === sheetId; });
+        var metadata = (_a = sheet === null || sheet === void 0 ? void 0 : sheet.rowMetadata) === null || _a === void 0 ? void 0 : _a[rowIndex];
+        return (_c = (_b = metadata === null || metadata === void 0 ? void 0 : metadata.hiddenByUser) !== null && _b !== void 0 ? _b : metadata === null || metadata === void 0 ? void 0 : metadata.hiddenByFilter) !== null && _c !== void 0 ? _c : false;
+    };
+    /**
+     * Generate RFC patches that can be used to
+     * update yJS doc
+     * @returns
+     */
+    Spreadsheet.prototype.generateStatePatches = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var spreadsheetPatches, promises;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spreadsheetPatches = [];
+                        promises = [];
+                        // Sheet data
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeSheetData) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches({}, function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        sheetData: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeSheets
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeSheets) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        sheets: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeTables
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeTables) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        tables: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeCharts
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeCharts) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        charts: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeEmbeds
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeEmbeds) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        embeds: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeNamedRanges
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeNamedRanges) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        namedRanges: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeSharedStrings
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeSharedStrings) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                // Always use Map for shared strings
+                                var base = new Map();
+                                var _a = __read(produceWithPatches(base, function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        sharedStrings: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeDataValidations
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeDataValidations) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        dataValidations: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeConditionalFormats
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeConditionalFormats) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        conditionalFormats: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeCellXfs
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeCellXfs) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        cellXfs: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // onChangeCitations
+                        promises.push(new Promise(function (resolve) {
+                            var _a;
+                            (_a = _this.onChangeCitations) === null || _a === void 0 ? void 0 : _a.call(_this, function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatches.push([
+                                    {
+                                        citations: { patches: patches, inversePatches: inversePatches },
+                                    },
+                                ]);
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                        // Wait for all callbacks to complete
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1:
+                        // Wait for all callbacks to complete
+                        _a.sent();
+                        return [2 /*return*/, spreadsheetPatches];
+                }
+            });
+        });
+    };
+    /**
+     * Get patches as tuples for applyPatchesToYDoc
+     * @param type - The operation type ('redo' or 'undo')
+     * @returns Array of tuples in the format expected by applyPatchesToYDoc
+     */
+    Spreadsheet.prototype.getPatchTuples = function (type) {
+        if (type === void 0) { type = "redo"; }
+        return this._patches.map(function (patch) { return [patch, type]; });
+    };
+    /**
+     * Insert note in a cell
+     * @param args
+     */
+    Spreadsheet.prototype.insertNote = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        insertNote({
+            createHistory: this.createHistory,
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+        }).apply(void 0, __spreadArray([], __read(args), false));
+    };
+    /**
+     * Inserts table row
+     * @param tableView
+     * @param relativeRowIndex
+     * @param rowData
+     */
+    Spreadsheet.prototype.insertTableRow = function (tableView, relativeRowIndex, rowData) {
+        var sheet = this.getSheet(tableView.sheetId);
+        insertTableRow({
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getActiveCell: this.getActiveCell,
+            getDependents: this.getDependents,
+            getSheetName: this.getSheetName,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+        })(tableView, relativeRowIndex, rowData);
+    };
+    /**
+     * Inserts a row
+     * @param sheetId
+     * @param referenceRowIndex
+     * @param numRows
+     */
+    Spreadsheet.prototype.insertRow = function (sheetId, referenceRowIndex, numRows) {
+        var _this = this;
+        if (numRows === void 0) { numRows = 1; }
+        var sheet = this.getSheet(sheetId);
+        insertRow({
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            getDependents: this.getDependents,
+            getGraphNodes: function () { return _this._calculationInterface.getNodes(); },
+            getGraphNodesInSheet: function (sheetId) {
+                return _this._calculationInterface.getNodesInSheet(sheetId);
+            },
+            getSheetName: this.getSheetName,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+        })(sheetId, referenceRowIndex, numRows);
+    };
+    /**
+     * Inserts a column
+     * @param sheetId
+     * @param referenceColumnIndex
+     * @param numColumns
+     */
+    Spreadsheet.prototype.insertColumn = function (sheetId, referenceColumnIndex, numColumns) {
+        var _this = this;
+        if (numColumns === void 0) { numColumns = 1; }
+        var sheet = this.getSheet(sheetId);
+        insertColumn({
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getDependents: this.getDependents,
+            getGraphNodes: function () { return _this._calculationInterface.getNodes(); },
+            getGraphNodesInSheet: function (sheetId) {
+                return _this._calculationInterface.getNodesInSheet(sheetId);
+            },
+            getSelections: this.getSelections,
+            getActiveCell: this.getActiveCell,
+            getSheetName: this.getSheetName,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            tables: this.tables,
+        })(sheetId, referenceColumnIndex, numColumns);
+    };
+    /**
+     * Deletes columns
+     * @param sheetId
+     * @param columnIndexes
+     */
+    Spreadsheet.prototype.deleteColumn = function (sheetId, columnIndexes) {
+        var _this = this;
+        var sheet = this.getSheet(sheetId);
+        deleteColumn({
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getDependents: this.getDependents,
+            getGraphNodes: function () { return _this._calculationInterface.getNodes(); },
+            getGraphNodesInSheet: function (sheetId) {
+                return _this._calculationInterface.getNodesInSheet(sheetId);
+            },
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            getSheetName: this.getSheetName,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            onChangeActiveCell: this.onChangeActiveSheet,
+            onChangeSelections: this.onChangeSelections,
+            onChangeCitations: this.onChangeCitations,
+        })(sheetId, columnIndexes);
+    };
+    /**
+     * Update a range of cells
+     * @param sheetId
+     * @param ranges
+     * @param values
+     */
+    Spreadsheet.prototype.changeBatch = function (sheetId, ranges, values, formatting, citations, changeBatchOptions) {
+        var _this = this;
+        var ssRegistry = this.sharedStringRegistry;
+        var cellXfsRegistry = this.cellXfsRegistry;
+        return changeBatch({
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            tables: this.tables,
+            onChangeTables: this.onChangeTables,
+            locale: this.locale,
+            getUserEnteredValue: this.getUserEnteredStringValue,
+            cellXfsRegistry: cellXfsRegistry,
+            getFormattedValue: this.getFormattedValue,
+            getCellDimensions: this.getCellDimensions,
+            getRowHeight: this.getRowHeight,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            getDependents: this.getDependents,
+            getSheetName: this.getSheetName,
+            isMergedCell: this.isMergedCell,
+            getDataValidationById: this.getDataValidationById,
+            sharedStringRegistry: ssRegistry,
+            getEffectiveValuesFromRange: this.getEffectiveValuesFromRange,
+            onChangeCitations: this.onChangeCitations,
+            onChangeTableColumn: function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return changeTableColumn({
+                    locale: _this.locale,
+                    sharedStringRegistry: ssRegistry,
+                    cellXfsRegistry: cellXfsRegistry,
+                    createHistory: _this.createHistory,
+                    enqueueCalculation: _this.enqueueCalculation,
+                    enqueueGraphOperation: _this.enqueueCalculation,
+                    getDependents: _this.getDependents,
+                    onChangeSheetData: _this.onChangeSheetData,
+                    onChangeTables: _this.onChangeTables,
+                }).apply(void 0, __spreadArray([], __read(args), false));
+            },
+            onChangeCalculatedColumn: function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return changeCalculatedColumn({
+                    locale: _this.locale,
+                    sharedStringRegistry: ssRegistry,
+                    cellXfsRegistry: cellXfsRegistry,
+                    createHistory: _this.createHistory,
+                    enqueueCalculation: _this.enqueueCalculation,
+                    onChangeTables: _this.onChangeTables,
+                    getSheetName: _this.getSheetName,
+                    getUserEnteredValue: _this.getUserEnteredStringValue,
+                    onChangeSheetData: _this.onChangeSheetData,
+                }).apply(void 0, __spreadArray([], __read(args), false));
+            },
+        })(sheetId, ranges, values, formatting, citations, changeBatchOptions);
+    };
+    /**
+     * Stream cell updates into a range
+     * @param sheetId
+     * @param range
+     * @param stream
+     */
+    Spreadsheet.prototype.changeBatchStream = function (sheetId, range, stream) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, changeBatchStream({
+                        onChangeSheetData: this.onChangeSheetData,
+                        enqueueCalculation: this.enqueueCalculation,
+                        locale: this.locale,
+                        getDataValidationById: this.getDataValidationById,
+                        getEffectiveValuesFromRange: this.getEffectiveValuesFromRange,
+                    })(sheetId, range, stream)];
+            });
+        });
+    };
+    /**
+     * Change cell formatting
+     * @param args
+     */
+    Spreadsheet.prototype.changeFormatting = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        changeFormatting({
+            getFormattedValue: this.getFormattedValue,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            locale: this.locale,
+            cellXfsRegistry: this.cellXfsRegistry,
+            getCellDimensions: this.getCellDimensions,
+            getRowHeight: this.getRowHeight,
+        }).apply(void 0, __spreadArray([], __read(args), false));
+    };
+    /**
+     * Change cell border
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param location
+     * @param color
+     * @param style
+     */
+    Spreadsheet.prototype.changeBorder = function (sheetId, activeCell, selections, location, color, style) {
+        if (style === void 0) { style = "solid"; }
+        changeBorder({
+            getFormattedValue: this.getFormattedValue,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            locale: this.locale,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections, location, color, style);
+    };
+    /**
+     * Create a new table spec
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param tableSpec
+     * @param theme
+     * @param bandedRange
+     */
+    Spreadsheet.prototype.createTable = function (sheetId, activeCell, selections, tableSpec, theme, bandedRange) {
+        var sheet = this.getSheet(sheetId);
+        return createTable({
+            locale: this.locale,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            getDependents: this.getDependents,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onRequestCalculate: this.onRequestCalculate,
+            getEffectiveValue: this.getEffectiveValue,
+            getFormattedValue: this.getFormattedValue,
+            getContentfulRangeAroundCell: this.getContentfulRangeAroundCell,
+            getSheetName: this.getSheetName,
+            theme: defaultSpreadsheetTheme,
+        })(sheetId, activeCell, selections, tableSpec, theme, bandedRange);
+    };
+    /**
+     * Updates an existing table spec
+     * @param sheetId
+     * @param updatedTable
+     * @param previousTable
+     */
+    Spreadsheet.prototype.updateTable = function (sheetId, tableId, updatedTable) {
+        return updateTable({
+            locale: this.locale,
+            tables: this.tables,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getDependents: this.getDependents,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeTables: this.onChangeTables,
+            getFormattedValue: this.getFormattedValue,
+        })(sheetId, tableId, updatedTable);
+    };
+    /**
+     * Removes an existing table view
+     * @param tableView
+     */
+    Spreadsheet.prototype.removeTable = function (tableView) {
+        removeTable({
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getDependents: this.getDependents,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+        })(tableView);
+    };
+    /**
+     * Insert a column into a table
+     * @param tableView
+     * @param dimensionIndex
+     * @param direction
+     */
+    Spreadsheet.prototype.insertTableColumn = function (tableView, dimensionIndex, direction) {
+        var sheet = this.getSheet(tableView.sheetId);
+        insertTableColumn({
+            tables: this.tables,
+            columnCount: sheet.columnCount,
+            rowCount: sheet.rowCount,
+            locale: this.locale,
+            createHistory: this.createHistory,
+            onChangeTables: this.onChangeTables,
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getDependents: this.getDependents,
+            getSheetName: this.getSheetName,
+        })(tableView, dimensionIndex, direction);
+    };
+    /**
+     * Delete a column from a table
+     * @param tableView
+     * @param dimensionIndex
+     */
+    Spreadsheet.prototype.deleteTableColumn = function (tableView, dimensionIndex) {
+        var sheet = this.getSheet(tableView.sheetId);
+        deleteTableColumn({
+            columnCount: sheet.columnCount,
+            rowCount: sheet.rowCount,
+            locale: this.locale,
+            getSheetName: this.getSheetName,
+            createHistory: this.createHistory,
+            onChangeTables: this.onChangeTables,
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            getDependents: this.getDependents,
+        })(tableView, dimensionIndex);
+    };
+    /**
+     * Delete rows
+     * @param sheetId
+     * @param rowIndexes
+     */
+    Spreadsheet.prototype.deleteRow = function (sheetId, rowIndexes) {
+        var _this = this;
+        var sheet = this.getSheet(sheetId);
+        deleteRow({
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            getDependents: this.getDependents,
+            getGraphNodes: function () { return _this._calculationInterface.getNodes(); },
+            getGraphNodesInSheet: function (sheetId) {
+                return _this._calculationInterface.getNodesInSheet(sheetId);
+            },
+            getSheetName: this.getSheetName,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            onChangeActiveCell: this.onChangeActiveSheet,
+            onChangeSelections: this.onChangeSelections,
+        })(sheetId, rowIndexes);
+    };
+    /**
+     * Delete selected cells and shift left
+     */
+    Spreadsheet.prototype.deleteCellsShiftLeft = function (sheetId, activeCell, selections) {
+        var sheet = this.getSheet(sheetId);
+        deleteCellsShiftLeft({
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            getDependents: this.getDependents,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+        })(sheetId, activeCell, selections);
+    };
+    /**
+     * Delete selected cells and shift up
+     */
+    Spreadsheet.prototype.deleteCellsShiftUp = function (sheetId, activeCell, selections) {
+        var sheet = this.getSheet(sheetId);
+        deleteCellsShiftUp({
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            getDependents: this.getDependents,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+        })(sheetId, activeCell, selections);
+    };
+    /** Freeze a row index */
+    Spreadsheet.prototype.freezeRow = function (sheetId, rowIndex) {
+        freezeRow({
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            onChangeCharts: this.onChangeCharts,
+            onChangeEmbeds: this.onChangeEmbeds,
+        })(sheetId, rowIndex);
+    };
+    /** Freeze a column index */
+    Spreadsheet.prototype.freezeColumn = function (sheetId, columnIndex) {
+        freezeColumn({
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            onChangeCharts: this.onChangeCharts,
+            onChangeEmbeds: this.onChangeEmbeds,
+        })(sheetId, columnIndex);
+    };
+    /** Hide columns */
+    Spreadsheet.prototype.hideColumns = function (sheetId, columnIndexes) {
+        var sheet = this.getSheet(sheetId);
+        hideColumns({
+            createHistory: this.createHistory,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            onChangeActiveCell: this.onChangeActiveCell,
+            onChangeSelections: this.onChangeSelections,
+            onChangeSheets: this.onChangeSheets,
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            getNextFocusableCell: undefined,
+        })(sheetId, columnIndexes);
+    };
+    /** Hide rows */
+    Spreadsheet.prototype.hideRows = function (sheetId, rowIndexes) {
+        var sheet = this.getSheet(sheetId);
+        hideRows({
+            createHistory: this.createHistory,
+            getActiveCell: this.getActiveCell,
+            getSelections: this.getSelections,
+            onChangeActiveCell: this.onChangeActiveCell,
+            onChangeSelections: this.onChangeSelections,
+            onChangeSheets: this.onChangeSheets,
+            columnCount: sheet.columnCount,
+            rowCount: sheet.rowCount,
+            getNextFocusableCell: undefined,
+        })(sheetId, rowIndexes);
+    };
+    /**
+     * Apply fill operation programmatically
+     */
+    Spreadsheet.prototype.applyFill = function (sheetId, activeCell, fillSelection, selections, fillableSelections, fillType) {
+        return __awaiter(this, void 0, void 0, function () {
+            var getCellData, ssRegistry;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        getCellData = function (sId, r, c) { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = _this._sheetData) === null || _a === void 0 ? void 0 : _a[sId]) === null || _b === void 0 ? void 0 : _b[r]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[c]; };
+                        ssRegistry = this.sharedStringRegistry;
+                        return [4 /*yield*/, applyFill({
+                                locale: this.locale,
+                                cellXfsRegistry: this.cellXfsRegistry,
+                                // Fallback safe getters
+                                getCellData: getCellData,
+                                getEffectiveValue: this.getEffectiveValue,
+                                getFormattedValue: this.getFormattedValue,
+                                getAutoFillValues: getAutoFillValues,
+                                enqueueCalculation: this.enqueueCalculation,
+                                onChangeSheetData: this.onChangeSheetData,
+                                createHistory: this.createHistory,
+                                getSheetName: this.getSheetName,
+                                sharedStringRegistry: ssRegistry,
+                            })(sheetId, activeCell, fillSelection, selections, fillableSelections, fillType)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Spreadsheet.prototype.createNewSheet = function (sheetSpec) {
+        return createNewSheet({
+            sheetId: this.activeSheetId,
+            createHistory: this.createHistory,
+            onChangeActiveSheet: this.onChangeActiveSheet,
+            onChangeSheets: this.onChangeSheets,
+            sheets: this.sheets,
+        })(sheetSpec);
+    };
+    Spreadsheet.prototype.updateSheet = function (sheetId, sheetSpec) {
+        var _this = this;
+        return updateSheet({
+            sheets: this.sheets,
+            locale: this.locale,
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            onChangeSheetData: this.onChangeSheetData,
+            getGraphNodes: function () { return _this._calculationInterface.getNodes(); },
+            // Use raw getPrecedents without filtering to correctly handle cross-sheet references
+            getPrecedents: function (source) {
+                return _this._calculationInterface.getPrecedents(source);
+            },
+        })(sheetId, sheetSpec);
+    };
+    /**
+     * Delete a sheet
+     * @param sheetId
+     */
+    Spreadsheet.prototype.deleteSheet = function (sheetId) {
+        deleteSheet({
+            sheets: this.sheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeActiveSheet: function () { },
+            onChangeSheets: this.onChangeSheets,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+        })(sheetId);
+    };
+    /**
+     * Create conditional formatting rule
+     * @param rule
+     */
+    Spreadsheet.prototype.createConditionalFormattingRule = function (rule) {
+        createConditionalFormattingRule({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(rule);
+    };
+    /**
+     * Update conditional formatting rule
+     * @param updatedRule
+     * @param previousRule
+     */
+    Spreadsheet.prototype.updateConditionalFormattingRule = function (updatedRule, previousRule) {
+        updateConditionalFormattingRule({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(updatedRule, previousRule);
+    };
+    /**
+     * Delete conditional formatting rule
+     * @param rule
+     */
+    Spreadsheet.prototype.deleteConditionalFormattingRule = function (rule) {
+        deleteConditionalFormattingRule({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(rule);
+    };
+    /**
+     * Preview conditional formatting rule
+     * @param rule
+     */
+    Spreadsheet.prototype.previewConditionalFormattingRule = function (rule) {
+        previewConditionalFormattingRule({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(rule);
+    };
+    /**
+     * Create data validation rule
+     * @param rule
+     */
+    Spreadsheet.prototype.createDataValidationRule = function (rule) {
+        createDataValidationRule({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeDataValidations: this.onChangeDataValidations,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getSheetName: this.getSheetName,
+            cellXfsRegistry: this.cellXfsRegistry,
+            sharedStringRegistry: this.sharedStringRegistry,
+        })(rule);
+    };
+    /**
+     * Update data validation rule
+     * @param rule
+     * @param previousRule
+     */
+    Spreadsheet.prototype.updateDataValidationRule = function (rule, previousRule) {
+        updateDataValidationRule({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeDataValidations: this.onChangeDataValidations,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getSheetName: this.getSheetName,
+            cellXfsRegistry: this.cellXfsRegistry,
+            sharedStringRegistry: this.sharedStringRegistry,
+        })(rule, previousRule);
+    };
+    /**
+     * Delete data validation rule
+     * @param rule
+     */
+    Spreadsheet.prototype.deleteDataValidationRule = function (rule) {
+        deleteDataValidationRule({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeDataValidations: this.onChangeDataValidations,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getSheetName: this.getSheetName,
+            cellXfsRegistry: this.cellXfsRegistry,
+            sharedStringRegistry: this.sharedStringRegistry,
+        })(rule);
+    };
+    /**
+     * Delete all data validation rules
+     * @param rules
+     */
+    Spreadsheet.prototype.deleteDataValidationRules = function (rules) {
+        deleteDataValidationRules({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeDataValidations: this.onChangeDataValidations,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            getSheetName: this.getSheetName,
+            cellXfsRegistry: this.cellXfsRegistry,
+            sharedStringRegistry: this.sharedStringRegistry,
+        })(rules);
+    };
+    /**
+     * Change cell decimals
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param type
+     */
+    Spreadsheet.prototype.changeDecimals = function (sheetId, activeCell, selections, type) {
+        changeDecimals({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+            enqueueCalculation: this.enqueueCalculation,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections, type);
+    };
+    /**
+     * Change sheet tab color
+     * @param sheetId
+     * @param color
+     */
+    Spreadsheet.prototype.changeSheetTabcolor = function (sheetId, color) {
+        changeSheetTabcolor({
+            onChangeSheets: this.onChangeSheets,
+            createHistory: this.createHistory,
+        })(sheetId, color);
+    };
+    /**
+     * Change theme
+     * @param theme
+     */
+    Spreadsheet.prototype.changeTheme = function (theme) {
+        changeTheme({
+            createHistory: this.createHistory,
+            onChangeTheme: function () { },
+        })(theme);
+    };
+    /**
+     * Clear formatting
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    Spreadsheet.prototype.clearFormatting = function (sheetId, activeCell, selections) {
+        clearFormatting({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections);
+    };
+    /**
+     * Remove duplicate rows
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    Spreadsheet.prototype.removeDuplicates = function (sheetId, activeCell, selections) {
+        return removeDuplicates({
+            locale: this.locale,
+            getFormattedValue: this.getFormattedValue,
+            onChangeSheetData: this.onChangeSheetData,
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+        })(sheetId, activeCell, selections);
+    };
+    /**
+     * Increase indent
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    Spreadsheet.prototype.increaseIndent = function (sheetId, activeCell, selections) {
+        increaseIndent({
+            locale: this.locale,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections);
+    };
+    /**
+     * Decrease indent
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    Spreadsheet.prototype.decreaseIndent = function (sheetId, activeCell, selections) {
+        decreaseIndent({
+            locale: this.locale,
+            enqueueCalculation: this.enqueueCalculation,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+            cellXfsRegistry: this.cellXfsRegistry,
+        })(sheetId, activeCell, selections);
+    };
+    /**
+     * Create named range
+     * @param sheetId
+     * @param namedRange
+     */
+    Spreadsheet.prototype.createNamedRange = function (sheetId, namedRange) {
+        createNamedRange({
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeNamedRanges: this.onChangeNamedRanges,
+        })(sheetId, namedRange);
+    };
+    /**
+     * Delete named range
+     * @param id
+     */
+    Spreadsheet.prototype.deleteNamedRange = function (id) {
+        deleteNamedRange({
+            getDependents: this.getDependents,
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            onChangeNamedRanges: this.onChangeNamedRanges,
+        })(id);
+    };
+    /**
+     * Delete cells
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param clearType - "contents" (default), "formats", or "all"
+     */
+    Spreadsheet.prototype.deleteCells = function (sheetId, activeCell, selections, clearType) {
+        if (clearType === void 0) { clearType = "contents"; }
+        var sheet = this.getSheet(sheetId);
+        deleteCells({
+            locale: this.locale,
+            rowCount: sheet.rowCount,
+            cellXfsRegistry: this.cellXfsRegistry,
+            getDependents: this.getDependents,
+            getDataRowCount: function () { return sheet.rowCount; },
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onChangeActiveCell: function () { },
+            enqueueCalculation: this.enqueueCalculation,
+            createHistory: this.createHistory,
+            isArrayFormula: function () { return false; },
+            getRowHeight: this.getRowHeight,
+        })(sheetId, activeCell, selections, clearType);
+    };
+    /**
+     * Delete table row
+     * @param tableView
+     * @param rowIndexes
+     */
+    Spreadsheet.prototype.deleteTableRow = function (tableView, rowIndexes) {
+        var sheet = this.getSheet(tableView.sheetId);
+        deleteTableRow({
+            rowCount: sheet.rowCount,
+            columnCount: sheet.columnCount,
+            locale: this.locale,
+            getDependents: this.getDependents,
+            getSheetName: this.getSheetName,
+            createHistory: this.createHistory,
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            enqueueCalculation: this.enqueueCalculation,
+            enqueueStructureChange: this.enqueueStructureChange,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+        })(tableView, rowIndexes);
+    };
+    /**
+     * Duplicate sheet
+     * @param sheetId
+     */
+    Spreadsheet.prototype.duplicateSheet = function (sheetId, newSheetId) {
+        return duplicateSheet({
+            locale: this.locale,
+            maxSheetCount: 100,
+            sheets: this.sheets,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeSheets: this.onChangeSheets,
+            onChangeTables: this.onChangeTables,
+            onChangeCharts: this.onChangeCharts,
+            onChangeEmbeds: this.onChangeEmbeds,
+            onChangeConditionalFormats: this.onChangeConditionalFormats,
+            onChangeDataValidations: this.onChangeDataValidations,
+            onChangeActiveSheet: function () { },
+            enqueueGraphOperation: this.enqueueGraphOperation,
+            createHistory: this.createHistory,
+        })(sheetId, newSheetId);
+    };
+    /**
+     * Create embed
+     * @param embedId
+     */
+    Spreadsheet.prototype.createEmbed = function (spec) {
+        createEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(spec);
+    };
+    /**
+     * Delete embed
+     * @param embedId
+     */
+    Spreadsheet.prototype.deleteEmbed = function (embedId) {
+        deleteEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(embedId);
+    };
+    /**
+     * Update embed
+     * @param embed
+     */
+    Spreadsheet.prototype.updateEmbed = function (embed) {
+        updateEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(embed);
+    };
+    /**
+     * Move embed
+     * @param embedId
+     * @param sheetId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     */
+    Spreadsheet.prototype.moveEmbed = function (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels) {
+        moveEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels);
+    };
+    /**
+     * Resize embed
+     * @param embedId
+     * @param sheetId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     * @param width
+     * @param height
+     */
+    Spreadsheet.prototype.resizeEmbed = function (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) {
+        resizeEmbed({
+            onChangeEmbeds: this.onChangeEmbeds,
+            createHistory: this.createHistory,
+        })(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height);
+    };
+    /**
+     * Check if chart operations are available
+     * @returns true if @rowsncolumns/charts package is installed
+     */
+    Spreadsheet.prototype.isChartsAvailable = function () {
+        return isChartsAvailable();
+    };
+    /**
+     * Create a chart
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param chartSpec
+     */
+    Spreadsheet.prototype.createChart = function (sheetId, activeCell, selections, chartSpec) {
+        safeCreateChart({
+            onChangeCharts: this.onChangeCharts,
+            getFormattedValue: this.getFormattedValue,
+            getEffectiveValue: this.getEffectiveValue,
+            createHistory: this.createHistory,
+        })(sheetId, activeCell, selections, chartSpec);
+    };
+    /**
+     * Delete a chart
+     * @param chartId
+     */
+    Spreadsheet.prototype.deleteChart = function (chartId) {
+        safeDeleteChart({
+            onChangeCharts: this.onChangeCharts,
+            createHistory: this.createHistory,
+        })(chartId);
+    };
+    /**
+     * Move a chart
+     * @param chartId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     */
+    Spreadsheet.prototype.moveChart = function (chartId, anchorCell, offsetXPixels, offsetYPixels) {
+        safeMoveChart({
+            onChangeCharts: this.onChangeCharts,
+            createHistory: this.createHistory,
+        })(chartId, anchorCell, offsetXPixels, offsetYPixels);
+    };
+    /**
+     * Resize a chart
+     * @param chartId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     * @param width
+     * @param height
+     */
+    Spreadsheet.prototype.resizeChart = function (chartId, anchorCell, offsetXPixels, offsetYPixels, width, height) {
+        safeResizeChart({
+            onChangeCharts: this.onChangeCharts,
+            createHistory: this.createHistory,
+        })(chartId, anchorCell, offsetXPixels, offsetYPixels, width, height);
+    };
+    /**
+     * Update a chart
+     * @param chart
+     */
+    Spreadsheet.prototype.updateChart = function (chart) {
+        safeUpdateChart({
+            onChangeCharts: this.onChangeCharts,
+            createHistory: this.createHistory,
+        })(chart);
+    };
+    /**
+     * Auto fit rows or columns
+     * @param sheetId
+     * @param indexes
+     * @param axis
+     * @returns
+     */
+    Spreadsheet.prototype.autoResize = function (sheetId, indexes, axis) {
+        return autoResize({
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            getColumnWidth: this.getColumnWidth,
+            getRowHeight: this.getRowHeight,
+            getActiveCell: this.getActiveCell,
+        })(sheetId, indexes, axis);
+    };
+    /**
+     * Resize row or column
+     * @param sheetId
+     * @param indexes
+     * @param dimension
+     * @param axis
+     * @returns
+     */
+    Spreadsheet.prototype.resize = function (sheetId, indexes, dimension, axis) {
+        return resize({
+            createHistory: this.createHistory,
+            onChangeSheets: this.onChangeSheets,
+            getRowHeight: this.getRowHeight,
+            getActiveCell: this.getActiveCell,
+            getCellDimensions: this.getCellDimensions,
+            isMergedCell: this.isMergedCell,
+        })(sheetId, indexes, dimension, axis);
+    };
+    Spreadsheet.prototype.deletePivotTable = function (pivotId, database) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, safeDeletePivotTable({
+                        activeCell: this.getActiveCell(),
+                        enqueueCalculation: this.enqueueCalculation,
+                        onChangeActiveCell: this.onChangeActiveSheet,
+                        pivotTables: this.pivotTables,
+                        sheetId: this.activeSheetId,
+                        cellXfsRegistry: this.cellXfsRegistry,
+                        database: database,
+                        locale: this.locale,
+                        onChangeSheetData: this.onChangeSheetData,
+                        onChangeSheets: this.onChangeSheets,
+                        // onCreateNewSheet:,
+                        createHistory: this.createHistory,
+                        onChangePivotTables: this.onChangePivotTables,
+                        getColumnWidth: this.getColumnWidth,
+                    })(pivotId)];
+            });
+        });
+    };
+    Spreadsheet.prototype.createPivotTable = function (pivotTable, createNewSheet, database) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, safeCreatePivotTable({
+                            activeCell: this.getActiveCell(),
+                            enqueueCalculation: this.enqueueCalculation,
+                            onChangeActiveCell: this.onChangeActiveSheet,
+                            pivotTables: this.pivotTables,
+                            sheetId: this.activeSheetId,
+                            cellXfsRegistry: this.cellXfsRegistry,
+                            database: database,
+                            locale: this.locale,
+                            onChangeSheetData: this.onChangeSheetData,
+                            onChangeSheets: this.onChangeSheets,
+                            // onCreateNewSheet:,
+                            createHistory: this.createHistory,
+                            onChangePivotTables: this.onChangePivotTables,
+                            getGridValues: this.getGridValuesForPivot,
+                            getColumnWidth: this.getColumnWidth,
+                        })(pivotTable, createNewSheet)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Create a new citation and attach it to a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     * @param citation
+     */
+    Spreadsheet.prototype.createCitation = function (sheetId, rowIndex, columnIndex, citation) {
+        createCitation({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            onChangeCitations: this.onChangeCitations,
+            createHistory: this.createHistory,
+        })(sheetId, rowIndex, columnIndex, citation);
+    };
+    /**
+     * Create multiple citations in a batch (adds to citations array only)
+     * @param cellCitations
+     */
+    Spreadsheet.prototype.createBatchCitations = function (citations) {
+        createBatchCitations({
+            onChangeCitations: this.onChangeCitations,
+            createHistory: this.createHistory,
+        })(citations);
+    };
+    /**
+     * Update an existing citation
+     * @param citationId
+     * @param updates
+     */
+    Spreadsheet.prototype.updateCitation = function (citationId, updates) {
+        updateCitation({
+            onChangeCitations: this.onChangeCitations,
+            createHistory: this.createHistory,
+        })(citationId, updates);
+    };
+    /**
+     * Remove a citation reference from a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    Spreadsheet.prototype.removeCitationFromCell = function (sheetId, rowIndex, columnIndex) {
+        removeCitationFromCell({
+            locale: this.locale,
+            onChangeSheetData: this.onChangeSheetData,
+            createHistory: this.createHistory,
+        })(sheetId, rowIndex, columnIndex);
+    };
+    /**
+     * Delete a citation completely (removes from citations array)
+     * Note: Cells with this citationId will still have the reference
+     * @param citationId
+     */
+    Spreadsheet.prototype.deleteCitation = function (citationId) {
+        deleteCitation({
+            onChangeCitations: this.onChangeCitations,
+            createHistory: this.createHistory,
+        })(citationId);
+    };
+    return Spreadsheet;
+}());
+export { Spreadsheet };
+/**
+ * Simple sheet interface for some getters
+ */
+var SheetInterface = /** @class */ (function () {
+    function SheetInterface(sheet) {
+        this.sheet = sheet;
+    }
+    Object.defineProperty(SheetInterface.prototype, "name", {
+        get: function () {
+            var _a;
+            return (_a = this.sheet) === null || _a === void 0 ? void 0 : _a.title;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SheetInterface.prototype, "rowCount", {
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.sheet) === null || _a === void 0 ? void 0 : _a.rowCount) !== null && _b !== void 0 ? _b : DEFAULT_ROW_COUNT;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SheetInterface.prototype, "columnCount", {
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.sheet) === null || _a === void 0 ? void 0 : _a.columnCount) !== null && _b !== void 0 ? _b : DEFAULT_COLUMN_COUNT;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SheetInterface.prototype, "frozenColumns", {
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.sheet) === null || _a === void 0 ? void 0 : _a.frozenColumnCount) !== null && _b !== void 0 ? _b : 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SheetInterface.prototype, "frozenRows", {
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.sheet) === null || _a === void 0 ? void 0 : _a.frozenRowCount) !== null && _b !== void 0 ? _b : 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SheetInterface;
+}());