@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-parser/plugins/xlsx/styles.js

@@ -0,0 +1,1377 @@
+import { __assign, __read, __values } from "tslib";
+import { formulaToRelativeReference } from "@rowsncolumns/calculator";
+import { IndexedColors } from "@rowsncolumns/utils";
+import { addressToCell, ssfFormat } from "@rowsncolumns/utils";
+import { standardExcelFormatCodeById } from "./numfmt";
+import { detectValueTypeAndPattern } from "./value-type-detection";
+var getNode = function (node) {
+    var e_1, _a;
+    var keys = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        keys[_i - 1] = arguments[_i];
+    }
+    if (!node)
+        return undefined;
+    try {
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            if (node[key] !== undefined) {
+                return node[key];
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+};
+var getNodeText = function (node) {
+    if (node === undefined || node === null) {
+        return undefined;
+    }
+    if (typeof node === "object") {
+        if ("t$" in node && node.t$ !== undefined) {
+            return node.t$;
+        }
+        if ("_" in node && node._ !== undefined) {
+            return node._;
+        }
+        if ("#text" in node && node["#text"] !== undefined) {
+            return node["#text"];
+        }
+        return undefined;
+    }
+    return String(node);
+};
+var getInlineStringValue = function (cell) {
+    var _a, _b;
+    if (!cell.is) {
+        return undefined;
+    }
+    if (cell.is.t !== undefined) {
+        var inlineValue = cell.is.t;
+        return typeof inlineValue === "object"
+            ? (_b = (_a = inlineValue.t$) !== null && _a !== void 0 ? _a : inlineValue._) !== null && _b !== void 0 ? _b : ""
+            : inlineValue;
+    }
+    if (cell.is.r) {
+        var runs = Array.isArray(cell.is.r) ? cell.is.r : [cell.is.r];
+        return runs
+            .map(function (run) {
+            var _a;
+            if (run.t === undefined)
+                return "";
+            return typeof run.t === "object" ? (_a = run.t.t$) !== null && _a !== void 0 ? _a : "" : run.t;
+        })
+            .join("");
+    }
+    return undefined;
+};
+/**
+ * Extract cell value and format information from Excel cell data
+ * @param {Object} cell - The cell object from the sheet data
+ * @param {WorkBook} workbook - The workbook object containing shared strings
+ * @returns {Object} Object containing value and cellFormat properties
+ */
+export function getCellValueAndFormat(cell, workbook, enableCellXfsRegistry, enableSharedStrings, activeSheetName, mergeContext) {
+    var _a, _b;
+    if (enableCellXfsRegistry === void 0) { enableCellXfsRegistry = false; }
+    if (enableSharedStrings === void 0) { enableSharedStrings = false; }
+    if (!cell) {
+        return null;
+    }
+    // Extract raw value
+    var _c = extractCellValue(cell, workbook, activeSheetName), extractedRawValue = _c.rawValue, formulaValue = _c.formulaValue, sharedStringIndex = _c.sharedStringIndex, isError = _c.isError, arrayFormulaRef = _c.arrayFormulaRef, sharedFormulaSpec = _c.sharedFormulaSpec;
+    var rawValue = extractedRawValue;
+    // Extract cell format
+    var cellFormat = extractCellFormat(cell, workbook.workbookStyles, mergeContext);
+    var ef = cellFormat;
+    // Cell-level protection — lives top-level on CellData, not on
+    // CellFormat. Excel's xf carries it, but it's a per-cell concept
+    // (toggled per cell to opt in/out of sheet protection), not a
+    // share-by-style property in our model.
+    var protection = extractCellProtection(cell, workbook.workbookStyles);
+    var isSharedStringCell = enableSharedStrings &&
+        sharedStringIndex !== undefined &&
+        formulaValue === null;
+    if (isSharedStringCell) {
+        if (enableCellXfsRegistry) {
+            var styleId = workbook.registerFormat(cellFormat);
+            ef = { sid: styleId };
+        }
+        var hasFormat_1 = enableCellXfsRegistry || Object.keys(cellFormat !== null && cellFormat !== void 0 ? cellFormat : {}).length > 0;
+        // Cells only carry `ss`; rich-text runs (if any) live on the
+        // SharedStrings entry the index points at. The parser populates
+        // those rich entries via `loadSharedStrings`.
+        return __assign(__assign(__assign({}, (hasFormat_1 ? { uf: ef } : {})), { ss: String(sharedStringIndex) }), (protection ? { protection: protection } : {}));
+    }
+    // If there is no numberFormat, coerce typed display strings ("$1,200",
+    // "50%") into a number plus a detected pattern. Only strings need this:
+    // a numeric `<v>` is already typed, and its missing numberFormat means
+    // General — synthesizing a pattern (e.g. NUMBER "#") here changed how
+    // untouched imported cells render and export vs the source workbook.
+    if (!cellFormat.numberFormat &&
+        typeof rawValue === "string" &&
+        formulaValue === null) {
+        var _d = __read(detectValueTypeAndPattern(rawValue, undefined), 4), detectedValueType = _d[0], detectedNumberFormatType = _d[1], detectedNumberValue = _d[2], detectedPattern = _d[3];
+        if (detectedValueType === "numberValue" &&
+            detectedNumberFormatType &&
+            detectedNumberValue !== undefined) {
+            rawValue = detectedNumberValue;
+            cellFormat.numberFormat = __assign({ type: detectedNumberFormatType }, (detectedPattern ? { pattern: detectedPattern } : {}));
+        }
+    }
+    if (enableCellXfsRegistry) {
+        var styleId = workbook.registerFormat(cellFormat);
+        ef = { sid: styleId };
+    }
+    // User entered value
+    var ue;
+    var ev;
+    var extendedValue = getExtendedValue(rawValue);
+    if (isError) {
+        // Error cell: preserve the Excel error code on `name` so the renderer
+        // shows the original code (#REF!, #DIV/0!, …) instead of a generic
+        // "#ERROR!" fallback.
+        var code = typeof rawValue === "string" ? rawValue : String(rawValue);
+        var errorValue = {
+            type: "Error",
+            name: code,
+            message: code,
+        };
+        if (formulaValue) {
+            ue = { fv: "=" + formulaValue };
+        }
+        else {
+            ue = { ev: errorValue };
+        }
+        ev = { ev: errorValue };
+    }
+    else if (formulaValue) {
+        ue = {
+            fv: "=" + formulaValue,
+        };
+        ev = extendedValue;
+    }
+    else {
+        ue = extendedValue;
+        ev = extendedValue;
+    }
+    var hasFormat = enableCellXfsRegistry || Object.keys(cellFormat !== null && cellFormat !== void 0 ? cellFormat : {}).length > 0;
+    var hasValue = formulaValue !== null && formulaValue !== undefined && formulaValue !== "";
+    var hasRawValue = rawValue !== null && rawValue !== undefined;
+    if (!hasRawValue && !hasValue) {
+        return hasFormat ? { uf: ef } : null;
+    }
+    var pattern = (_b = (_a = cellFormat === null || cellFormat === void 0 ? void 0 : cellFormat.numberFormat) === null || _a === void 0 ? void 0 : _a.pattern) !== null && _b !== void 0 ? _b : "GENERAL";
+    // Skip persisting `fv` for formula cells — the renderer derives the
+    // formatted value at paint time from the formula's effective value and
+    // the precedent-derived number format. Excel ships a cached `fv` in the
+    // xml (the result from the last save), but persisting it here makes
+    // `getFormattedValue` short-circuit on that stale string and skip the
+    // derivation pipeline (so e.g. a formula that depends on a currency
+    // source won't pick up the currency pattern at render).
+    var fv = formulaValue || rawValue === null || rawValue === undefined
+        ? undefined
+        : typeof rawValue === "string"
+            ? rawValue
+            : ssfFormat(pattern, rawValue);
+    return __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (hasFormat ? { uf: ef } : {})), (fv !== undefined ? { fv: fv } : {})), (ue ? { ue: ue } : {})), (ev ? { ev: ev } : {})), (arrayFormulaRef ? { af: arrayFormulaRef } : {})), (sharedFormulaSpec ? { sf: sharedFormulaSpec } : {})), (protection ? { protection: protection } : {}));
+}
+/**
+ * Build a format-only CellData for a style index that a cell inherits from
+ * its row (`<row customFormat="1" s="N">`) or column (`<col style="N">`)
+ * rather than carrying itself. Excel paints such styles across every cell
+ * of the row/column even where no `<c>` element exists, so the importer
+ * materializes them as phantom cells. Returns null when the style resolves
+ * to an empty format (nothing to paint or inherit).
+ */
+export function getCellDataForStyleIndex(styleIndex, workbook, enableCellXfsRegistry) {
+    if (enableCellXfsRegistry === void 0) { enableCellXfsRegistry = false; }
+    var syntheticCell = { a$: { s: String(styleIndex) } };
+    var cellFormat = extractCellFormat(syntheticCell, workbook.workbookStyles);
+    if (!cellFormat || Object.keys(cellFormat).length === 0) {
+        return null;
+    }
+    var protection = extractCellProtection(syntheticCell, workbook.workbookStyles);
+    var ef = enableCellXfsRegistry
+        ? { sid: workbook.registerFormat(cellFormat) }
+        : cellFormat;
+    return __assign({ uf: ef }, (protection ? { protection: protection } : {}));
+}
+export var getExtendedValue = function (rawValue) {
+    var rawValueType = typeof rawValue;
+    if (rawValueType === "boolean") {
+        return { bv: rawValue };
+    }
+    else if (rawValueType === "string") {
+        return { sv: rawValue };
+    }
+    else if (rawValueType === "number") {
+        return { nv: rawValue };
+    }
+};
+/**
+ * Extract the raw and formatted value from a cell
+ */
+function extractCellValue(cell, workbook, activeSheetName) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    // Handle namespaced properties (x:v and x:f)
+    var cellValueNode = (_a = cell.v) !== null && _a !== void 0 ? _a : cell["x:v"];
+    var cellValueText = getNodeText(cellValueNode);
+    var inlineStringValue = getInlineStringValue(cell);
+    var cellFormula = (_b = cell.f) !== null && _b !== void 0 ? _b : cell["x:f"];
+    var cellType = cell.a$ && cell.a$.t ? cell.a$.t : "n"; // Default to number
+    var hasPrimitiveValue = cellValueText !== undefined && cellValueText !== "";
+    var hasInlineValue = inlineStringValue !== undefined && inlineStringValue !== "";
+    // Check if the cell is empty
+    if (!hasPrimitiveValue &&
+        !hasInlineValue &&
+        !cellFormula &&
+        !cell.t$ &&
+        cellType !== "s") {
+        return { rawValue: null, formulaValue: null, sharedStringIndex: undefined };
+    }
+    var rawValue = null;
+    var formulaValue = null;
+    var sharedStringIndex;
+    var isError = false;
+    var arrayFormulaRef;
+    var sharedFormulaSpec;
+    if (cellFormula) {
+        // Shared formula. Capture provenance so the exporter can re-emit
+        // `<f t="shared" si="N" ref="…">FORMULA</f>` on the leader and
+        // `<f t="shared" si="N"/>` on followers. The leader cell carries both
+        // `t="shared"` and `ref` (the range the formula applies to); follower
+        // cells carry `t="shared"` + `si` but no `ref`. Without this, the
+        // exporter expands every follower to a standalone `<f>` and the
+        // structural compression is lost on round-trip.
+        if (cellFormula.a$ && cellFormula.a$.t === "shared") {
+            var sharedIndex = cellFormula.a$.si;
+            var sharedFormula = cellFormula.t$;
+            var siNum = sharedIndex !== undefined && sharedIndex !== null
+                ? Number(sharedIndex)
+                : NaN;
+            if (Number.isFinite(siNum)) {
+                sharedFormulaSpec = __assign({ si: siNum }, (cellFormula.a$.ref ? { ref: cellFormula.a$.ref } : {}));
+            }
+            // if (!sharedFormulaMap.has(sharedIndex)) {
+            if (sharedFormula && workbook.sharedFormulaMap) {
+                workbook.sharedFormulaMap.set(sharedIndex, [sharedFormula, cell.a$.r]);
+            }
+        }
+        // Array formula. The `ref` attribute names the spill range
+        // ("G7:G7" single-cell, "B5:B20" multi-cell). Only the anchor cell
+        // carries the `<f>` element; spilled cells in the range have no formula
+        // and therefore never reach this branch. Default to the cell's own
+        // coordinate when `ref` is absent (some writers omit it for single-cell).
+        if (cellFormula.a$ && cellFormula.a$.t === "array") {
+            var cellRef = (_c = cell.a$) === null || _c === void 0 ? void 0 : _c.r;
+            arrayFormulaRef =
+                (_d = cellFormula.a$.ref) !== null && _d !== void 0 ? _d : (cellRef ? "".concat(cellRef, ":").concat(cellRef) : undefined);
+        }
+        // Shared-formula followers parse as `{ a$: { t: "shared", si }, t$: "" }` —
+        // the self-closing `<f t="shared" si=".."/>` has no text content but the
+        // XML parser still creates an empty `t$`. The original `t$ !== undefined`
+        // check matched that empty string, returning `""` and skipping the
+        // shared-formula translation branch below. Require `t$` to be a non-empty
+        // string so followers fall through and pick up the leader's formula.
+        if (typeof cellFormula === "string") {
+            formulaValue = cellFormula;
+        }
+        else if (typeof cellFormula.t$ === "string" && cellFormula.t$ !== "") {
+            formulaValue = cellFormula.t$;
+        }
+        else if (cellFormula._ !== undefined && cellFormula._ !== "") {
+            formulaValue = cellFormula._;
+        }
+        else if (cellFormula.a$ && cellFormula.a$.t === "shared") {
+            // Shared-formula reference. Excel's shared-formula semantics preserve
+            // absolute references (`$A$1`) verbatim and only shift relative refs.
+            // Pass `preserveAbsolutes: true` explicitly — the default shifts
+            // `$A$1` along with relative refs, which corrupts followers.
+            var sharedIndex = cellFormula.a$.si;
+            var sFormula = (_e = workbook.sharedFormulaMap) === null || _e === void 0 ? void 0 : _e.get(sharedIndex);
+            if (sFormula) {
+                var _k = __read(sFormula, 2), sharedFormula = _k[0], sourceCell = _k[1];
+                var sourceCellInterface = addressToCell(sourceCell);
+                var destinationCell = addressToCell(cell.a$.r);
+                if (sourceCellInterface && destinationCell) {
+                    try {
+                        var finalFormula = formulaToRelativeReference(sharedFormula, sourceCellInterface, destinationCell, activeSheetName !== null && activeSheetName !== void 0 ? activeSheetName : "", { preserveAbsolutes: true });
+                        formulaValue = finalFormula;
+                    }
+                    catch (err) { }
+                }
+            }
+        }
+    }
+    if (formulaValue) {
+        formulaValue = normalizeFormulaSheetNames(formulaValue);
+    }
+    switch (cellType) {
+        case "s": {
+            // Shared string
+            if (hasPrimitiveValue) {
+                var stringIndex = Number(cellValueText);
+                if (!Number.isNaN(stringIndex)) {
+                    sharedStringIndex = stringIndex;
+                    rawValue =
+                        (_h = (_g = (_f = workbook.sharedStrings) === null || _f === void 0 ? void 0 : _f[stringIndex]) !== null && _g !== void 0 ? _g : cellValueText) !== null && _h !== void 0 ? _h : "";
+                }
+                else {
+                    rawValue = cellValueText !== null && cellValueText !== void 0 ? cellValueText : "";
+                }
+            }
+            else if (inlineStringValue !== undefined) {
+                rawValue = inlineStringValue;
+            }
+            else {
+                rawValue = "";
+            }
+            break;
+        }
+        case "n": // Number
+            rawValue =
+                cellValueText !== undefined && cellValueText !== ""
+                    ? parseFloat(cellValueText)
+                    : undefined;
+            // For time
+            // Check if this number should be treated as a date/time based on its format
+            if (cell.a$ && cell.a$.s) {
+                var styleIndex = parseInt(cell.a$.s);
+                // You'll need a function to get the numFmtId from the style
+                var xf = workbook.workbookStyles.getCellXfs(styleIndex);
+                var numFmtId = ((_j = xf === null || xf === void 0 ? void 0 : xf.a$) === null || _j === void 0 ? void 0 : _j.numFmtId) ? parseInt(xf.a$.numFmtId) : NaN;
+                // Time formats typically have numFmtId values: 18-21 and 45-47
+                // Date formats typically have numFmtId values: 14-17 and 22
+                var isTimeFormat = [18, 19, 20, 21, 45, 46, 47].includes(numFmtId);
+                var isDateFormat = [14, 15, 16, 17, 22].includes(numFmtId);
+                if (isTimeFormat || isDateFormat) {
+                    // Convert Excel date/time to JS Date object
+                    // rawValue = toDate(rawValue);
+                }
+            }
+            break;
+        case "b": // Boolean
+            rawValue =
+                cellValueText === "1" ||
+                    cellValueText === "TRUE" ||
+                    cellValueText === "true";
+            break;
+        case "d": // Date
+            rawValue =
+                cellValueText !== undefined && cellValueText !== ""
+                    ? parseFloat(cellValueText)
+                    : undefined;
+            // Convert Excel date to JS Date object
+            // rawValue = toDate(rawValue);
+            break;
+        case "e": // Error
+            rawValue = cellValueText;
+            isError = true;
+            break;
+        case "str": // Formula string result
+            rawValue = cellValueText !== null && cellValueText !== void 0 ? cellValueText : "";
+            break;
+        case "inlineStr":
+            rawValue = inlineStringValue !== null && inlineStringValue !== void 0 ? inlineStringValue : "";
+            break;
+        default:
+            rawValue = cellValueText;
+            break;
+    }
+    return {
+        rawValue: rawValue,
+        formulaValue: formulaValue,
+        sharedStringIndex: sharedStringIndex,
+        isError: isError,
+        arrayFormulaRef: arrayFormulaRef,
+        sharedFormulaSpec: sharedFormulaSpec,
+    };
+}
+function normalizeFormulaSheetNames(formula) {
+    return formula.replace(/('([^']|'')+'|[^'!,]+)!/g, function (match, sheetName) {
+        if (!sheetName.startsWith("'")) {
+            return match;
+        }
+        var unescaped = sheetName.slice(1, -1).replace(/''/g, "'");
+        if (canUnquoteSheetName(unescaped)) {
+            return "".concat(unescaped, "!");
+        }
+        return "'".concat(unescaped.replace(/'/g, "''"), "'!");
+    });
+}
+function canUnquoteSheetName(sheetName) {
+    if (!/^[A-Za-z0-9_]+$/.test(sheetName)) {
+        return false;
+    }
+    if (/^[A-Za-z]{1,3}\d+$/.test(sheetName)) {
+        return false;
+    }
+    if (/^R\d+C\d+$/i.test(sheetName)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Extract the cell formatting information
+ */
+// Per OOXML §18.8.45 (CT_Xf), a cellXf with xfId="N" (N>0) inherits from
+// cellStyleXfs[N] (the named-style xf table). For each property X
+// (numFmt, font, fill, border, alignment), the cell-level value is used
+// only when applyX="1"; otherwise the parent named style provides X.
+// Build an effective xf that merges the cell-level overrides on top of the
+// parent named style so downstream extractors see the resolved values.
+function buildEffectiveXf(cellXf, parentXf) {
+    if (!parentXf)
+        return cellXf;
+    var cellAttrs = cellXf.a$ || {};
+    var parentAttrs = parentXf.a$ || {};
+    var resolvedAttrs = __assign({}, cellAttrs);
+    // Only inherit when applyX="0" is explicitly set on the cell-level xf —
+    // that means "ignore my X, take it from the parent named style." When
+    // applyX is absent, Excel treats the cell-level X as the active value
+    // (this matches openpyxl, LibreOffice, and Excel itself). The earlier
+    // `applyX !== "1"` rule was too aggressive and silently replaced
+    // explicit cell-level fontIds with the parent's default.
+    var inheritIfApplyZero = function (applyKey, attrKey) {
+        if (cellAttrs[applyKey] === "0" && parentAttrs[attrKey] !== undefined) {
+            resolvedAttrs[attrKey] = parentAttrs[attrKey];
+        }
+    };
+    inheritIfApplyZero("applyNumberFormat", "numFmtId");
+    inheritIfApplyZero("applyFont", "fontId");
+    inheritIfApplyZero("applyFill", "fillId");
+    inheritIfApplyZero("applyBorder", "borderId");
+    var effectiveXf = __assign(__assign({}, cellXf), { a$: resolvedAttrs });
+    if (cellAttrs.applyAlignment === "0") {
+        var parentAlignment = getNode(parentXf, "alignment", "x:alignment");
+        if (parentAlignment) {
+            effectiveXf.alignment = parentAlignment;
+            delete effectiveXf["x:alignment"];
+        }
+    }
+    return effectiveXf;
+}
+/**
+ * Read OOXML `<protection>` flags off a resolved xf. Returns undefined
+ * when the cell uses Excel's defaults (locked=true, hidden=false) so the
+ * caller only writes a `protection` field on the cell when it deviates.
+ */
+function readProtectionFromXf(xf) {
+    var node = getNode(xf, "protection", "x:protection");
+    if (!node)
+        return undefined;
+    var attrs = node.a$ || {};
+    var lockedRaw = attrs.locked;
+    var hiddenRaw = attrs.hidden;
+    var protection = {};
+    if (lockedRaw !== undefined && lockedRaw !== null) {
+        var locked = lockedRaw === "0" || lockedRaw === "false" || lockedRaw === false
+            ? false
+            : true;
+        if (locked === false)
+            protection.locked = false;
+    }
+    if (hiddenRaw !== undefined && hiddenRaw !== null) {
+        var hidden = hiddenRaw === "1" || hiddenRaw === "true" || hiddenRaw === true;
+        if (hidden === true)
+            protection.hidden = true;
+    }
+    return Object.keys(protection).length ? protection : undefined;
+}
+/**
+ * Resolve the xf for a cell and extract its protection flags. Returns
+ * undefined when the cell has no style or the style is at Excel defaults.
+ */
+export function extractCellProtection(cell, workbookStyles) {
+    if (!(cell === null || cell === void 0 ? void 0 : cell.a$) || !cell.a$.s)
+        return undefined;
+    var styleIndex = parseInt(cell.a$.s);
+    var cellXf = workbookStyles.getCellXfs(styleIndex);
+    if (!cellXf)
+        return undefined;
+    var xfIdStr = cellXf.a$ && cellXf.a$.xfId;
+    var xfId = xfIdStr !== undefined ? parseInt(xfIdStr) : 0;
+    var parentXf = xfId > 0 ? workbookStyles.getCellStyleXf(xfId) : null;
+    var xf = buildEffectiveXf(cellXf, parentXf);
+    return readProtectionFromXf(xf);
+}
+function extractCellFormat(cell, workbookStyles, mergeContext) {
+    // Default empty cell format
+    var cellFormat = {};
+    // If no style info, return default
+    if (!cell.a$ || !cell.a$.s) {
+        return cellFormat;
+    }
+    var styleIndex = parseInt(cell.a$.s);
+    var cellXf = workbookStyles.getCellXfs(styleIndex);
+    if (!cellXf)
+        return cellFormat;
+    // Resolve named-style inheritance. Cells using a built-in or custom named
+    // style ("Currency", "Comma", custom company styles) reference the parent
+    // via xfId; properties the cell doesn't explicitly override (applyX != "1")
+    // come from the parent. Skipping this resolution silently drops the named
+    // style's formatting (font, fill, border, numFmt).
+    var xfIdStr = cellXf.a$ && cellXf.a$.xfId;
+    var xfId = xfIdStr !== undefined ? parseInt(xfIdStr) : 0;
+    var parentXf = xfId > 0 ? workbookStyles.getCellStyleXf(xfId) : null;
+    var xf = buildEffectiveXf(cellXf, parentXf);
+    // Extract number format
+    var numberFormat = extractNumberFormat(xf, workbookStyles);
+    if (!((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "GENERAL" && !numberFormat.pattern)) {
+        cellFormat.numberFormat = numberFormat;
+    }
+    // `[Red]`/`[ColorN]` number-format colors are a render-time concern:
+    // the canvas grid resolves the pattern's active section color against
+    // the CURRENT value at paint time. Import must store the cell's real
+    // font color — baking the format-derived color into `textFormat.color`
+    // froze the import-time value's color onto the cell (a cell that later
+    // changed sign kept the stale color) and destroyed the cell's actual
+    // explicit font color.
+    cellFormat.textFormat = extractTextFormat(xf, workbookStyles);
+    // Only set horizontalAlignment when the source xf carried an explicit
+    // <alignment horizontal="…"/>. Excel's default behavior (right-align
+    // numbers, left-align text) is a render-time concern, not a model-level
+    // attribute — fabricating it on import produces an alignment xf on export
+    // that wasn't in the source.
+    var xfAlignment = getNode(xf, "alignment", "x:alignment");
+    if (xfAlignment) {
+        var alignment = xfAlignment.a$ || {};
+        if (alignment.horizontal) {
+            cellFormat.horizontalAlignment = alignment.horizontal;
+        }
+        var verticalAlignment = mapVerticalAlignment(alignment.vertical);
+        if (verticalAlignment && verticalAlignment !== "bottom") {
+            cellFormat.verticalAlignment = verticalAlignment;
+        }
+        var wrapText = alignment.wrapText === "1" || alignment.wrapText === "true"
+            ? "wrap"
+            : "overflow";
+        if (wrapText !== "overflow") {
+            cellFormat.wrapStrategy = wrapText;
+        }
+        var indent = alignment.indent ? parseInt(alignment.indent) : null;
+        if (indent)
+            cellFormat.indent = indent;
+        var relativeIndent = alignment.relativeIndent
+            ? parseInt(alignment.relativeIndent)
+            : null;
+        if (relativeIndent)
+            cellFormat.relativeIndent = relativeIndent;
+        if (alignment.textRotation) {
+            var rotation = parseInt(alignment.textRotation);
+            cellFormat.textRotation = rotation === 255 ? "vertical" : rotation;
+        }
+        if (alignment.shrinkToFit === "1" || alignment.shrinkToFit === "true") {
+            cellFormat.shrinkToFit = true;
+        }
+    }
+    // Extract background color + pattern (if any). For solid fills only
+    // `backgroundColor` is populated (existing behavior). For patterned fills
+    // all three of `fillPattern` / `foregroundColor` / `backgroundColor` are
+    // set so the renderer can tile the pattern over the under-layer.
+    var fillInfo = extractFillInfo(xf, workbookStyles);
+    if (fillInfo) {
+        if (fillInfo.backgroundColor !== undefined) {
+            cellFormat.backgroundColor = fillInfo.backgroundColor;
+        }
+        if (fillInfo.foregroundColor !== undefined) {
+            cellFormat.foregroundColor = fillInfo.foregroundColor;
+        }
+        if (fillInfo.fillPattern !== undefined) {
+            cellFormat.fillPattern = fillInfo.fillPattern;
+        }
+        if (fillInfo.gradient !== undefined) {
+            cellFormat.gradient = fillInfo.gradient;
+        }
+    }
+    // Extract borders
+    var borders = extractBorders(xf, workbookStyles);
+    borders = mergeBordersForAnchorCell(borders, cell, workbookStyles, mergeContext);
+    if (borders)
+        cellFormat.borders = borders;
+    return cellFormat;
+}
+function mergeBordersForAnchorCell(borders, cell, workbookStyles, mergeContext) {
+    var _a;
+    if (!mergeContext)
+        return borders;
+    var cellRef = (_a = cell === null || cell === void 0 ? void 0 : cell.a$) === null || _a === void 0 ? void 0 : _a.r;
+    if (!cellRef)
+        return borders;
+    var cellPosition = addressToCell(cellRef);
+    if (!cellPosition)
+        return borders;
+    var range = mergeContext.range, rowCellsByColumnIndex = mergeContext.rowCellsByColumnIndex;
+    var isAnchorCell = cellPosition.rowIndex === range.startRowIndex &&
+        cellPosition.columnIndex === range.startColumnIndex;
+    if (!isAnchorCell)
+        return borders;
+    var mergedBorders = borders ? __assign({}, borders) : {};
+    var leftCell = rowCellsByColumnIndex.get(range.startColumnIndex);
+    var rightCell = rowCellsByColumnIndex.get(range.endColumnIndex);
+    var leftBorders = leftCell
+        ? extractBordersFromCell(leftCell, workbookStyles)
+        : null;
+    var rightBorders = rightCell
+        ? extractBordersFromCell(rightCell, workbookStyles)
+        : null;
+    if (!mergedBorders.left && (leftBorders === null || leftBorders === void 0 ? void 0 : leftBorders.left)) {
+        mergedBorders.left = leftBorders.left;
+    }
+    if (!mergedBorders.right && (rightBorders === null || rightBorders === void 0 ? void 0 : rightBorders.right)) {
+        mergedBorders.right = rightBorders.right;
+    }
+    if (range.startRowIndex === range.endRowIndex) {
+        var rowEdgeCell = leftCell !== null && leftCell !== void 0 ? leftCell : rightCell;
+        var rowBorders = rowEdgeCell
+            ? extractBordersFromCell(rowEdgeCell, workbookStyles)
+            : null;
+        if (!mergedBorders.top && (rowBorders === null || rowBorders === void 0 ? void 0 : rowBorders.top)) {
+            mergedBorders.top = rowBorders.top;
+        }
+        if (!mergedBorders.bottom && (rowBorders === null || rowBorders === void 0 ? void 0 : rowBorders.bottom)) {
+            mergedBorders.bottom = rowBorders.bottom;
+        }
+    }
+    return Object.keys(mergedBorders).length > 0 ? mergedBorders : null;
+}
+function extractBordersFromCell(cell, workbookStyles) {
+    var _a;
+    if (!((_a = cell === null || cell === void 0 ? void 0 : cell.a$) === null || _a === void 0 ? void 0 : _a.s))
+        return null;
+    var styleIndex = parseInt(cell.a$.s);
+    var xf = workbookStyles.getCellXfs(styleIndex);
+    if (!xf)
+        return null;
+    return extractBorders(xf, workbookStyles);
+}
+/**
+ * Extract text formatting information from a style
+ */
+function extractTextFormat(xf, workbookStyles) {
+    if (!xf.a$ || !xf.a$.fontId) {
+        return null;
+    }
+    var fontId = parseInt(xf.a$.fontId);
+    var font = workbookStyles.getFont(fontId);
+    return fontNodeToTextFormat(font, workbookStyles);
+}
+/**
+ * Parse a raw styles.xml `<font>` node into a TextFormat. Also used for the
+ * workbook default font (fonts[0]) so the exporter can round-trip it.
+ */
+export function fontNodeToTextFormat(font, workbookStyles) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!font) {
+        return null;
+    }
+    // Create text format object
+    var textFormat = {};
+    // Extract properties. An explicit `<name val>` always wins; a font that
+    // instead carries `<scheme val="major|minor"/>` follows the workbook
+    // theme's `<a:fontScheme>` typefaces (headings/body). Without this,
+    // scheme-only fonts (Excel writes them for theme-styled cells) had no
+    // fontFamily at all and silently rendered in the renderer default.
+    // Missing theme → leave unresolved (mirrors rnc-import's
+    // `resolve_scheme_fonts`).
+    var fontName = getNode(font, "name", "x:name");
+    if ((_a = fontName === null || fontName === void 0 ? void 0 : fontName.a$) === null || _a === void 0 ? void 0 : _a.val) {
+        textFormat.fontFamily = fontName.a$.val;
+    }
+    else {
+        var schemeVal = (_c = (_b = getNode(font, "scheme", "x:scheme")) === null || _b === void 0 ? void 0 : _b.a$) === null || _c === void 0 ? void 0 : _c.val;
+        var themeFonts = workbookStyles.themeFonts;
+        var resolved = schemeVal === "major"
+            ? themeFonts === null || themeFonts === void 0 ? void 0 : themeFonts.major
+            : schemeVal === "minor"
+                ? themeFonts === null || themeFonts === void 0 ? void 0 : themeFonts.minor
+                : undefined;
+        if (resolved) {
+            textFormat.fontFamily = resolved;
+        }
+    }
+    var fontSize = getNode(font, "sz", "x:sz");
+    if ((_d = fontSize === null || fontSize === void 0 ? void 0 : fontSize.a$) === null || _d === void 0 ? void 0 : _d.val) {
+        textFormat.fontSize = parseInt(fontSize.a$.val);
+    }
+    var fontColor = getNode(font, "color", "x:color");
+    if (fontColor) {
+        textFormat.color = extractColor(fontColor, workbookStyles.indexedColors);
+    }
+    // Boolean font properties. OOXML allows `<X/>` (truthy by default),
+    // `<X val="true"/>` or `<X val="1"/>` (truthy), and `<X val="false"/>`,
+    // `<X val="0"/>`, or `<u val="none"/>` (explicitly falsy). The original
+    // code only checked element presence and treated `<u val="none"/>` as
+    // underlined — which fabricated underline on every cell whose source
+    // font carried that explicit "no underline" marker.
+    var isTruthyFlagNode = function (node) {
+        var _a, _b, _c;
+        if (node === undefined || node === null)
+            return false;
+        var val = typeof node === "object"
+            ? ((_c = (_b = (_a = node.a$) === null || _a === void 0 ? void 0 : _a.val) !== null && _b !== void 0 ? _b : node["#text"]) !== null && _c !== void 0 ? _c : node)
+            : node;
+        if (val === undefined || val === null || val === true)
+            return true;
+        var str = String(val).toLowerCase();
+        if (str === "" || str === "true" || str === "1")
+            return true;
+        return false;
+    };
+    if (isTruthyFlagNode(getNode(font, "b", "x:b")))
+        textFormat.bold = true;
+    if (isTruthyFlagNode(getNode(font, "i", "x:i")))
+        textFormat.italic = true;
+    if (isTruthyFlagNode(getNode(font, "strike", "x:strike"))) {
+        textFormat.strikethrough = true;
+    }
+    // Underline is not a boolean — `<u val="none"/>` means no underline,
+    // anything else (including absent val attribute) is some form of
+    // underline. Treat "none" specifically as falsy.
+    var uNode = getNode(font, "u", "x:u");
+    if (uNode !== undefined) {
+        var uVal = typeof uNode === "object"
+            ? ((_f = (_e = uNode.a$) === null || _e === void 0 ? void 0 : _e.val) !== null && _f !== void 0 ? _f : uNode["#text"])
+            : uNode;
+        var uStr = uVal === undefined || uVal === null ? "" : String(uVal).toLowerCase();
+        if (uStr !== "none") {
+            textFormat.underline = true;
+        }
+    }
+    var vertAlignNode = getNode(font, "vertAlign", "x:vertAlign");
+    if ((_g = vertAlignNode === null || vertAlignNode === void 0 ? void 0 : vertAlignNode.a$) === null || _g === void 0 ? void 0 : _g.val) {
+        var v = String(vertAlignNode.a$.val).toLowerCase();
+        if (v === "superscript")
+            textFormat.baselineOffset = "superscript";
+        else if (v === "subscript")
+            textFormat.baselineOffset = "subscript";
+    }
+    return textFormat;
+}
+/**
+ * Extract color information
+ */
+export function extractColor(colorObj, indexedColors) {
+    if (!colorObj || !colorObj.a$) {
+        return undefined;
+    }
+    if (colorObj.a$.auto &&
+        (colorObj.a$.auto === "1" || colorObj.a$.auto === "true")) {
+        return {
+            theme: 1,
+        };
+    }
+    if (colorObj.a$.indexed) {
+        var index = parseInt(colorObj.a$.indexed);
+        // Last color
+        if (index === 64) {
+            return {
+                theme: 1,
+            };
+        }
+        if (indexedColors && indexedColors.length > 0) {
+            var paletteColor = indexedColors[index];
+            if (paletteColor) {
+                return paletteColor;
+            }
+        }
+        return IndexedColors[index];
+    }
+    else if (colorObj.a$.rgb) {
+        // OOXML §18.3.1.15 says <color rgb> is 8-char aRGB, but real-world
+        // files commonly emit the 6-char RGB form (alpha implied FF — this
+        // is what Office's default theme accent colors look like in many
+        // sheets). Only strip the alpha-prefix when the input is actually
+        // 8 chars; otherwise pass through verbatim so the exporter can
+        // canonicalize 6→8 by prepending FF. Blindly substring(2) turned
+        // `44546A` into `546A`, which downstream consumers (openpyxl) then
+        // refuse to load.
+        var raw = String(colorObj.a$.rgb).trim();
+        return "#" + (raw.length === 8 ? raw.substring(2) : raw);
+    }
+    else if (colorObj.a$.theme) {
+        return {
+            theme: parseInt(colorObj.a$.theme),
+            tint: colorObj.a$.tint ? parseFloat(colorObj.a$.tint) : null,
+        };
+    }
+    return null;
+}
+/**
+ * Extract number format information
+ */
+function extractNumberFormat(xf, workbookStyles) {
+    var _a, _b, _c;
+    if (!xf.a$ || !xf.a$.numFmtId)
+        return null;
+    var numFmtId = parseInt(xf.a$.numFmtId);
+    var formatCode = (_a = standardExcelFormatCodeById.get(numFmtId)) !== null && _a !== void 0 ? _a : null;
+    // Check for custom number formats
+    if ((_b = workbookStyles.numFmts) === null || _b === void 0 ? void 0 : _b.length) {
+        var numFmts = workbookStyles.numFmts;
+        var customFormat = numFmts.find(function (fmt) { return fmt.a$ && parseInt(fmt.a$.numFmtId) === numFmtId; });
+        if (customFormat && customFormat.a$ && customFormat.a$.formatCode) {
+            formatCode = customFormat.a$.formatCode;
+        }
+    }
+    // Map number format type based on id or format code
+    var type = (_c = mapNumberFormatType(numFmtId, formatCode)) !== null && _c !== void 0 ? _c : "GENERAL";
+    return {
+        type: type,
+        pattern: formatCode,
+    };
+}
+/**
+ * Map Excel number format ID to our NumberFormatType
+ */
+function mapNumberFormatType(numFmtId, formatCode) {
+    // Built-in format ids
+    switch (numFmtId) {
+        case 0:
+            return "GENERAL";
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 6:
+        case 7:
+        case 8:
+        case 11:
+            return "NUMBER";
+        case 14:
+        case 15:
+        case 16:
+        case 17:
+            return "DATE";
+        case 18:
+        case 19:
+        case 20:
+        case 21:
+        case 45:
+        case 46:
+        case 47:
+            return "TIME";
+        case 22:
+            return "DATE_TIME";
+        case 9:
+        case 10:
+            return "PERCENT";
+        case 12:
+        case 13:
+            return "FRACTION";
+        case 48:
+        case 49:
+            return "TEXT";
+        case 5:
+        case 37:
+        case 38:
+            return "CURRENCY";
+        case 39:
+        case 40:
+        case 41:
+        case 42:
+        case 43:
+        case 44:
+            return "ACCOUNTING";
+    }
+    // For custom formats, analyze the pattern
+    if (formatCode) {
+        // Get the first section (positive numbers format)
+        var mainSection = formatCode.split(";")[0];
+        var _a = stripQuotedAndBracketLiterals(mainSection), cleanedSection = _a.cleanedSection, hasBracketedTimeToken = _a.hasBracketedTimeToken;
+        // Check for date components - d, m, y that aren't escaped
+        var hasDateComponent = false;
+        var i = 0;
+        while (i < cleanedSection.length) {
+            if (cleanedSection[i] === "\\") {
+                // Skip escaped character
+                i += 2;
+            }
+            else {
+                var char = cleanedSection[i].toLowerCase();
+                if (char === "d" || char === "m" || char === "y") {
+                    hasDateComponent = true;
+                    break;
+                }
+                i++;
+            }
+        }
+        if (hasDateComponent) {
+            // Check if it also has time components - h, s, :
+            var hasTimeComponent = false;
+            i = 0;
+            while (i < cleanedSection.length) {
+                if (cleanedSection[i] === "\\") {
+                    // Skip escaped character
+                    i += 2;
+                }
+                else {
+                    var char = cleanedSection[i].toLowerCase();
+                    if (char === "h" || char === "s" || char === ":") {
+                        hasTimeComponent = true;
+                        break;
+                    }
+                    i++;
+                }
+            }
+            if (hasTimeComponent || hasBracketedTimeToken) {
+                return "DATE_TIME";
+            }
+            else {
+                return "DATE";
+            }
+        }
+        // Check for currency symbols. They appear in formats as either:
+        //   - a quoted literal:  "$"#,##0   (Excel writes it this way)
+        //   - a bracketed currency: [$$-409]#,##0   (international forms)
+        //   - a bare symbol:     $#,##0     (older format strings)
+        // `cleanedSection` has stripped quotes and brackets, so we check the
+        // RAW main section, but first remove the locale specifier pattern
+        // `[$-XXXX]` (the `$` there is structural, not a currency symbol).
+        var localeSpecifierPattern = /\[\$-[0-9A-Fa-f]+\]/g;
+        var rawWithoutLocale = mainSection.replace(localeSpecifierPattern, "");
+        if (rawWithoutLocale.includes("$") ||
+            rawWithoutLocale.includes("€") ||
+            rawWithoutLocale.includes("£") ||
+            rawWithoutLocale.includes("¥")) {
+            return "CURRENCY";
+        }
+        // Other types
+        if (cleanedSection.includes("%")) {
+            return "PERCENT";
+        }
+        if (cleanedSection.includes("/")) {
+            return "FRACTION";
+        }
+        // Check for time patterns that aren't escaped
+        var hasTimePattern = false;
+        i = 0;
+        while (i < cleanedSection.length) {
+            if (cleanedSection[i] === "\\") {
+                // Skip escaped character
+                i += 2;
+            }
+            else {
+                var char = cleanedSection[i].toLowerCase();
+                if (char === "h" ||
+                    char === "s" ||
+                    char === ":" ||
+                    cleanedSection.substring(i).startsWith("AM/PM") ||
+                    cleanedSection.substring(i).startsWith("am/pm")) {
+                    hasTimePattern = true;
+                    break;
+                }
+                i++;
+            }
+        }
+        if (hasTimePattern || hasBracketedTimeToken) {
+            return "TIME";
+        }
+        if (cleanedSection.match(/[0#?]+(\.[0#?]+)?[eE][+-]?[0#?]+/)) {
+            return "SCIENTIFIC";
+        }
+        if (cleanedSection.includes("@")) {
+            return "TEXT";
+        }
+        var hasNumberPlaceholder = cleanedSection.match(/[0#?]/);
+        if (!hasNumberPlaceholder) {
+            var trimmed = cleanedSection.trim();
+            if (trimmed === "" || trimmed.toLowerCase() === "general") {
+                return "GENERAL";
+            }
+            return "TEXT";
+        }
+    }
+    // Default to number for any other custom format
+    return "NUMBER";
+}
+function stripQuotedAndBracketLiterals(section) {
+    var result = "";
+    var inQuotes = false;
+    var i = 0;
+    var hasBracketedTimeToken = false;
+    while (i < section.length) {
+        var char = section[i];
+        if (char === "\\") {
+            // Skip escaped character entirely.
+            i += 2;
+            continue;
+        }
+        if (char === '"') {
+            if (inQuotes && section[i + 1] === '"') {
+                // Escaped quote inside a quoted literal.
+                i += 2;
+                continue;
+            }
+            inQuotes = !inQuotes;
+            i += 1;
+            continue;
+        }
+        if (inQuotes) {
+            i += 1;
+            continue;
+        }
+        if (char === "[") {
+            var end = section.indexOf("]", i + 1);
+            var content = end === -1 ? section.substring(i + 1) : section.substring(i + 1, end);
+            if (content.match(/^[hms]+$/i)) {
+                hasBracketedTimeToken = true;
+            }
+            i = end === -1 ? section.length : end + 1;
+            continue;
+        }
+        result += char;
+        i += 1;
+    }
+    return { cleanedSection: result, hasBracketedTimeToken: hasBracketedTimeToken };
+}
+// Patterned-fill type → engine enum. Excel writes ~18 distinct
+// patternType values; the engine carries the same names. `none` is treated
+// as "no fill" (returns null).
+var KNOWN_FILL_PATTERNS = new Set([
+    "solid",
+    "mediumGray",
+    "darkGray",
+    "lightGray",
+    "darkHorizontal",
+    "darkVertical",
+    "darkDown",
+    "darkUp",
+    "darkGrid",
+    "darkTrellis",
+    "lightHorizontal",
+    "lightVertical",
+    "lightDown",
+    "lightUp",
+    "lightGrid",
+    "lightTrellis",
+    "gray125",
+    "gray0625",
+]);
+/**
+ * Extract patterned-fill information (pattern type + fg/bg colors). For
+ * `solid` patterns the foreground color is hoisted to `backgroundColor` so
+ * the existing renderer / consumers keep working — that's also OOXML's
+ * authoring convention (a "solid" fill puts the visible color in fgColor).
+ *
+ * Also handles `<gradientFill>` (Excel Phase 8) — both `linear` (with a
+ * `degree`) and `path` (radial/rectangular, with `left`/`right`/`top`/
+ * `bottom` insets). Gradient fills coexist with — but take precedence
+ * over — pattern fills, matching Excel's UI (you pick ONE or the other).
+ */
+function extractFillInfo(xf, workbookStyles) {
+    var _a;
+    if (!xf.a$ || !xf.a$.fillId)
+        return null;
+    var fillId = parseInt(xf.a$.fillId);
+    if (fillId === 0)
+        return null;
+    var fill = workbookStyles.getFill(fillId);
+    if (!fill)
+        return null;
+    // <gradientFill> branch — extract type + stops + axis attrs.
+    var gradientFill = getNode(fill, "gradientFill", "x:gradientFill");
+    if (gradientFill) {
+        var gradient = extractGradientFill(gradientFill, workbookStyles);
+        if (gradient)
+            return { gradient: gradient };
+    }
+    var patternFill = getNode(fill, "patternFill", "x:patternFill");
+    if (!patternFill)
+        return null;
+    var patternAttrs = (_a = patternFill.a$) !== null && _a !== void 0 ? _a : {};
+    var patternType = patternAttrs.patternType;
+    if (patternType === "none" || patternType === undefined)
+        return null;
+    var fgColorNode = getNode(patternFill, "fgColor", "x:fgColor");
+    var bgColorNode = getNode(patternFill, "bgColor", "x:bgColor");
+    var fgColor = fgColorNode
+        ? extractColor(fgColorNode, workbookStyles.indexedColors)
+        : undefined;
+    var bgColor = bgColorNode
+        ? extractColor(bgColorNode, workbookStyles.indexedColors)
+        : undefined;
+    // gray125 is Excel's default placeholder fill — historically dropped on
+    // import. Keep that behavior unless the file explicitly carries colors,
+    // in which case it's a real pattern the user chose.
+    if (patternType === "gray125" && !fgColor && !bgColor)
+        return null;
+    // For "solid" pattern, hoist the foreground into the legacy
+    // `backgroundColor` slot so the existing renderer path stays the
+    // hot path. The `fillPattern: "solid"` field is still emitted for
+    // round-trip identity on export.
+    if (patternType === "solid") {
+        return __assign({ fillPattern: "solid" }, (fgColor !== undefined ? { backgroundColor: fgColor } : {}));
+    }
+    // True patterned fill — preserve all three fields.
+    return __assign(__assign({ fillPattern: KNOWN_FILL_PATTERNS.has(patternType) ? patternType : undefined }, (fgColor !== undefined ? { foregroundColor: fgColor } : {})), (bgColor !== undefined ? { backgroundColor: bgColor } : {}));
+}
+/**
+ * Parse a `<gradientFill>` node into our `GradientFill` shape. Returns
+ * `null` if the gradient is unusable (no parseable stops). Stops are
+ * sorted by `position` ascending to match the renderer's expectations.
+ */
+function extractGradientFill(gradientFill, workbookStyles) {
+    var e_2, _a;
+    var _b, _c, _d, _e, _f, _g, _h, _j;
+    var attrs = (_b = gradientFill.a$) !== null && _b !== void 0 ? _b : {};
+    var type = attrs.type === "path" ? "path" : "linear";
+    // The fast-xml-parser surfaces repeated <stop> children as either an
+    // array (multiple) or a single object (one). Normalize.
+    var rawStops = (_c = getNode(gradientFill, "stop", "x:stop")) !== null && _c !== void 0 ? _c : getNode(gradientFill, "stops", "x:stops");
+    if (rawStops == null)
+        return null;
+    if (!Array.isArray(rawStops))
+        rawStops = [rawStops];
+    var stops = [];
+    try {
+        for (var rawStops_1 = __values(rawStops), rawStops_1_1 = rawStops_1.next(); !rawStops_1_1.done; rawStops_1_1 = rawStops_1.next()) {
+            var s = rawStops_1_1.value;
+            if (!s)
+                continue;
+            var sAttrs = (_d = s.a$) !== null && _d !== void 0 ? _d : {};
+            var positionRaw = sAttrs.position;
+            var position = typeof positionRaw === "number"
+                ? positionRaw
+                : positionRaw != null
+                    ? parseFloat(positionRaw)
+                    : NaN;
+            if (!Number.isFinite(position))
+                continue;
+            var colorNode = getNode(s, "color", "x:color");
+            if (!colorNode)
+                continue;
+            var color = extractColor(colorNode, workbookStyles.indexedColors);
+            if (color == null)
+                continue;
+            stops.push({ position: position, color: String(color) });
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (rawStops_1_1 && !rawStops_1_1.done && (_a = rawStops_1.return)) _a.call(rawStops_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (stops.length === 0)
+        return null;
+    stops.sort(function (a, b) { return a.position - b.position; });
+    var numAttr = function (k) {
+        var v = attrs[k];
+        if (v == null)
+            return undefined;
+        var n = typeof v === "number" ? v : parseFloat(v);
+        return Number.isFinite(n) ? n : undefined;
+    };
+    return __assign(__assign({ type: type }, (type === "linear"
+        ? { degree: (_e = numAttr("degree")) !== null && _e !== void 0 ? _e : 0 }
+        : {
+            left: (_f = numAttr("left")) !== null && _f !== void 0 ? _f : 0,
+            right: (_g = numAttr("right")) !== null && _g !== void 0 ? _g : 0,
+            top: (_h = numAttr("top")) !== null && _h !== void 0 ? _h : 0,
+            bottom: (_j = numAttr("bottom")) !== null && _j !== void 0 ? _j : 0,
+        })), { stops: stops });
+}
+/**
+ * Extract borders information
+ */
+function extractBorders(xf, workbookStyles) {
+    var _a, _b, _c;
+    if (!xf.a$ || !xf.a$.borderId)
+        return null;
+    var borderId = parseInt(xf.a$.borderId);
+    // Default no borders
+    if (borderId === 0)
+        return null;
+    var borders = workbookStyles.borders;
+    var border = borders[borderId];
+    if (!border)
+        return null;
+    var result = {};
+    // Process each side. Source XML often uses `<side style="none"/>` to
+    // indicate "no border on this edge"; the original truthy check on `style`
+    // was treating "none" as a real style and `mapBorderStyle`'s default
+    // branch returns "solid", producing fabricated solid borders on every
+    // edge that the source explicitly marked as none.
+    ["top", "right", "bottom", "left"].forEach(function (side) {
+        var _a;
+        var sideNode = getNode(border, side, "x:".concat(side));
+        var style = (_a = sideNode === null || sideNode === void 0 ? void 0 : sideNode.a$) === null || _a === void 0 ? void 0 : _a.style;
+        if (style && style !== "none") {
+            result[side] = {
+                style: mapBorderStyle(style),
+                width: mapBorderWidth(style),
+                color: getNode(sideNode, "color", "x:color")
+                    ? extractColor(getNode(sideNode, "color", "x:color"), workbookStyles.indexedColors)
+                    : null,
+            };
+        }
+    });
+    // Diagonals: OOXML uses a single <diagonal> child for the style/color,
+    // and `diagonalUp="1"` / `diagonalDown="1"` attributes on the parent
+    // <border> to pick which corner-to-corner line(s) get drawn.
+    var diagonalNode = getNode(border, "diagonal", "x:diagonal");
+    var diagonalStyle = (_a = diagonalNode === null || diagonalNode === void 0 ? void 0 : diagonalNode.a$) === null || _a === void 0 ? void 0 : _a.style;
+    if (diagonalStyle && diagonalStyle !== "none") {
+        var diagonalBorder = {
+            style: mapBorderStyle(diagonalStyle),
+            width: mapBorderWidth(diagonalStyle),
+            color: getNode(diagonalNode, "color", "x:color")
+                ? extractColor(getNode(diagonalNode, "color", "x:color"), workbookStyles.indexedColors)
+                : null,
+        };
+        var diagonalUpFlag = (_b = border === null || border === void 0 ? void 0 : border.a$) === null || _b === void 0 ? void 0 : _b.diagonalUp;
+        var diagonalDownFlag = (_c = border === null || border === void 0 ? void 0 : border.a$) === null || _c === void 0 ? void 0 : _c.diagonalDown;
+        var isTruthy = function (v) {
+            return v !== undefined && v !== "0" && v !== "false" && v !== false;
+        };
+        if (isTruthy(diagonalUpFlag))
+            result.diagonalUp = diagonalBorder;
+        if (isTruthy(diagonalDownFlag))
+            result.diagonalDown = diagonalBorder;
+    }
+    return Object.keys(result).length > 0 ? result : null;
+}
+/**
+ * Map Excel border style to our BorderStyle. Covers all 13 OOXML
+ * styles; the previous reduced set silently collapsed `hair` →
+ * `thin` and lost `mediumDashed` / `dashDot` / `dashDotDot` /
+ * `slantDashDot` entirely.
+ */
+function mapBorderStyle(excelStyle) {
+    switch (excelStyle) {
+        case "hair":
+            return "hair";
+        case "thin":
+            return "solid";
+        case "medium":
+            return "solid_medium";
+        case "thick":
+            return "solid_thick";
+        case "dashed":
+            return "dashed";
+        case "dotted":
+            return "dotted";
+        case "double":
+            return "double";
+        case "mediumDashed":
+            return "mediumDashed";
+        case "mediumDashDot":
+            return "mediumDashDot";
+        case "dashDot":
+            return "dashDot";
+        case "dashDotDot":
+            return "dashDotDot";
+        case "slantDashDot":
+            return "slantDashDot";
+        default:
+            return "solid";
+    }
+}
+/**
+ * Map border width based on style
+ */
+function mapBorderWidth(excelStyle) {
+    switch (excelStyle) {
+        case "hair":
+            // Hair is the lightest border in OOXML — slightly thinner than
+            // thin but the canvas can't paint sub-pixel lines, so it gets
+            // the same 1px width but a different dash signature.
+            return 1;
+        case "thin":
+            return 1;
+        case "medium":
+        case "mediumDashed":
+        case "mediumDashDot":
+            return 2;
+        case "thick":
+            return 3;
+        case "double":
+            return 2;
+        case "dashDot":
+        case "dashDotDot":
+        case "slantDashDot":
+            return 1;
+        default:
+            return 1;
+    }
+}
+/**
+ * Map horizontal alignment
+ */
+function mapHorizontalAlignment(excelAlign) {
+    switch (excelAlign) {
+        case "left":
+            return "left";
+        case "center":
+            return "center";
+        case "right":
+            return "right";
+        default:
+            return null;
+    }
+}
+/**
+ * Map vertical alignment
+ */
+function mapVerticalAlignment(excelAlign) {
+    switch (excelAlign) {
+        case "top":
+            return "top";
+        case "center":
+            return "middle";
+        case "bottom":
+            return "bottom";
+        default:
+            return null;
+    }
+}
+function getDefaultHorizontalAlignment(cell, xf, numberFormat) {
+    var cellType = cell.a$ && cell.a$.t ? cell.a$.t : undefined; // Default to number
+    if (cellType === "s") {
+        return undefined;
+    }
+    if (cellType === "b") {
+        return "center";
+    }
+    // If there's no explicit alignment, check the number format
+    if (xf.a$ && xf.a$.numFmtId) {
+        var numFmtId = parseInt(xf.a$.numFmtId);
+        // Currency formats (including custom ones) are typically right-aligned
+        // Custom number formats (numFmtId >= 164)
+        if (numFmtId >= 164) {
+            // Get the format code if workbookStyles is available
+            if ((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "NUMBER") {
+                return "right";
+            }
+        }
+        if ((numFmtId >= 5 && numFmtId <= 8) ||
+            (numFmtId >= 37 && numFmtId <= 44)) {
+            return "right";
+        }
+        // Most number formats are right-aligned
+        if ((numFmtId >= 1 && numFmtId <= 4) ||
+            (numFmtId >= 9 && numFmtId <= 11) ||
+            numFmtId === 37 ||
+            numFmtId === 38 ||
+            (numFmtId >= 39 && numFmtId <= 44)) {
+            return "right";
+        }
+    }
+    if (cellType === "n") {
+        return "right";
+    }
+    if (cellType === "b") {
+        return "center";
+    }
+    // Default for text
+    return undefined;
+}