@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/sheet-cell.js

@@ -0,0 +1,1809 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { lexify, tokenVocabulary } from "@rowsncolumns/calculator";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { getCellEffectiveValue, getCellFormattedValue, getCellUserEnteredFormat, getCellUserEnteredValue, getExtendedValueBool, getExtendedValueError, getExtendedValueFormula, getExtendedValueNumber, getExtendedValueString, getStyleId, balanceFormula, cellToAddress, getCellXfsKey, getCurrentLocale, getDefaultDateFormat, getDefaultTimeFormat, desanitizeSheetName, isAlternateFormula, isDatePattern, isDateTimePattern, isNil, isTextPattern, isValidFormula, looksLikeMarkdown, } from "@rowsncolumns/utils";
+import isEqual from "lodash/isEqual";
+import set from "lodash/set";
+import { isDataValidationFormulaRule } from "./api/data-validation";
+import { checkBooleanRule } from "./api/validation";
+import { createFormattedValue, createNumberValue, detectNumberFormatPattern, detectNumberFormatType, detectValueType, detectValueTypeAndPattern, isMultiline, isNumber, isValidURLorEmail, } from "./api/datatype";
+import { changeDecimals, getDecimalPlaces, pattern_number, pattern_number_thousands, } from "./api/decimals";
+import { formulaToRelativeReference, updateColumnName, updateNamedRangeName, updateSheetName, } from "./api/formula";
+import { getLocaleSeparators } from "./api/intl";
+import { AWAITING_CALCULATION } from "./helpers";
+export var defaultSheetId = 1;
+export var defaultCellCoords = { rowIndex: 1, columnIndex: 1 };
+// Add this helper function to determine if an object is a StyleReference
+export function isStyleReference(obj) {
+    return obj && typeof obj === "object" && ("styleId" in obj || "sid" in obj);
+}
+/**
+ * Marker persisted as `fv` on cells whose calculation is in flight (set by
+ * `setLoading()`). Exported so other modules can detect the loading state
+ * from cellData without a stringly-typed comparison.
+ */
+export var LOADING_VALUE = "Loading...";
+var excludeKeys = new Set([
+    "userEnteredValue",
+    "ue",
+    "effectiveValue",
+    "ev",
+    "formattedValue",
+    "fv",
+    "ss",
+    "effectiveFormat",
+    "ef",
+    "userEnteredFormat",
+    "uf",
+    "dataValidation",
+    "imageUrl",
+    "hyperlink",
+    "metaType",
+    "note",
+    "citationId",
+    "commentThreadId",
+    "expandable",
+    "expanded",
+    "groupKeys",
+    "pivotId",
+    "conditionalFormattingResultById",
+    "dataValidationResult",
+]);
+var hasExcelTextPrefix = function (value) {
+    return typeof value === "string" && value.startsWith("'") && value.length > 1;
+};
+/**
+ * Both halves of a `NumberFormat` can encode "General" two ways: as a
+ * missing field, or as the literal sentinel value (`"GENERAL"` for type,
+ * `"General"` for pattern). These two predicates normalize both forms so
+ * the rules above don't have to repeat `(!x || x === "…")` everywhere.
+ */
+var hasGeneralType = function (format) {
+    return !format.type || format.type === "GENERAL";
+};
+var hasGeneralPattern = function (format) {
+    return !format.pattern || format.pattern === "General";
+};
+/**
+ * "General" means the cell has no explicit number format applied. Excel's
+ * auto-format-on-input rule triggers only for General cells; any other
+ * format is preserved as-is.
+ */
+var isGeneralNumberFormat = function (format) { return !format || (hasGeneralType(format) && hasGeneralPattern(format)); };
+var stripExcelTextPrefix = function (value) { return value.slice(1); };
+var getHyperlinkTarget = function (hyperlink) {
+    if (typeof hyperlink === "string") {
+        return hyperlink;
+    }
+    if (hyperlink.kind === "external") {
+        return hyperlink.url;
+    }
+    return hyperlink.location;
+};
+var getHyperlinkDisplay = function (hyperlink) {
+    if (typeof hyperlink === "string") {
+        return undefined;
+    }
+    return hyperlink.display;
+};
+var SheetCell = /** @class */ (function () {
+    function SheetCell(sheetId, coords, cellData, options) {
+        if (sheetId === void 0) { sheetId = defaultSheetId; }
+        if (coords === void 0) { coords = defaultCellCoords; }
+        this.assign(sheetId, coords, cellData, options);
+        this.ensureFormatsMutable();
+    }
+    SheetCell.prototype.setVersion = function (version) {
+        this.version = version !== null && version !== void 0 ? version : undefined;
+    };
+    SheetCell.prototype.setUpdatedAt = function (timestamp) {
+        this.updatedAt = timestamp !== null && timestamp !== void 0 ? timestamp : undefined;
+    };
+    SheetCell.setDefaultSharedStrings = function (sharedStrings) {
+        SheetCell.defaultSharedStrings = sharedStrings;
+    };
+    SheetCell.setDefaultEnableAtFormula = function (enable) {
+        SheetCell.defaultEnableAtFormula = enable !== null && enable !== void 0 ? enable : false;
+    };
+    SheetCell.prototype.setLocale = function (locale) {
+        this.locale = locale;
+    };
+    SheetCell.prototype.setUse1904 = function (use1904) {
+        this.use1904 = use1904;
+    };
+    SheetCell.prototype.assign = function (sheetId, coords, cellData, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        if (sheetId === void 0) { sheetId = defaultSheetId; }
+        if (coords === void 0) { coords = defaultCellCoords; }
+        var _r = options !== null && options !== void 0 ? options : {}, getRangeValues = _r.getRangeValues, _s = _r.locale, locale = _s === void 0 ? getCurrentLocale() : _s, use1904 = _r.use1904, lenientGrouping = _r.lenientGrouping, enableAtFormula = _r.enableAtFormula, cellXfsRegistry = _r.cellXfsRegistry, getDataValidationById = _r.getDataValidationById, sharedStringRegistry = _r.sharedStringRegistry;
+        this.sheetId = sheetId;
+        this.coords = coords;
+        this.cellData = cellData;
+        this.cellXfsRegistry = cellXfsRegistry;
+        this.sharedStringRegistry = sharedStringRegistry;
+        this.sharedStrings =
+            (_b = (_a = sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.getSharedStrings()) !== null && _a !== void 0 ? _a : SheetCell.defaultSharedStrings) !== null && _b !== void 0 ? _b : this.sharedStrings;
+        this.sharedStringIndex = (_c = cellData === null || cellData === void 0 ? void 0 : cellData.ss) !== null && _c !== void 0 ? _c : undefined;
+        this.use1904 = use1904;
+        this.lenientGrouping = lenientGrouping;
+        this.enableAtFormula =
+            (_d = enableAtFormula !== null && enableAtFormula !== void 0 ? enableAtFormula : SheetCell.defaultEnableAtFormula) !== null && _d !== void 0 ? _d : false;
+        var userEnteredFormat = cellData
+            ? getCellUserEnteredFormat(cellData)
+            : undefined;
+        // Legacy `ef` is still readable from cellData for backwards-compat at
+        // the renderer layer (see `useSheetProperties.getEffectiveFormat`),
+        // but `SheetCell` no longer tracks it as in-memory state. `uf` is the
+        // single source of truth.
+        this.userEnteredFormat = isStyleReference(userEnteredFormat)
+            ? cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getCellXfsFromStyleId(getStyleId(userEnteredFormat))
+            : userEnteredFormat;
+        this.originalUserEnteredFormat = userEnteredFormat;
+        this.userEnteredValue = cellData
+            ? getCellUserEnteredValue(cellData)
+            : undefined;
+        this.defaultPattern = "General";
+        this.effectiveValue = cellData
+            ? getCellEffectiveValue(cellData)
+            : undefined;
+        this.formattedValue = cellData
+            ? getCellFormattedValue(cellData)
+            : undefined;
+        this.textFormatRuns = Array.isArray(cellData === null || cellData === void 0 ? void 0 : cellData.tf)
+            ? __spreadArray([], __read(cellData.tf), false)
+            : undefined;
+        if (this.sharedStringIndex != null) {
+            this.hydrateSharedStringValue(this.sharedStringIndex);
+        }
+        var cellDataValidation = cellData === null || cellData === void 0 ? void 0 : cellData.dataValidation;
+        // Backwards compatiblity
+        // Object based
+        if (cellDataValidation && typeof cellDataValidation === "object") {
+            this.dataValidationId = cellDataValidation.id;
+            this.dataValidationRule = cellDataValidation;
+        }
+        else {
+            // New
+            this.dataValidationId = cellDataValidation !== null && cellDataValidation !== void 0 ? cellDataValidation : undefined;
+            this.dataValidationRule = this.dataValidationId
+                ? getDataValidationById === null || getDataValidationById === void 0 ? void 0 : getDataValidationById(this.dataValidationId)
+                : undefined;
+        }
+        this.conditionalFormattingResultById =
+            cellData === null || cellData === void 0 ? void 0 : cellData.conditionalFormattingResultById;
+        this.dataValidationResult = cellData === null || cellData === void 0 ? void 0 : cellData.dataValidationResult;
+        this.imageUrl = (_e = cellData === null || cellData === void 0 ? void 0 : cellData.imageUrl) !== null && _e !== void 0 ? _e : undefined;
+        this.isLoading = false;
+        this.loadingValue = LOADING_VALUE;
+        this.hyperlink = (_f = cellData === null || cellData === void 0 ? void 0 : cellData.hyperlink) !== null && _f !== void 0 ? _f : undefined;
+        this.metaType = (_g = cellData === null || cellData === void 0 ? void 0 : cellData.metaType) !== null && _g !== void 0 ? _g : undefined;
+        this.note = (_h = cellData === null || cellData === void 0 ? void 0 : cellData.note) !== null && _h !== void 0 ? _h : undefined;
+        this.commentThreadId = (_j = cellData === null || cellData === void 0 ? void 0 : cellData.commentThreadId) !== null && _j !== void 0 ? _j : undefined;
+        this.citationId = (_k = cellData === null || cellData === void 0 ? void 0 : cellData.citationId) !== null && _k !== void 0 ? _k : undefined;
+        this.expandable = (_l = cellData === null || cellData === void 0 ? void 0 : cellData.expandable) !== null && _l !== void 0 ? _l : undefined;
+        this.expanded = (_m = cellData === null || cellData === void 0 ? void 0 : cellData.expanded) !== null && _m !== void 0 ? _m : undefined;
+        this.getRangeValues = getRangeValues;
+        this.locale = locale;
+        this.pivotId = cellData === null || cellData === void 0 ? void 0 : cellData.pivotId;
+        this.groupKeys = cellData === null || cellData === void 0 ? void 0 : cellData.groupKeys;
+        this.version = (_o = cellData === null || cellData === void 0 ? void 0 : cellData.version) !== null && _o !== void 0 ? _o : undefined;
+        this.updatedAt = (_p = cellData === null || cellData === void 0 ? void 0 : cellData.updatedAt) !== null && _p !== void 0 ? _p : undefined;
+        this.arrayFormulaRef = (_q = cellData === null || cellData === void 0 ? void 0 : cellData.af) !== null && _q !== void 0 ? _q : undefined;
+        this.sharedFormulaSpec = (cellData === null || cellData === void 0 ? void 0 : cellData.sf)
+            ? __assign({ si: cellData.sf.si }, (cellData.sf.ref ? { ref: cellData.sf.ref } : {})) : undefined;
+        return this;
+    };
+    Object.defineProperty(SheetCell.prototype, "key", {
+        get: function () {
+            return SheetCell.generateCellKey(this.sheetId, this.coords.rowIndex, this.coords.columnIndex);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SheetCell.prototype.cloneWithFormatting = function () {
+        // Delete cell contents
+        this.deleteContents({ preserveTextNumberFormat: true });
+        return this;
+    };
+    SheetCell.prototype.updateNote = function (note) {
+        this.note = note;
+    };
+    SheetCell.prototype.updateCommentThreadId = function (commentThreadId) {
+        this.commentThreadId = commentThreadId;
+    };
+    SheetCell.prototype.clearCommentThreadId = function () {
+        this.commentThreadId = undefined;
+    };
+    SheetCell.prototype.updateCitationId = function (citationId) {
+        this.citationId = citationId;
+    };
+    SheetCell.prototype.clearCitationId = function () {
+        this.citationId = undefined;
+    };
+    SheetCell.generateCellKey = function (sheetId, rowIndex, columnIndex) {
+        return "".concat(sheetId, "!").concat(cellToAddress({
+            rowIndex: rowIndex,
+            columnIndex: columnIndex,
+        }));
+    };
+    /**
+     * Clears the cell's content (value, formatted value, links,
+     * notes, comments, shared-string refs, etc.).
+     *
+     * Formatting behavior is intentionally Del-key-compatible by
+     * default — Excel's Delete clears value but keeps bold / fill /
+     * etc. so users don't lose their styling when they wipe a cell.
+     * Pass `clearFormat: true` for callers that want unconditional
+     * full-clear semantics (e.g. pivot tear-down regenerating cells,
+     * "Clear All" toolbar action).
+     *
+     * Even without `clearFormat`, the method still strips
+     * `userEnteredFormat` when the existing numberFormat is one of
+     * the implicit defaults (`NUMBER` with `pattern_number` /
+     * `pattern_number_thousands`, or `TEXT`) — those formats are
+     * auto-applied based on the value's type and shouldn't outlive
+     * the value. Explicit user-applied formats (bold, fill,
+     * custom number formats) are preserved.
+     */
+    SheetCell.prototype.deleteContents = function (options) {
+        var _a;
+        var _b = options !== null && options !== void 0 ? options : {}, _c = _b.preserveTextNumberFormat, preserveTextNumberFormat = _c === void 0 ? false : _c, _d = _b.clearFormat, clearFormat = _d === void 0 ? false : _d, _e = _b.clearDataValidation, clearDataValidation = _e === void 0 ? false : _e;
+        // Stripping the validation stamp is an interactive-delete-only
+        // semantic (Del on an already-empty cell, incl. checkboxes). It must
+        // be requested explicitly — programmatic clears (changeBatch null
+        // writes, move/cut sources, fill previews) keep the validation.
+        if (clearDataValidation &&
+            !this.userEnteredValue &&
+            this.dataValidationRule) {
+            // Reset data validation
+            this.dataValidationId = undefined;
+            this.dataValidationRule = undefined;
+        }
+        this.cellData = undefined;
+        this.userEnteredValue = undefined;
+        this.effectiveValue = undefined;
+        this.formattedValue = undefined;
+        this.imageUrl = undefined;
+        this.hyperlink = undefined;
+        this.metaType = undefined;
+        this.note = undefined;
+        this.commentThreadId = undefined;
+        this.citationId = undefined;
+        this.textFormatRuns = undefined;
+        this.expandable = undefined;
+        this.expanded = undefined;
+        this.groupKeys = undefined;
+        this.version = undefined;
+        this.updatedAt = undefined;
+        this.arrayFormulaRef = undefined;
+        this.sharedFormulaSpec = undefined;
+        this.clearSharedStringIndex();
+        /**
+         * Strip userEnteredFormat. `clearFormat=true` is an
+         * unconditional wipe — used by pivot tear-down and "Clear All".
+         * Without it, only the implicit auto-applied formats go (a
+         * NUMBER cell with the default integer/thousands pattern, or
+         * a TEXT cell unless preserved). User-applied bold / fill /
+         * custom formats stay so the Del key keeps cell styling, matching
+         * Excel's behavior.
+         */
+        if (clearFormat) {
+            this.userEnteredFormat = undefined;
+            this.originalUserEnteredFormat = undefined;
+        }
+        else {
+            var numberFormat = (_a = this.userEnteredFormat) === null || _a === void 0 ? void 0 : _a.numberFormat;
+            if (((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "NUMBER" &&
+                (numberFormat.pattern === pattern_number ||
+                    (numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern) === pattern_number_thousands)) ||
+                ((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "TEXT" && !preserveTextNumberFormat)) {
+                this.userEnteredFormat = undefined;
+                this.originalUserEnteredFormat = undefined;
+            }
+        }
+        // If there is no data validation result
+        // Preserves data validation result
+        if (!this.dataValidationRule) {
+            this.dataValidationResult = undefined;
+        }
+        this.validate();
+    };
+    SheetCell.prototype.deleteUserEnteredFormat = function () {
+        this.userEnteredFormat = undefined;
+        this.originalUserEnteredFormat = undefined;
+    };
+    /**
+     * Copy a `userEnteredFormat` from a source format onto this cell.
+     * No-op when this cell already has a format, or when the source is
+     * empty. Used by table row-expansion to propagate column-consistent
+     * formats onto newly added rows (Excel parity).
+     */
+    SheetCell.prototype.inheritFormat = function (format) {
+        if (!format)
+            return;
+        if (this.userEnteredFormat || this.originalUserEnteredFormat)
+            return;
+        this.userEnteredFormat = isStyleReference(format) ? undefined : format;
+        this.originalUserEnteredFormat = format;
+    };
+    SheetCell.prototype.changeFormulaSheetName = function (name, oldName) {
+        if (this.formula) {
+            set(this, "userEnteredValue.fv", updateSheetName(this.formula, name, oldName));
+        }
+    };
+    SheetCell.prototype.changeNamedRangeName = function (name, oldName) {
+        if (this.formula) {
+            set(this, "userEnteredValue.fv", updateNamedRangeName(this.formula, name, oldName));
+        }
+    };
+    SheetCell.prototype.changeFormulaColumnName = function (name, previousName) {
+        if (this.formula) {
+            set(this, "userEnteredValue.fv", updateColumnName(this.formula, name, previousName));
+        }
+    };
+    SheetCell.prototype.setLoading = function () {
+        // Preserve effectiveValue: Excel-style, the cell keeps showing the
+        // last calculated value while a recalc is in flight. getCellData only
+        // emits the "Loading..." placeholder when no prior value exists.
+        this.isLoading = true;
+    };
+    SheetCell.prototype.hideLoading = function () {
+        this.isLoading = false;
+    };
+    Object.defineProperty(SheetCell.prototype, "formula", {
+        get: function () {
+            return getExtendedValueFormula(this.userEnteredValue);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SheetCell.prototype, "error", {
+        get: function () {
+            return getExtendedValueError(this.effectiveValue);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SheetCell.prototype, "failsBlockingValidation", {
+        /**
+         * True when the current value violates the cell's data-validation rule
+         * AND the rule blocks entry. Excel's default errorStyle is "stop" — only
+         * an explicit warning/information alert downgrades the rule (mirroring
+         * the agent-write guard's strictness).
+         *
+         * Unlike `validate()`, this checks the rule SYNCHRONOUSLY via
+         * `checkBooleanRule` even for condition types that `validate()` routes
+         * through the calculator (ONE_OF_LIST dropdowns etc.) — a programmatic
+         * write path needs the verdict before committing, not one calc tick
+         * later. CUSTOM_FORMULA rules (calculator-only), rules that error while
+         * evaluating, and ONE_OF_RANGE without a range resolver all fail open,
+         * matching the agent-write guard. Used by `changeBatchStream` with
+         * `skipInvalidValues` to drop the write silently; interactive editing
+         * keeps its dialog flow.
+         */
+        get: function () {
+            var _a, _b;
+            var rule = this.dataValidationRule;
+            if (!((_a = rule === null || rule === void 0 ? void 0 : rule.condition) === null || _a === void 0 ? void 0 : _a.type)) {
+                return false;
+            }
+            var style = (_b = rule.alert) === null || _b === void 0 ? void 0 : _b.style;
+            if (style === "warning" || style === "information") {
+                return false;
+            }
+            if (rule.condition.type === "CUSTOM_FORMULA") {
+                return false;
+            }
+            try {
+                // Error values (a formula result like #REF!) aren't a validation
+                // concern — fail open, same as validate().
+                if (getExtendedValueError(this.effectiveValue)) {
+                    return false;
+                }
+                var effectiveValue = this.getEffectiveValue();
+                var isBlank = effectiveValue === undefined ||
+                    effectiveValue === null ||
+                    (typeof effectiveValue === "string" && effectiveValue === "");
+                if (rule.allowBlank && isBlank) {
+                    return false;
+                }
+                // Strict `=== false`: a rule the checker can't resolve (e.g.
+                // ONE_OF_RANGE without getRangeValues) returns undefined → fail open.
+                return (checkBooleanRule(rule, effectiveValue, undefined, this.getRangeValues, { locale: this.locale }) === false);
+            }
+            catch (_c) {
+                return false;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SheetCell.getRelativeFormula = function (value, from, to, activeSheetName, exclusionRange, ignoreCircular, rowCount, columnCount, preserveAbsolutes) {
+        if (activeSheetName === void 0) { activeSheetName = ""; }
+        if (ignoreCircular === void 0) { ignoreCircular = false; }
+        if (typeof value !== "string") {
+            return undefined;
+        }
+        return formulaToRelativeReference(value, from, to, activeSheetName, {
+            exclusionRange: exclusionRange,
+            ignoreCircular: ignoreCircular,
+            rowCount: rowCount,
+            columnCount: columnCount,
+            preserveAbsolutes: preserveAbsolutes,
+        });
+    };
+    SheetCell.prototype.moveFormula = function (from, to, activeSheetName, options) {
+        var e_1, _a;
+        /**
+         * Moving formula does not trigger a recalc
+         * The cell dependency is updated using
+         * enqueueGraphOperation
+         */
+        if (this.isFormula()) {
+            try {
+                var sourceFormula = this.formula;
+                var movedFormula = formulaToRelativeReference(sourceFormula, from, to, activeSheetName, options);
+                // Filling/moving formulas should also shift explicit refs like
+                // ='Sheet1'!A1 when the source and target rows/cols move.
+                var referencedSheetNames = lexify(sourceFormula)
+                    .tokens.map(function (token) {
+                    if (token.tokenType.name === tokenVocabulary.Sheet.name) {
+                        return token.image.slice(0, -1);
+                    }
+                    if (token.tokenType.name === tokenVocabulary.SheetQuoted.name) {
+                        var desanitized = desanitizeSheetName(token.image);
+                        return desanitized ? desanitized.slice(0, -1) : undefined;
+                    }
+                    return undefined;
+                })
+                    .filter(function (sheetName) { return Boolean(sheetName); });
+                try {
+                    for (var _b = __values(new Set(referencedSheetNames)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var sheetName = _c.value;
+                        if (sheetName.toLowerCase() === activeSheetName.toLowerCase()) {
+                            continue;
+                        }
+                        movedFormula = formulaToRelativeReference(movedFormula, from, to, sheetName, options);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                this.userEnteredValue = { fv: movedFormula };
+            }
+            catch (err) {
+                console.log("Error moving formula", err, this.formula, from, to);
+                if (err instanceof FormulaError) {
+                    this.effectiveValue = {
+                        ev: {
+                            type: "Error",
+                            name: err.error,
+                            message: err.message,
+                        },
+                    };
+                }
+            }
+        }
+    };
+    SheetCell.prototype.isFormula = function () {
+        return !!getExtendedValueFormula(this.userEnteredValue);
+    };
+    SheetCell.prototype.isStructuredReferenceFormula = function () {
+        // This regex matches table references like [Column], [@Column], or TableName[Column]
+        return this.formula && /(\w+\[[@]?\w+\]|\[[@]?\w+\])/.test(this.formula);
+    };
+    SheetCell.prototype.ephemeral = function () {
+        var _a;
+        // The formula contains absolute reference or is a table
+        return this.isStructuredReferenceFormula() || ((_a = this.formula) === null || _a === void 0 ? void 0 : _a.includes("$"));
+    };
+    SheetCell.prototype.isEmpty = function () {
+        return !getExtendedValueString(this.userEnteredValue);
+    };
+    SheetCell.prototype.isNumberType = function (numType) {
+        return [
+            "NUMBER",
+            "CURRENCY",
+            "PERCENT",
+            "ACCOUNTING",
+            "FRACTION",
+            "SCIENTIFIC",
+        ].includes(numType);
+    };
+    SheetCell.prototype.changeDecimals = function (delta) {
+        var _a, _b;
+        if (delta === void 0) { delta = 1; }
+        // Read through getNumberFormat so we pick up `uf.numberFormat` when
+        // `effectiveFormat` is empty (which is the common case now that `ef`
+        // is no longer persisted on cellData).
+        var currentNumberFormat = this.getNumberFormat();
+        var effectiveNumberType = currentNumberFormat === null || currentNumberFormat === void 0 ? void 0 : currentNumberFormat.type;
+        var isNumber = this.isNumberType(effectiveNumberType);
+        var effectiveValue = getExtendedValueNumber(this.effectiveValue);
+        var isGeneralNumber = effectiveNumberType === undefined || effectiveNumberType === "GENERAL";
+        var effectivePattern = (currentNumberFormat === null || currentNumberFormat === void 0 ? void 0 : currentNumberFormat.pattern) === "General"
+            ? undefined
+            : currentNumberFormat === null || currentNumberFormat === void 0 ? void 0 : currentNumberFormat.pattern;
+        // Blank cells stay editable when they carry an explicit numeric pattern
+        // (e.g. whole-column formatting), so later entries inherit the adjusted
+        // precision. Blank General cells have nothing to adjust.
+        if ((!isNumber && !isGeneralNumber) ||
+            (typeof effectiveValue !== "number" && !(isNumber && effectivePattern))) {
+            return;
+        }
+        var finalNumberType = isGeneralNumber ? "NUMBER" : effectiveNumberType;
+        var finalPattern = effectivePattern
+            ? effectivePattern
+            : changeDecimals(pattern_number, Math.min(
+            // The guard above ensures effectiveValue is a number whenever
+            // effectivePattern is falsy, so the 0 fallback is unreachable —
+            // it only narrows the type for getDecimalPlaces.
+            getDecimalPlaces((_b = (_a = this.formattedValue) !== null && _a !== void 0 ? _a : effectiveValue) !== null && _b !== void 0 ? _b : 0, this.locale), 3), false);
+        var pattern = changeDecimals(finalPattern, delta);
+        if (pattern) {
+            if (typeof effectiveValue === "number") {
+                this.formattedValue = createFormattedValue(effectiveValue, "numberValue", pattern, this.locale);
+            }
+            if (!this.userEnteredFormat) {
+                this.userEnteredFormat = {};
+            }
+            this.userEnteredFormat.numberFormat = {
+                type: finalNumberType,
+                pattern: pattern,
+            };
+        }
+    };
+    SheetCell.prototype.decreaseDecimals = function () {
+        this.changeDecimals(-1);
+    };
+    SheetCell.prototype.increaseDecimals = function () {
+        this.changeDecimals(1);
+    };
+    SheetCell.prototype.setBorder = function (position, border) {
+        this.ensureUserEnteredFormatMutable();
+        if (!this.userEnteredFormat) {
+            this.userEnteredFormat = {};
+        }
+        var existing = this.userEnteredFormat.borders;
+        var borders = existing && Object.isExtensible(existing)
+            ? existing
+            : __assign({}, (existing !== null && existing !== void 0 ? existing : {}));
+        this.userEnteredFormat.borders = borders;
+        if (!border.color) {
+            // User is trying to clear the border
+            delete borders[position];
+        }
+        else {
+            if (isNil(border)) {
+                delete borders[position];
+            }
+            else {
+                borders[position] = border;
+            }
+        }
+    };
+    SheetCell.prototype.setUserEnteredBorder = function (position, border) {
+        this.ensureUserEnteredFormatMutable();
+        if (!this.userEnteredFormat) {
+            this.userEnteredFormat = {};
+        }
+        var existing = this.userEnteredFormat.borders;
+        var borders = existing && Object.isExtensible(existing)
+            ? existing
+            : __assign({}, (existing !== null && existing !== void 0 ? existing : {}));
+        this.userEnteredFormat.borders = borders;
+        if (!border.color) {
+            // User is trying to clear the border
+            delete borders[position];
+        }
+        else {
+            if (isNil(border)) {
+                delete borders[position];
+            }
+            else {
+                borders[position] = border;
+            }
+        }
+    };
+    SheetCell.prototype.setAllBorders = function (border) {
+        // User is trying to clear the border
+        if (!border.color) {
+            this.clearAllBorders();
+        }
+        else {
+            set(this, "userEnteredFormat.borders", {
+                top: border,
+                bottom: border,
+                left: border,
+                right: border,
+            });
+        }
+    };
+    SheetCell.prototype.clearAllBorders = function () {
+        if (this.userEnteredFormat) {
+            this.userEnteredFormat.borders = undefined;
+        }
+    };
+    SheetCell.prototype.setImage = function (imageUrl) {
+        this.imageUrl = imageUrl;
+        this.userEnteredValue = undefined;
+        this.hyperlink = undefined;
+        this.formattedValue = "";
+    };
+    SheetCell.prototype.isMultiline = function () {
+        return isMultiline(this.getUserEnteredValue());
+    };
+    /**
+     * Over write formatted value
+     * @param value
+     */
+    SheetCell.prototype.setFormattedValue = function (value) {
+        this.formattedValue = value;
+    };
+    SheetCell.prototype.setUserEnteredValue = function (value, textFormatRuns, options) {
+        var _a, _b, _c;
+        if (value === "" || isNil(value)) {
+            this.clearUserEnteredValue();
+            return this;
+        }
+        // Ensure new entries can replace the previously formatted value (e.g. hyperlinks)
+        this.formattedValue = undefined;
+        // SDK / programmatic-write path: trust the caller's explicit JS type
+        // (matches stock openpyxl / Excel-Java behavior — a Python string
+        // stays a string, a Python datetime is pre-converted by the SDK and
+        // arrives as a numberValue with the appropriate numberFormat already
+        // staged by a separate ``SetCellStyle`` command). Skips the markdown,
+        // ``@``-prefix, leading-``+``, and ``detectValueTypeAndPattern``
+        // coercions that the cell-editor UX relies on.
+        if (options === null || options === void 0 ? void 0 : options.disableTypeInference) {
+            // eslint-disable-next-line no-console
+            var inferredType = typeof value === "boolean"
+                ? "boolValue"
+                : typeof value === "number"
+                    ? "numberValue"
+                    : "stringValue";
+            // For numeric values, set ``numberFormatType="NUMBER"`` so the cell
+            // doesn't get auto-interned as a shared string. ``setNumberValue``
+            // stores ``userEnteredValue.sv`` with the string representation of
+            // the number; without a non-falsy ``numberFormat.type``,
+            // ``shouldUseSharedStrings`` treats the cell as a string and the
+            // shared-string registry promotes it to ``ss``. That in turn makes
+            // a subsequent ``SetCellStyle`` with a ``numberFormat`` (e.g.
+            // ``"$#,##0.00"``) early-return inside ``setNumberFormat``
+            // (the ``!isNil(sharedStringIndex) && numberFormatType !== "TEXT"``
+            // guard), so the user's currency / percent / date pattern never
+            // lands on the cell. Stamping ``NUMBER`` here mirrors what
+            // ``detectValueTypeAndPattern`` does for a plain integer / float
+            // — only the auto-detected ``pattern`` is left undefined, so the
+            // SDK-supplied ``SetCellStyle`` is authoritative.
+            var inferredFormatType = typeof value === "number" ? "NUMBER" : undefined;
+            this.setUserEnteredValueByType(inferredType, value, textFormatRuns, inferredFormatType, typeof value === "number" ? value : undefined, undefined, undefined);
+            if (!this.isFormula()) {
+                this.validate();
+            }
+            this.setVersion(((_a = this.version) !== null && _a !== void 0 ? _a : 0) + 1);
+            this.setUpdatedAt(Date.now());
+            return this;
+        }
+        var originalValue = value;
+        var normalizedValue = value;
+        var forceStringFromPrefix = false;
+        if (hasExcelTextPrefix(normalizedValue)) {
+            normalizedValue = stripExcelTextPrefix(normalizedValue);
+            forceStringFromPrefix = true;
+        }
+        if (typeof normalizedValue === "string" &&
+            normalizedValue.startsWith("+") &&
+            !isAlternateFormula(normalizedValue)) {
+            var plusTrimmed = normalizedValue.slice(1).trim();
+            if (isNumber(plusTrimmed, this.locale, this.lenientGrouping)) {
+                normalizedValue = plusTrimmed;
+            }
+        }
+        var forceMarkdownText = typeof normalizedValue === "string" && looksLikeMarkdown(normalizedValue);
+        var startsWithAt = typeof normalizedValue === "string" && normalizedValue.startsWith("@");
+        var forceStringFromAtPrefix = startsWithAt && !this.enableAtFormula;
+        var dataValuePattern = forceMarkdownText
+            ? ["stringValue"]
+            : forceStringFromAtPrefix
+                ? ["stringValue"]
+                : this.enableAtFormula && startsWithAt
+                    ? ["formulaValue"]
+                    : detectValueTypeAndPattern(normalizedValue, this.locale, this.lenientGrouping, this.use1904);
+        var _d = __read(dataValuePattern, 4), valueType = _d[0], numberValue = _d[2], newPattern = _d[3];
+        // User forced this cell to be a text
+        var forceStringValue = this.isText((_b = this.userEnteredFormat) === null || _b === void 0 ? void 0 : _b.numberFormat);
+        var finalValueType = forceStringValue ||
+            forceStringFromPrefix ||
+            forceMarkdownText ||
+            forceStringFromAtPrefix
+            ? "stringValue"
+            : valueType;
+        var numberFormatType = dataValuePattern[1];
+        this.setUserEnteredValueByType(finalValueType, normalizedValue, textFormatRuns, numberFormatType, numberValue, newPattern, forceStringFromPrefix ? originalValue : undefined);
+        // Validate
+        // Formula cells preserve their prior effectiveValue across an edit
+        // (Excel-like behavior), so guarding on `getEffectiveValue()` would
+        // validate against the *stale* value. Defer validation for formulas
+        // entirely — calc-success drives it via setDataValidationResult.
+        if (!this.isFormula()) {
+            this.validate();
+        }
+        this.setVersion(((_c = this.version) !== null && _c !== void 0 ? _c : 0) + 1);
+        this.setUpdatedAt(Date.now());
+        return this;
+    };
+    SheetCell.prototype.clearUserEnteredValue = function () {
+        this.userEnteredValue = undefined;
+        this.formattedValue = undefined;
+        this.textFormatRuns = undefined;
+        this.clearSharedStringIndex();
+        // Remove effective value too
+        this.effectiveValue = undefined;
+    };
+    SheetCell.prototype.clearEffectiveValueForFormula = function () {
+        // Remove effective value
+        this.effectiveValue = undefined;
+        this.textFormatRuns = undefined;
+        this.formattedValue = "";
+    };
+    SheetCell.prototype.setUserEnteredValueByType = function (valueType, value, textFormatRuns, numberFormatType, numberValue, newPattern, originalStringValue) {
+        switch (valueType) {
+            case "boolValue":
+                this.setBooleanValue(value);
+                break;
+            case "numberValue":
+                this.setNumberValue(value, numberFormatType, numberValue, newPattern);
+                break;
+            case "formulaValue":
+                this.setFormulaValue(value);
+                break;
+            case "stringValue":
+                // Check if its url (unless original prefix forced plain text)
+                if (!originalStringValue && isValidURLorEmail(value)) {
+                    // A fresh user entry replaces whatever string the cell held.
+                    // `setHyperlink`'s no-title branch deliberately leaves the
+                    // shared-string index alone (it also runs during hydration),
+                    // so drop it here — otherwise `getCellData` keeps serializing
+                    // the old SST slot and the cell renders the previous URL.
+                    this.clearSharedStringIndex();
+                    this.setUrl(value);
+                }
+                else {
+                    this.setStringValue(value, textFormatRuns, originalStringValue);
+                }
+                break;
+        }
+    };
+    SheetCell.prototype.ensureUserEnteredFormatMutable = function () {
+        if (this.userEnteredFormat &&
+            !Object.isExtensible(this.userEnteredFormat)) {
+            this.userEnteredFormat = __assign({}, this.userEnteredFormat);
+        }
+    };
+    SheetCell.prototype.ensureFormatsMutable = function () {
+        this.ensureUserEnteredFormatMutable();
+    };
+    SheetCell.prototype.setBooleanValue = function (value) {
+        this.clearSharedStringIndex();
+        var effectiveValue = String(value).toUpperCase() === "TRUE";
+        set(this, "userEnteredValue", { bv: effectiveValue });
+        set(this, "effectiveValue", { bv: effectiveValue });
+        this.formattedValue = createFormattedValue(value, "boolValue", this.defaultPattern, this.locale);
+        this.ensureFormatsMutable();
+        // Excel parity: the cell's existing number format survives a boolean
+        // entry — re-typing a number later restores the styled display. Wiping
+        // `uf.numberFormat` here would silently drop a user-applied custom
+        // format the moment TRUE/FALSE was written.
+    };
+    SheetCell.prototype.setNumberValue = function (value, numberFormatType, numberValue, newPattern) {
+        var _a, _b;
+        this.clearSharedStringIndex();
+        // Read through getNumberFormat so we pick up either `uf.numberFormat`
+        // or the in-memory `effectiveFormat.numberFormat` (legacy `ef`-only
+        // cells loaded from older saved data populate effectiveFormat in
+        // assign()). Without this, editing a legacy ef-only currency cell
+        // would silently drop CURRENCY back to NUMBER.
+        var existingFormat = this.getNumberFormat();
+        var finalFormatType = numberFormatType;
+        var finalPattern = newPattern;
+        if ((existingFormat === null || existingFormat === void 0 ? void 0 : existingFormat.type) === "TEXT") {
+            finalFormatType = "TEXT";
+            finalPattern = (_a = existingFormat.pattern) !== null && _a !== void 0 ? _a : finalPattern;
+        }
+        // Excel-like behavior: Preserve existing format when entering plain numbers
+        if (existingFormat &&
+            this.shouldPreserveExistingFormat(numberFormatType, existingFormat, newPattern, numberValue)) {
+            finalFormatType = existingFormat.type;
+            finalPattern = (_b = existingFormat.pattern) !== null && _b !== void 0 ? _b : undefined;
+        }
+        // Calculate string value for user entered value
+        var stringValue = this.getStringValueForFormat(value, numberValue, finalFormatType);
+        // Create formatted display value
+        this.formattedValue = createFormattedValue(numberValue, "numberValue", finalPattern !== null && finalPattern !== void 0 ? finalPattern : this.defaultPattern, this.locale);
+        // Set values and alignment
+        if (finalFormatType === "TEXT") {
+            this.formattedValue = createFormattedValue(String(value), "stringValue", finalPattern !== null && finalPattern !== void 0 ? finalPattern : this.defaultPattern, this.locale);
+            set(this, "userEnteredValue", { sv: String(value) });
+            set(this, "effectiveValue", { sv: String(value) });
+        }
+        else {
+            var userString = typeof value === "string" && finalFormatType === "NUMBER"
+                ? this.normalizeUserEnteredNumber(value)
+                : typeof value === "string" && finalFormatType === "SCIENTIFIC"
+                    ? stringValue // Use expanded numeric string for scientific notation
+                    : typeof value === "string"
+                        ? value
+                        : stringValue;
+            set(this, "userEnteredValue", { sv: userString });
+            set(this, "effectiveValue", { nv: numberValue });
+        }
+        // Apply number format if specified — uf only.
+        if (finalFormatType) {
+            set(this, "userEnteredFormat.numberFormat.type", finalFormatType);
+            set(this, "userEnteredFormat.numberFormat.pattern", finalPattern);
+        }
+    };
+    SheetCell.prototype.normalizeUserEnteredNumber = function (value) {
+        var group = getLocaleSeparators(this.locale).group;
+        if (!group) {
+            return value;
+        }
+        var isWhitespaceGroup = group.trim() === "";
+        if (isWhitespaceGroup) {
+            return value.replace(/[\s\u00A0\u202F]/g, "");
+        }
+        var escaped = group.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return value.replace(new RegExp(escaped, "g"), "");
+    };
+    SheetCell.prototype.shouldPreserveExistingFormat = function (newFormatType, existingFormat, _newPattern, _numberValue) {
+        // Excel rule, in three layers:
+        //   1. General cell                → defer to the typed value's
+        //                                    inferred format
+        //   2. Plain NUMBER input          → preserve any non-General format
+        //   3. Explicit-format input       → preserve only when the
+        //      (Currency / Percent / Date)   existing format is in the same
+        //                                    category, else switch
+        if (isGeneralNumberFormat(existingFormat))
+            return false;
+        if (!newFormatType || newFormatType === "NUMBER")
+            return true;
+        // Specific data state: General type combined with a non-General
+        // pattern is the exact shape the Custom-format dialog produces.
+        // Excel's auto-format paths always stamp a named type (CURRENCY,
+        // PERCENT, DATE, …), so a pattern paired with a General type can
+        // only have come from explicit user action (dialog or programmatic).
+        // Respect it across all inputs.
+        if (hasGeneralType(existingFormat) && !hasGeneralPattern(existingFormat)) {
+            return true;
+        }
+        // Cross-category transitions — resolve the existing format's
+        // effective category, falling back to pattern inference for
+        // pattern-only formats imported from xlsx.
+        var effectiveType = !hasGeneralType(existingFormat)
+            ? existingFormat.type
+            : this.isDateTime(existingFormat)
+                ? "DATE_TIME"
+                : this.isDate(existingFormat)
+                    ? "DATE"
+                    : "NUMBER";
+        return effectiveType === newFormatType;
+    };
+    SheetCell.prototype.getStringValueForFormat = function (value, numberValue, formatType) {
+        var isDate = this.isDate(formatType ? { type: formatType } : undefined);
+        var isDateTime = this.isDateTime(formatType ? { type: formatType } : undefined);
+        if (isDate || isDateTime) {
+            return createFormattedValue(numberValue, "numberValue", isDate ? getDefaultDateFormat(this.locale) : getDefaultTimeFormat(this.locale), this.locale);
+        }
+        if (formatType === "PERCENT") {
+            return value; // Show user entered value for percent
+        }
+        return String(numberValue);
+    };
+    SheetCell.prototype.setFormulaValue = function (formulaValue, clearEffectiveValue) {
+        if (clearEffectiveValue === void 0) { clearEffectiveValue = false; }
+        if (formulaValue.startsWith("@") && !this.enableAtFormula) {
+            this.setStringValue(formulaValue);
+            return;
+        }
+        // A leading "==" can never start a valid formula expression (Excel/Sheets
+        // have no token for it), so values like "=== COMP DRIVERS ===" are label
+        // text, not formulas. Store them as a plain string rather than handing a
+        // never-parseable expression to the calculator. Mirrors the "@" guard
+        // above and the matching `isAFormula` classification.
+        if (formulaValue.startsWith("==")) {
+            this.setStringValue(formulaValue);
+            return;
+        }
+        this.clearSharedStringIndex();
+        // Balance parenthesis
+        formulaValue = balanceFormula(formulaValue);
+        // Sanitize formula
+        if (formulaValue.startsWith("@")) {
+            formulaValue = "=".concat(formulaValue.slice(1));
+        }
+        else if (isAlternateFormula(formulaValue)) {
+            // If it starts with @, replace it with =
+            formulaValue = "=".concat(formulaValue);
+        }
+        // Convert escaped quotes \\" or \" to Excel's doubled quote format ""
+        formulaValue = formulaValue.replace(/\\+"/g, '""');
+        // Convert newline escape sequences to CHAR(10) function
+        formulaValue = formulaValue.replace(/\\n/g, '"&CHAR(10)&"');
+        // Drop xlsx round-trip provenance — the user is supplying a brand-new
+        // formula, so any source-side `<f t="array" ref="…">` or
+        // `<f t="shared" si="…">` grouping no longer applies. Without this,
+        // the exporter would replay the stale marker and either:
+        //  (a) write `<f t="array" ref="G7:G10">USER_FORMULA</f>` and spill
+        //      the user's edit across cells that weren't part of the source
+        //      array, or
+        //  (b) emit `<f t="shared" si="N"/>` (self-closing, no formula text)
+        //      and lose the user's new expression entirely.
+        // Editing a cell formula is the canonical "detach from group" action,
+        // mirroring how Excel breaks the grouping on in-place edits.
+        this.arrayFormulaRef = undefined;
+        this.sharedFormulaSpec = undefined;
+        // Set user entered value
+        this.userEnteredValue = { fv: formulaValue };
+        // Clear
+        if (clearEffectiveValue) {
+            if (isValidFormula(formulaValue)) {
+                this.clearEffectiveValueForFormula();
+            }
+            else {
+                this.formattedValue = formulaValue;
+            }
+        }
+    };
+    SheetCell.prototype.setStringValue = function (stringValue, textFormatRuns, userEnteredStringValue) {
+        var _a, _b, _c;
+        this.clearSharedStringIndex();
+        this.ensureFormatsMutable();
+        var coercedValue = String(stringValue);
+        var userValue = userEnteredStringValue !== null && userEnteredStringValue !== void 0 ? userEnteredStringValue : coercedValue;
+        set(this, "userEnteredValue", { sv: userValue });
+        set(this, "effectiveValue", { sv: coercedValue });
+        // Excel parity: the cell's existing pattern still applies to text. A
+        // 4-section custom format like `[Blue]#,##0.00;[Red]-#,##0.00;[Green]"zero";[Magenta]@`
+        // uses its `@` (segment 4) branch for string values, so the literal
+        // prefixes / suffixes around `@` (e.g. `"Note: "@` → `Note: hello`) and
+        // any `[Color]` directive in that segment must flow through. Falling
+        // back to `defaultPattern` here would silently drop them.
+        var pattern = (_c = (_b = (_a = this.userEnteredFormat) === null || _a === void 0 ? void 0 : _a.numberFormat) === null || _b === void 0 ? void 0 : _b.pattern) !== null && _c !== void 0 ? _c : this.defaultPattern;
+        this.formattedValue = createFormattedValue(coercedValue, "stringValue", pattern, this.locale);
+        this.textFormatRuns = textFormatRuns;
+        // Don't clear `uf.numberFormat` here. Excel preserves the cell's number
+        // format when text is entered — re-typing a number later restores the
+        // styled display, and the `@` section of the existing pattern still
+        // formats the current text value. The previous "delete unless TEXT"
+        // branch nuked any user-applied custom format the moment a string was
+        // written, which also broke the per-section color path at render time.
+    };
+    SheetCell.prototype.getSharedStringCandidate = function () {
+        var _a;
+        return ((_a = getExtendedValueString(this.userEnteredValue)) !== null && _a !== void 0 ? _a : getExtendedValueString(this.effectiveValue));
+    };
+    /**
+     * Runs attached to this cell at write-time. The shared-string
+     * registry calls this to decide whether to intern a plain or rich
+     * SST entry. Returns `undefined` when the cell has no per-segment
+     * formatting (plain interning path stays unchanged).
+     */
+    SheetCell.prototype.getSharedStringRichRuns = function () {
+        if (!this.textFormatRuns || this.textFormatRuns.length === 0) {
+            return undefined;
+        }
+        return this.textFormatRuns;
+    };
+    SheetCell.prototype.shouldUseSharedStrings = function (candidate) {
+        var _a;
+        if (!candidate || candidate === "") {
+            return false;
+        }
+        if (hasExcelTextPrefix(candidate)) {
+            return false;
+        }
+        if (this.isFormula()) {
+            return false;
+        }
+        // The cell's effective value is numeric (or boolean) — the candidate
+        // string is just a serialized form of a real number. Promoting it to
+        // the SST would replace `ev.nv` with `ev.sv` on hydration, turning a
+        // genuine number into a text cell. That's exactly how `-12` typed
+        // into a `[Blue]…;[Red]-…;[Green]…;[Magenta]@` custom-format cell
+        // ended up rendered in magenta and left-aligned: the renderer saw a
+        // string and routed it through the `@` section instead of the
+        // negative-number section. This single guard is sufficient — a
+        // *text* value in the same custom-pattern cell still goes to the SST
+        // normally (no `ev.nv` to protect), which keeps xlsx export's
+        // string-interning optimization intact for the long-text case.
+        if (this.effectiveValue &&
+            (getExtendedValueNumber(this.effectiveValue) !== undefined ||
+                getExtendedValueBool(this.effectiveValue) !== undefined)) {
+            return false;
+        }
+        var numberFormat = (_a = this.userEnteredFormat) === null || _a === void 0 ? void 0 : _a.numberFormat;
+        var numberFormatType = numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type;
+        // A pattern-only format (no `type`) imported from xlsx still carries
+        // semantic intent. If the pattern is date/datetime/time, the cell is
+        // numeric in Excel's eyes — promoting it to the SST would lose that
+        // and re-emit the value as a literal text serial on save.
+        if (!numberFormatType && (numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern)) {
+            if (isDatePattern(numberFormat.pattern) ||
+                isDateTimePattern(numberFormat.pattern)) {
+                return false;
+            }
+        }
+        return (numberFormatType === undefined ||
+            numberFormatType === "GENERAL" ||
+            numberFormatType === "TEXT");
+    };
+    SheetCell.prototype.getSharedStringIndex = function () {
+        return this.sharedStringIndex;
+    };
+    SheetCell.prototype.applySharedStringIndex = function (index) {
+        this.sharedStringIndex = index !== null && index !== void 0 ? index : undefined;
+    };
+    SheetCell.prototype.clearSharedStringIndex = function () {
+        this.sharedStringIndex = undefined;
+    };
+    SheetCell.prototype.hydrateSharedStringValue = function (index) {
+        var _a, _b, _c;
+        var strings = (_b = (_a = this.sharedStrings) !== null && _a !== void 0 ? _a : SheetCell.defaultSharedStrings) !== null && _b !== void 0 ? _b : undefined;
+        if (!strings) {
+            return;
+        }
+        var rawValue = strings instanceof Map
+            ? strings.get(String(index))
+            : Array.isArray(strings)
+                ? strings[Number(index)]
+                : undefined;
+        // SharedStrings may hold a plain string OR a rich `{text, runs}`
+        // object. Either way we surface the plain text into `ue.sv` and
+        // hydrate the cell's `textFormatRuns` from the rich runs when
+        // present — so a cell loaded from a rich SST entry already
+        // carries the runs without a second lookup at render time.
+        var value;
+        if (typeof rawValue === "string") {
+            value = rawValue;
+        }
+        else if (rawValue &&
+            typeof rawValue === "object" &&
+            typeof rawValue.text === "string") {
+            value = rawValue.text;
+            var richRuns = rawValue.runs;
+            if (Array.isArray(richRuns) && richRuns.length > 0) {
+                this.textFormatRuns = richRuns;
+            }
+        }
+        else {
+            return;
+        }
+        if (value === undefined) {
+            return;
+        }
+        var hasEffectiveError = Boolean(getExtendedValueError(this.effectiveValue));
+        this.userEnteredValue = { sv: value };
+        if (!hasEffectiveError) {
+            this.effectiveValue = { sv: value };
+        }
+        this.formattedValue =
+            (_c = this.formattedValue) !== null && _c !== void 0 ? _c : createFormattedValue(value, "stringValue", this.defaultPattern, this.locale);
+    };
+    SheetCell.prototype.validate = function () {
+        var _a, _b;
+        // Validation
+        if (this.dataValidationRule) {
+            try {
+                var isFormulaRule = isDataValidationFormulaRule(this.dataValidationRule);
+                var allowBlank = this.dataValidationRule.allowBlank;
+                var hasEffectiveError = Boolean(getExtendedValueError(this.effectiveValue));
+                var effectiveValue = this.getEffectiveValue();
+                var isBlank = !hasEffectiveError &&
+                    (effectiveValue === undefined ||
+                        effectiveValue === null ||
+                        (typeof effectiveValue === "string" && effectiveValue === ""));
+                var isValid = allowBlank && isBlank
+                    ? true
+                    : isFormulaRule
+                        ? this.dataValidationResult === undefined
+                            ? true
+                            : Boolean(this.dataValidationResult)
+                        : checkBooleanRule(this.dataValidationRule, effectiveValue, undefined, this.getRangeValues, { locale: this.locale });
+                if (!isValid) {
+                    // Excel parity: a value that fails data validation is *flagged*,
+                    // not erased. The cell keeps showing its `sv` / `nv` / `bv` and
+                    // gets a red indicator (sourced from the `ev.ev` invalid marker).
+                    // Previously this replaced the entire effectiveValue with just
+                    // `{ev: ...}`, which destroyed the user's data the moment a
+                    // validation rule was applied to a non-matching cell.
+                    set(this, "effectiveValue.ev", {
+                        message: "This cell's contents violate its validation rule",
+                        type: "Invalid",
+                    });
+                }
+                else {
+                    (_a = this.effectiveValue) === null || _a === void 0 ? true : delete _a.ev;
+                }
+            }
+            catch (err) {
+                set(this, "effectiveValue.ev", {
+                    type: "Error",
+                    name: err instanceof FormulaError ? err.error : "#ERROR!",
+                    message: String(err),
+                });
+            }
+        }
+        else {
+            (_b = this.effectiveValue) === null || _b === void 0 ? true : delete _b.ev;
+        }
+    };
+    SheetCell.prototype.setConditionalFormatResult = function (ruleId, value) {
+        if (!this.conditionalFormattingResultById) {
+            this.conditionalFormattingResultById = {};
+        }
+        this.conditionalFormattingResultById[ruleId] = value;
+    };
+    SheetCell.prototype.clearConditionalFormatResults = function () {
+        this.conditionalFormattingResultById = undefined;
+    };
+    SheetCell.prototype.setDataValidationResult = function (value) {
+        this.dataValidationResult = value;
+        // Validate
+        this.validate();
+    };
+    /**
+     * Refresh formatted value
+     * from effective value and effective format
+     */
+    SheetCell.prototype.refreshFormattedValue = function () {
+        var _a, _b;
+        var effectiveValue = this.getEffectiveValue();
+        if (isNil(effectiveValue)) {
+            this.formattedValue = undefined;
+            return;
+        }
+        var valueType = detectValueType(effectiveValue, this.locale, this.lenientGrouping);
+        switch (valueType) {
+            case "numberValue":
+                this.formattedValue = createFormattedValue(effectiveValue, "numberValue", (_b = (_a = this.getNumberFormat()) === null || _a === void 0 ? void 0 : _a.pattern) !== null && _b !== void 0 ? _b : this.defaultPattern, this.locale);
+                break;
+            case "boolValue":
+                this.setEffectiveBooleanValue(effectiveValue);
+                break;
+            case "stringValue":
+            default:
+                this.setEffectiveStringValue(effectiveValue);
+                break;
+        }
+    };
+    SheetCell.prototype.setEffectiveValue = function (value, isPreview, preserveStringLiteral) {
+        var _a, _b;
+        if (isPreview === void 0) { isPreview = false; }
+        if (preserveStringLiteral === void 0) { preserveStringLiteral = false; }
+        // Hide loading
+        this.hideLoading();
+        if (isNil(value)) {
+            this.clearEffectiveValue();
+            return this;
+        }
+        if (value instanceof FormulaError) {
+            this.setErrorValue(value);
+            return this;
+        }
+        if (value === AWAITING_CALCULATION) {
+            // AWAITING_CALCULATION is a placeholder, not a computed result: the
+            // on-demand gate publishes it when it deliberately does NOT evaluate
+            // the formula. It must never destroy a persisted result — in
+            // particular a persisted error ev (#VALUE! from a failed =AOP() run)
+            // was erased here on every subsequent open: the open pass
+            // force-enqueues persisted-error cells, the on-demand gate answers
+            // AWAITING_CALCULATION, and the removeErrorValue() below scrubbed the
+            // error from state and (via the leader's recalc broadcast) from the
+            // Y.Doc, leaving the cell blank after reload.
+            if (!this.error &&
+                (!((_a = this.effectiveValue) === null || _a === void 0 ? void 0 : _a.structuredValue) ||
+                    this.formattedValue === this.loadingValue)) {
+                this.formattedValue = value;
+            }
+            return this;
+        }
+        this.removeErrorValue();
+        if (typeof value === "object" &&
+            value.kind) {
+            this.setStructuredValue(value);
+            return this;
+        }
+        else if (typeof value === "object") {
+            // Stringify objects to be displayed in a cell
+            value = JSON.stringify(value);
+        }
+        var normalizedValue = value;
+        var forceStringFromPrefix = false;
+        if (hasExcelTextPrefix(normalizedValue)) {
+            normalizedValue = stripExcelTextPrefix(normalizedValue);
+            forceStringFromPrefix = true;
+        }
+        var valueType = (preserveStringLiteral || forceStringFromPrefix) &&
+            typeof normalizedValue === "string"
+            ? "stringValue"
+            : detectValueType(normalizedValue, this.locale, this.lenientGrouping);
+        switch (valueType) {
+            case "numberValue":
+                this.setEffectiveNumberValue(normalizedValue);
+                break;
+            case "stringValue":
+            case "formulaValue":
+                this.setEffectiveStringValue(normalizedValue);
+                break;
+            case "boolValue":
+                this.setEffectiveBooleanValue(normalizedValue);
+                break;
+        }
+        if (!isPreview) {
+            this.validate();
+            this.setVersion(((_b = this.version) !== null && _b !== void 0 ? _b : 0) + 1);
+            this.setUpdatedAt(Date.now());
+        }
+        return this;
+    };
+    SheetCell.prototype.clearEffectiveValue = function () {
+        this.effectiveValue = undefined;
+        this.formattedValue = undefined;
+        this.cellData = undefined;
+    };
+    SheetCell.prototype.setErrorValue = function (error) {
+        this.effectiveValue = {
+            ev: {
+                type: "Error",
+                name: error.error,
+                message: error.message,
+            },
+        };
+        this.formattedValue = String(error.error);
+    };
+    SheetCell.prototype.removeErrorValue = function () {
+        var _a;
+        (_a = this.effectiveValue) === null || _a === void 0 ? true : delete _a.ev;
+    };
+    SheetCell.prototype.setStructuredValue = function (structuredValue) {
+        switch (structuredValue.kind) {
+            case "hyperlink":
+                this.setUrl(structuredValue.url, structuredValue.title);
+                // Set structuredValue
+                set(this, "effectiveValue.structuredValue", structuredValue);
+                break;
+            case "image":
+                this.imageUrl = structuredValue.imageUrl;
+                this.formattedValue = "";
+                // Set structuredValue
+                set(this, "effectiveValue", { structuredValue: structuredValue });
+                break;
+            case "sparkline":
+                this.formattedValue = structuredValue.formattedValue;
+                // Set structuredValue
+                set(this, "effectiveValue", { structuredValue: structuredValue });
+                break;
+            default:
+                this.formattedValue = structuredValue.formattedValue;
+                // Set structuredValue
+                set(this, "effectiveValue", { structuredValue: structuredValue });
+                // Always set to left
+                break;
+        }
+    };
+    SheetCell.prototype.setEffectiveNumberValue = function (value) {
+        var _a, _b, _c, _d, _e, _f;
+        this.clearSharedStringIndex();
+        var numberFormat = (_c = (_b = (_a = this.userEnteredFormat) === null || _a === void 0 ? void 0 : _a.numberFormat) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : detectNumberFormatType(value, this.locale, this.lenientGrouping);
+        var numberValue = createNumberValue(value, numberFormat, this.locale, this.use1904, this.lenientGrouping);
+        var pattern = (_f = (_e = (_d = this.userEnteredFormat) === null || _d === void 0 ? void 0 : _d.numberFormat) === null || _e === void 0 ? void 0 : _e.pattern) !== null && _f !== void 0 ? _f : detectNumberFormatPattern(value, numberValue, numberFormat, this.locale);
+        this.formattedValue = createFormattedValue(numberValue, "numberValue", pattern !== null && pattern !== void 0 ? pattern : this.defaultPattern, this.locale);
+        this.effectiveValue = { nv: numberValue };
+    };
+    SheetCell.prototype.setEffectiveStringValue = function (value) {
+        this.clearSharedStringIndex();
+        var stringValue = String(value);
+        this.effectiveValue = { sv: stringValue };
+        this.formattedValue = createFormattedValue(stringValue, "stringValue", this.defaultPattern, this.locale);
+    };
+    SheetCell.prototype.setEffectiveBooleanValue = function (value) {
+        this.clearSharedStringIndex();
+        this.effectiveValue = { bv: Boolean(value) };
+        this.formattedValue = createFormattedValue(value, "boolValue", this.defaultPattern, this.locale);
+    };
+    SheetCell.prototype.setHyperlink = function (hyperlink, title) {
+        var target = getHyperlinkTarget(hyperlink);
+        var display = title !== null && title !== void 0 ? title : getHyperlinkDisplay(hyperlink);
+        if (!target) {
+            return;
+        }
+        this.hyperlink = hyperlink;
+        if (display) {
+            this.clearSharedStringIndex();
+            this.formattedValue = display;
+            // Update both user entered and effective values
+            set(this, "userEnteredValue.sv", display);
+            set(this, "effectiveValue.sv", display);
+        }
+        else {
+            if (!this.formattedValue && target) {
+                this.formattedValue = target;
+            }
+            // Update both user entered and effective values with the URL if no
+            // title. `userEnteredValue` must be populated so consumers that read
+            // only `userEnteredValue` (e.g. the rnc-engine paste handler) see the
+            // pasted URL instead of an empty cell.
+            if (!display && target) {
+                set(this, "userEnteredValue.sv", target);
+                set(this, "effectiveValue.sv", target);
+            }
+        }
+        // Persist the hyperlink underline on `userEnteredFormat`. Writing to
+        // `effectiveFormat` here would silently drop on save/reload because
+        // `effectiveFormat` is derived at render time and not persisted (see
+        // the in-file note around `assign()` — `uf` is the single source of
+        // truth). Excel saves the underline as part of the cell's style.
+        this.ensureFormatsMutable();
+        set(this, "userEnteredFormat.textFormat.underline", true);
+    };
+    SheetCell.prototype.setUrl = function (url, title) {
+        this.setHyperlink(url, title);
+    };
+    SheetCell.prototype.deleteUrl = function () {
+        var _a, _b;
+        this.hyperlink = undefined;
+        // Excel parity: removing the hyperlink also removes the underline that
+        // was added when the hyperlink was applied. We only strip the
+        // underline (not the whole textFormat) so any user-applied bold /
+        // italic / color the user set on top of the hyperlink survives.
+        if ((_b = (_a = this.userEnteredFormat) === null || _a === void 0 ? void 0 : _a.textFormat) === null || _b === void 0 ? void 0 : _b.underline) {
+            this.ensureFormatsMutable();
+            delete this.userEnteredFormat.textFormat.underline;
+        }
+    };
+    SheetCell.prototype.setDataValidation = function (dataValidationId, dataValidationRule) {
+        this.dataValidationId = dataValidationId;
+        this.dataValidationRule = dataValidationRule;
+        // Excel parity: adding a validation rule (including a BOOLEAN /
+        // checkbox rule) does NOT mutate the cell's existing value. The rule
+        // is enforced on future edits — values that violate it get the
+        // standard "invalid value" indicator via `validate()` instead. The
+        // previous auto-coercion turned every cell into FALSE the moment a
+        // checkbox rule was applied, which destroyed user data.
+        this.validate();
+    };
+    SheetCell.prototype.deleteDataValidation = function () {
+        var _a;
+        this.dataValidationId = undefined;
+        this.dataValidationRule = undefined;
+        // Remove any errors
+        (_a = this.effectiveValue) === null || _a === void 0 ? true : delete _a.ev;
+    };
+    SheetCell.prototype.clearUserEnteredFormat = function () {
+        this.userEnteredFormat = undefined;
+        this.originalUserEnteredFormat = undefined;
+    };
+    SheetCell.prototype.setUserEnteredFormat = function (type, value) {
+        if (type === "textFormat") {
+            this.setTextFormat(value);
+        }
+        else if (type === "numberFormat") {
+            this.setNumberFormat(value);
+        }
+        else if (type === "borders") {
+            this.setBorders(value);
+        }
+        else {
+            set(this, "userEnteredFormat.".concat(type), value);
+        }
+    };
+    SheetCell.prototype.setTextFormat = function (value) {
+        this.ensureUserEnteredFormatMutable();
+        if (!this.userEnteredFormat) {
+            this.userEnteredFormat = {};
+        }
+        var existing = this.userEnteredFormat.textFormat;
+        var textFormat = existing && Object.isExtensible(existing)
+            ? existing
+            : __assign({}, (existing !== null && existing !== void 0 ? existing : {}));
+        this.userEnteredFormat.textFormat = textFormat;
+        var target = textFormat;
+        for (var key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                var finalValue = value[key];
+                if (isNil(finalValue)) {
+                    delete textFormat[key];
+                }
+                else {
+                    target[key] = finalValue;
+                }
+            }
+        }
+    };
+    SheetCell.prototype.setBorders = function (value) {
+        this.ensureUserEnteredFormatMutable();
+        if (!this.userEnteredFormat) {
+            this.userEnteredFormat = {};
+        }
+        var existing = this.userEnteredFormat.borders;
+        var borders = existing && Object.isExtensible(existing)
+            ? existing
+            : __assign({}, (existing !== null && existing !== void 0 ? existing : {}));
+        this.userEnteredFormat.borders = borders;
+        for (var key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                var borderValue = value[key];
+                if (borderValue === null || borderValue === undefined) {
+                    delete borders[key];
+                }
+                else if (!borderValue.color) {
+                    delete borders[key];
+                }
+                else {
+                    borders[key] = borderValue;
+                }
+            }
+        }
+    };
+    SheetCell.prototype.setNumberFormat = function (value) {
+        var _a, _b;
+        var previousFormatType = (_b = (_a = this.userEnteredFormat) === null || _a === void 0 ? void 0 : _a.numberFormat) === null || _b === void 0 ? void 0 : _b.type;
+        var numberFormatType = value === null || value === void 0 ? void 0 : value.type;
+        var hasUserEnteredValue = this.getUserEnteredValue() !== undefined;
+        if (!isNil(this.sharedStringIndex) &&
+            numberFormatType &&
+            numberFormatType !== "TEXT") {
+            return;
+        }
+        set(this, "userEnteredFormat.numberFormat", value);
+        var effectiveValue = this.getEffectiveValue();
+        if (effectiveValue === null || effectiveValue === undefined) {
+            return;
+        }
+        if (numberFormatType === "TEXT") {
+            var userValue = this.getUserEnteredValue();
+            this.formatAsText(userValue !== null && userValue !== void 0 ? userValue : effectiveValue, value, !hasUserEnteredValue);
+        }
+        else {
+            var preserveUserEnteredText = previousFormatType === "TEXT";
+            this.formatAsNumber(effectiveValue, value, preserveUserEnteredText, !hasUserEnteredValue);
+        }
+    };
+    SheetCell.prototype.formatAsText = function (effectiveValue, numberFormat, keepUserEnteredUnset) {
+        var _a;
+        if (keepUserEnteredUnset === void 0) { keepUserEnteredUnset = false; }
+        var textValue = String(effectiveValue);
+        this.formattedValue = createFormattedValue(effectiveValue, "stringValue", (_a = numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern) !== null && _a !== void 0 ? _a : this.defaultPattern, this.locale);
+        delete this.imageUrl;
+        delete this.hyperlink;
+        if (!keepUserEnteredUnset) {
+            set(this, "userEnteredValue", { sv: textValue });
+        }
+        set(this, "effectiveValue", { sv: textValue });
+    };
+    SheetCell.prototype.formatAsNumber = function (effectiveValue, numberFormat, preserveUserEnteredText, keepUserEnteredUnset) {
+        var _a, _b, _c, _d;
+        if (preserveUserEnteredText === void 0) { preserveUserEnteredText = false; }
+        if (keepUserEnteredUnset === void 0) { keepUserEnteredUnset = false; }
+        var isDate = this.isDate(numberFormat);
+        var isDateTime = this.isDateTime(numberFormat);
+        var parsedNumberValue = createNumberValue(effectiveValue, numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type, this.locale, this.use1904, this.lenientGrouping);
+        var hasValidNumberValue = typeof parsedNumberValue === "number" && !Number.isNaN(parsedNumberValue);
+        // When conversion fails for plain text (e.g. "hello"), keep displaying text
+        // instead of showing "NaN" while still preserving the selected number format.
+        // Excel parity: the cell's pattern still applies via its `@` (text)
+        // section — e.g. `"Note: "@` renders `Note: hello`, and a `[Magenta]@`
+        // segment colors the text. Falling back to `defaultPattern` here would
+        // silently drop the user-applied custom format from the display.
+        if (!hasValidNumberValue && typeof effectiveValue === "string") {
+            var textValue = String(effectiveValue);
+            this.formattedValue = createFormattedValue(textValue, "stringValue", (_a = numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern) !== null && _a !== void 0 ? _a : this.defaultPattern, this.locale);
+            if (!keepUserEnteredUnset &&
+                (!preserveUserEnteredText || ((_b = this.userEnteredValue) === null || _b === void 0 ? void 0 : _b.sv) === undefined)) {
+                set(this, "userEnteredValue", { sv: textValue });
+            }
+            set(this, "effectiveValue", { sv: textValue });
+            return;
+        }
+        var numberValue = parsedNumberValue === undefined ? effectiveValue : parsedNumberValue;
+        this.formattedValue = createFormattedValue(numberValue, "numberValue", (_c = numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern) !== null && _c !== void 0 ? _c : this.defaultPattern, this.locale);
+        var stringValue = isDate || isDateTime
+            ? createFormattedValue(numberValue, "numberValue", isDate ? getDefaultDateFormat(this.locale) : getDefaultTimeFormat(this.locale), this.locale)
+            : (numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "PERCENT"
+                ? this.formattedValue
+                : String(numberValue);
+        if (!keepUserEnteredUnset &&
+            (!preserveUserEnteredText || ((_d = this.userEnteredValue) === null || _d === void 0 ? void 0 : _d.sv) === undefined)) {
+            set(this, "userEnteredValue.sv", stringValue);
+        }
+        set(this, "effectiveValue.nv", preserveUserEnteredText ? String(numberValue) : numberValue);
+        // Default horizontal alignment for numbers/dates/currency is computed
+        // at render time by `getDefaultHorizontalAlignment` in canvas-grid —
+        // we deliberately do NOT stamp `uf.horizontalAlignment` here so the
+        // user's explicit alignment choice (or its absence) is preserved.
+    };
+    SheetCell.prototype.getEffectiveValue = function () {
+        var _a, _b;
+        if (!this.effectiveValue) {
+            return undefined;
+        }
+        return ((_b = (_a = getExtendedValueNumber(this.effectiveValue)) !== null && _a !== void 0 ? _a : getExtendedValueString(this.effectiveValue)) !== null && _b !== void 0 ? _b : getExtendedValueBool(this.effectiveValue));
+    };
+    SheetCell.prototype.getUserEnteredValue = function () {
+        var _a, _b, _c;
+        if (!this.userEnteredValue) {
+            return undefined;
+        }
+        return ((_c = (_b = (_a = getExtendedValueFormula(this.userEnteredValue)) !== null && _a !== void 0 ? _a : getExtendedValueNumber(this.userEnteredValue)) !== null && _b !== void 0 ? _b : getExtendedValueString(this.userEnteredValue)) !== null && _c !== void 0 ? _c : getExtendedValueBool(this.userEnteredValue));
+    };
+    SheetCell.prototype.getNumberFormat = function () {
+        var _a;
+        return (_a = this.userEnteredFormat) === null || _a === void 0 ? void 0 : _a.numberFormat;
+    };
+    SheetCell.prototype.processDerivedCell = function (cellData) {
+        var _a;
+        // Image url
+        if (cellData.imageUrl) {
+            this.setImage(cellData.imageUrl);
+        }
+        // Set formatted value for hyperlink
+        if (cellData.hyperlink) {
+            this.setHyperlink(cellData.hyperlink, getCellFormattedValue(cellData));
+        }
+        var structuredValue = (_a = getCellEffectiveValue(cellData)) === null || _a === void 0 ? void 0 : _a.structuredValue;
+        if (structuredValue) {
+            this.setStructuredValue(structuredValue);
+        }
+    };
+    // Excel parity: xlsx files often carry a `numberFormat.pattern` without
+    // a corresponding `type` (the Google-Sheets style category that we layer
+    // on top). Fall back to inspecting the pattern itself so DATE / DATE_TIME
+    // / TEXT cells imported from Excel render and serialize correctly.
+    SheetCell.prototype.isDate = function (numberFormat) {
+        if ((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "DATE")
+            return true;
+        if (numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type)
+            return false;
+        return (isDatePattern(numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern) &&
+            !isDateTimePattern(numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern));
+    };
+    SheetCell.prototype.isDateTime = function (numberFormat) {
+        if ((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "DATE_TIME")
+            return true;
+        if (numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type)
+            return false;
+        return isDateTimePattern(numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern);
+    };
+    SheetCell.prototype.isText = function (numberFormat) {
+        if ((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "TEXT")
+            return true;
+        if (numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type)
+            return false;
+        return isTextPattern(numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern);
+    };
+    SheetCell.prototype.setGroupKeys = function (groupKeys) {
+        this.groupKeys = groupKeys;
+        if (groupKeys) {
+            // If a cell is not expandable and has group keys
+            // its the last child the group. Indent persists on uf so the
+            // renderer (and exporters) see it.
+            var indent = (groupKeys.length - 1) * 2 + (this.expandable ? 0 : 4);
+            if (!this.userEnteredFormat) {
+                this.userEnteredFormat = {};
+            }
+            this.userEnteredFormat.indent = Math.max(0, indent);
+        }
+    };
+    SheetCell.prototype.changeIndent = function (size) {
+        var _a, _b;
+        if (size === void 0) { size = 1; }
+        var indent = (_b = (_a = this.userEnteredFormat) === null || _a === void 0 ? void 0 : _a.indent) !== null && _b !== void 0 ? _b : 0;
+        if (!this.userEnteredFormat) {
+            this.userEnteredFormat = {};
+        }
+        this.userEnteredFormat.indent = Math.max(0, indent + size);
+    };
+    SheetCell.prototype.setPivotId = function (pivotId) {
+        this.pivotId = pivotId;
+    };
+    SheetCell.prototype.expand = function () {
+        this.expanded = true;
+    };
+    SheetCell.prototype.collapse = function () {
+        this.expanded = false;
+    };
+    SheetCell.prototype.setExpandable = function (expandable) {
+        this.expandable = expandable;
+    };
+    SheetCell.prototype.setArrayFormulaRef = function (ref) {
+        this.arrayFormulaRef = ref !== null && ref !== void 0 ? ref : undefined;
+    };
+    SheetCell.prototype.clearArrayFormulaRef = function () {
+        if (!this.arrayFormulaRef) {
+            return;
+        }
+        this.arrayFormulaRef = undefined;
+    };
+    SheetCell.prototype.setSharedFormulaSpec = function (spec) {
+        this.sharedFormulaSpec = spec
+            ? __assign({ si: spec.si }, (spec.ref ? { ref: spec.ref } : {})) : undefined;
+    };
+    SheetCell.prototype.clearSharedFormulaSpec = function () {
+        if (!this.sharedFormulaSpec) {
+            return;
+        }
+        this.sharedFormulaSpec = undefined;
+    };
+    SheetCell.prototype.increaseIndent = function () {
+        this.changeIndent(2);
+    };
+    SheetCell.prototype.decreaseIndent = function () {
+        this.changeIndent(-2);
+    };
+    SheetCell.prototype.clearFormatting = function () {
+        this.userEnteredFormat = undefined;
+        this.originalUserEnteredFormat = undefined;
+    };
+    SheetCell.prototype.clearHyperlink = function () {
+        this.hyperlink = undefined;
+    };
+    // Inherit a different set of cell data
+    SheetCell.prototype.inheritCellData = function (cellData) {
+        this.cellData = cellData;
+    };
+    SheetCell.prototype.getUserCellData = function () {
+        if (!this.cellData)
+            return undefined;
+        var result = {};
+        for (var key in this.cellData) {
+            if (!excludeKeys.has(key)) {
+                result[key] = this.cellData[key];
+            }
+        }
+        return Object.keys(result).length > 0 ? result : undefined;
+    };
+    SheetCell.prototype.extendCellData = function (newCellData) {
+        this.assign(this.sheetId, this.coords, newCellData, {
+            getRangeValues: this.getRangeValues,
+            locale: this.locale,
+            cellXfsRegistry: this.cellXfsRegistry,
+            sharedStringRegistry: this.sharedStringRegistry,
+        });
+    };
+    SheetCell.prototype.getUserEnteredFormat = function () {
+        if (isStyleReference(this.originalUserEnteredFormat) &&
+            !this.cellXfsRegistry) {
+            return this.originalUserEnteredFormat;
+        }
+        return this.userEnteredFormat;
+    };
+    /**
+     * Returns the user-entered format. The "effective" format (uf + auto-
+     * derived alignment / pattern color / formula-precedent number format /
+     * conditional formatting) is computed at render time by
+     * `useSheetProperties.getEffectiveFormat`. SheetCell no longer maintains
+     * a separate in-memory effective format.
+     *
+     * Loading-state alignment override is preserved for legacy callers that
+     * sniff this method while a cell is being recalculated.
+     */
+    SheetCell.prototype.getEffectiveCellFormat = function () {
+        var _a, _b;
+        if (!this.userEnteredFormat && !this.isLoading) {
+            return undefined;
+        }
+        if (this.isLoading) {
+            return __assign(__assign({}, ((_a = this.userEnteredFormat) !== null && _a !== void 0 ? _a : {})), { horizontalAlignment: "center" });
+        }
+        return (_b = this.userEnteredFormat) !== null && _b !== void 0 ? _b : undefined;
+    };
+    SheetCell.prototype.getCellFormats = function (disableRegistry) {
+        var _a, _b;
+        // `ef` is no longer persisted: rendering derives the effective format
+        // on the fly from `uf`, the cell value, and (for formulas) precedent
+        // formats. The renderer caches the derivation so this stays cheap.
+        //
+        // Fall back to `originalUserEnteredFormat` when we never resolved a
+        // CellFormat — happens when assign() ran without a cellXfsRegistry on
+        // input that already had `uf: { sid: ... }` (e.g. the sheet-rename
+        // formula round-trip). Without this fallback the StyleReference is
+        // silently dropped on the way out.
+        var format = (_a = this.userEnteredFormat) !== null && _a !== void 0 ? _a : this.originalUserEnteredFormat;
+        if (!format)
+            return {};
+        if (!disableRegistry &&
+            ((_b = this.cellXfsRegistry) === null || _b === void 0 ? void 0 : _b.active) &&
+            this.userEnteredFormat) {
+            return { uf: { sid: getCellXfsKey(this.userEnteredFormat) } };
+        }
+        return { uf: __assign({}, format) };
+    };
+    Object.defineProperty(SheetCell.prototype, "isModified", {
+        get: function () {
+            return !isEqual(this.cellData, this.getCellData());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SheetCell.prototype.getCellData = function (options) {
+        var hasSharedString = this.sharedStringIndex != null;
+        var hasEffectiveError = Boolean(getExtendedValueError(this.effectiveValue));
+        var useSharedString = hasSharedString;
+        // Formula cells no longer persist `fv`: the renderer derives it from
+        // `effectiveValue` + the resolved number format and caches the result.
+        // Structured-value formula cells (sparkline/image/hyperlink) still get
+        // their display text from `effectiveValue.structuredValue` itself, so
+        // we don't need to write `fv` either.
+        //
+        // Exception: when `isLoading` is true, persist `fv = loadingValue` even
+        // for formula cells (and even when a prior `effectiveValue` is on the
+        // cell). The renderer surfaces "Loading..." while a recalc is in
+        // flight; calc-success clears it by writing the cell back through
+        // getCellData with isLoading=false.
+        var isFormulaCell = !!getExtendedValueFormula(this.userEnteredValue);
+        var shouldPersistFormattedValue = !useSharedString &&
+            (this.isLoading || (!isFormulaCell && this.formattedValue));
+        var newCellData = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, this.getUserCellData()), (this.conditionalFormattingResultById
+            ? {
+                conditionalFormattingResultById: this.conditionalFormattingResultById,
+            }
+            : {})), (this.dataValidationResult
+            ? { dataValidationResult: this.dataValidationResult }
+            : {})), (!useSharedString && this.userEnteredValue
+            ? {
+                ue: this.userEnteredValue,
+            }
+            : {})), (this.effectiveValue && (!useSharedString || hasEffectiveError)
+            ? {
+                ev: this.effectiveValue,
+            }
+            : {})), (shouldPersistFormattedValue
+            ? {
+                fv: this.isLoading ? this.loadingValue : this.formattedValue,
+            }
+            : undefined)), (hasSharedString
+            ? {
+                ss: typeof this.sharedStringIndex === "string"
+                    ? this.sharedStringIndex
+                    : String(this.sharedStringIndex),
+            }
+            : {})), this.getCellFormats(options === null || options === void 0 ? void 0 : options.disableRegistry)), (this.dataValidationId
+            ? {
+                dataValidation: this.dataValidationId,
+            }
+            : {})), (this.imageUrl
+            ? {
+                imageUrl: this.imageUrl,
+            }
+            : {})), (this.hyperlink
+            ? {
+                hyperlink: this.hyperlink,
+            }
+            : {})), (this.metaType ? { metaType: this.metaType } : {})), (this.pivotId ? { pivotId: this.pivotId } : {})), (this.groupKeys ? { groupKeys: this.groupKeys } : {})), (this.note ? { note: this.note } : {})), (!isNil(this.commentThreadId)
+            ? { commentThreadId: this.commentThreadId }
+            : {})), (!isNil(this.citationId) ? { citationId: this.citationId } : {})), (this.expandable
+            ? {
+                expandable: this.expandable,
+                expanded: this.expanded,
+            }
+            : {})), (this.arrayFormulaRef ? { af: this.arrayFormulaRef } : {})), (this.sharedFormulaSpec
+            ? {
+                sf: __assign({ si: this.sharedFormulaSpec.si }, (this.sharedFormulaSpec.ref
+                    ? { ref: this.sharedFormulaSpec.ref }
+                    : {})),
+            }
+            : {}));
+        if (newCellData && Object.keys(newCellData).length === 0) {
+            return null;
+        }
+        return newCellData;
+    };
+    SheetCell.defaultEnableAtFormula = false;
+    return SheetCell;
+}());
+export { SheetCell };