@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,1365 @@
+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";
+const getNode = (node, ...keys) => {
+    if (!node)
+        return undefined;
+    for (const key of keys) {
+        if (node[key] !== undefined) {
+            return node[key];
+        }
+    }
+    return undefined;
+};
+const getNodeText = (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);
+};
+const getInlineStringValue = (cell) => {
+    if (!cell.is) {
+        return undefined;
+    }
+    if (cell.is.t !== undefined) {
+        const inlineValue = cell.is.t;
+        return typeof inlineValue === "object"
+            ? inlineValue.t$ ?? inlineValue._ ?? ""
+            : inlineValue;
+    }
+    if (cell.is.r) {
+        const runs = Array.isArray(cell.is.r) ? cell.is.r : [cell.is.r];
+        return runs
+            .map((run) => {
+            if (run.t === undefined)
+                return "";
+            return typeof run.t === "object" ? run.t.t$ ?? "" : 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 = false, enableSharedStrings = false, activeSheetName, mergeContext) {
+    if (!cell) {
+        return null;
+    }
+    // Extract raw value
+    const { rawValue: extractedRawValue, formulaValue, sharedStringIndex, isError, arrayFormulaRef, sharedFormulaSpec, } = extractCellValue(cell, workbook, activeSheetName);
+    let rawValue = extractedRawValue;
+    // Extract cell format
+    const cellFormat = extractCellFormat(cell, workbook.workbookStyles, mergeContext);
+    let 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.
+    const protection = extractCellProtection(cell, workbook.workbookStyles);
+    const isSharedStringCell = enableSharedStrings &&
+        sharedStringIndex !== undefined &&
+        formulaValue === null;
+    if (isSharedStringCell) {
+        if (enableCellXfsRegistry) {
+            const styleId = workbook.registerFormat(cellFormat);
+            ef = { sid: styleId };
+        }
+        const hasFormat = enableCellXfsRegistry || Object.keys(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 {
+            ...(hasFormat ? { uf: ef } : {}),
+            ss: String(sharedStringIndex),
+            ...(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) {
+        const [detectedValueType, detectedNumberFormatType, detectedNumberValue, detectedPattern,] = detectValueTypeAndPattern(rawValue, undefined);
+        if (detectedValueType === "numberValue" &&
+            detectedNumberFormatType &&
+            detectedNumberValue !== undefined) {
+            rawValue = detectedNumberValue;
+            cellFormat.numberFormat = {
+                type: detectedNumberFormatType,
+                ...(detectedPattern ? { pattern: detectedPattern } : {}),
+            };
+        }
+    }
+    if (enableCellXfsRegistry) {
+        const styleId = workbook.registerFormat(cellFormat);
+        ef = { sid: styleId };
+    }
+    // User entered value
+    let ue;
+    let ev;
+    const 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.
+        const code = typeof rawValue === "string" ? rawValue : String(rawValue);
+        const 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;
+    }
+    const hasFormat = enableCellXfsRegistry || Object.keys(cellFormat ?? {}).length > 0;
+    const hasValue = formulaValue !== null && formulaValue !== undefined && formulaValue !== "";
+    const hasRawValue = rawValue !== null && rawValue !== undefined;
+    if (!hasRawValue && !hasValue) {
+        return hasFormat ? { uf: ef } : null;
+    }
+    const pattern = cellFormat?.numberFormat?.pattern ?? "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).
+    const fv = formulaValue || rawValue === null || rawValue === undefined
+        ? undefined
+        : typeof rawValue === "string"
+            ? rawValue
+            : ssfFormat(pattern, rawValue);
+    return {
+        ...(hasFormat ? { uf: ef } : {}),
+        ...(fv !== undefined ? { fv } : {}),
+        ...(ue ? { ue } : {}),
+        ...(ev ? { ev } : {}),
+        ...(arrayFormulaRef ? { af: arrayFormulaRef } : {}),
+        ...(sharedFormulaSpec ? { sf: sharedFormulaSpec } : {}),
+        ...(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 = false) {
+    const syntheticCell = { a$: { s: String(styleIndex) } };
+    const cellFormat = extractCellFormat(syntheticCell, workbook.workbookStyles);
+    if (!cellFormat || Object.keys(cellFormat).length === 0) {
+        return null;
+    }
+    const protection = extractCellProtection(syntheticCell, workbook.workbookStyles);
+    const ef = enableCellXfsRegistry
+        ? { sid: workbook.registerFormat(cellFormat) }
+        : cellFormat;
+    return {
+        uf: ef,
+        ...(protection ? { protection } : {}),
+    };
+}
+export const getExtendedValue = (rawValue) => {
+    const 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) {
+    // Handle namespaced properties (x:v and x:f)
+    const cellValueNode = cell.v ?? cell["x:v"];
+    const cellValueText = getNodeText(cellValueNode);
+    const inlineStringValue = getInlineStringValue(cell);
+    const cellFormula = cell.f ?? cell["x:f"];
+    const cellType = cell.a$ && cell.a$.t ? cell.a$.t : "n"; // Default to number
+    const hasPrimitiveValue = cellValueText !== undefined && cellValueText !== "";
+    const 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 };
+    }
+    let rawValue = null;
+    let formulaValue = null;
+    let sharedStringIndex;
+    let isError = false;
+    let arrayFormulaRef;
+    let 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") {
+            const sharedIndex = cellFormula.a$.si;
+            const sharedFormula = cellFormula.t$;
+            const siNum = sharedIndex !== undefined && sharedIndex !== null
+                ? Number(sharedIndex)
+                : NaN;
+            if (Number.isFinite(siNum)) {
+                sharedFormulaSpec = {
+                    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") {
+            const cellRef = cell.a$?.r;
+            arrayFormulaRef =
+                cellFormula.a$.ref ?? (cellRef ? `${cellRef}:${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.
+            const sharedIndex = cellFormula.a$.si;
+            const sFormula = workbook.sharedFormulaMap?.get(sharedIndex);
+            if (sFormula) {
+                const [sharedFormula, sourceCell] = sFormula;
+                const sourceCellInterface = addressToCell(sourceCell);
+                const destinationCell = addressToCell(cell.a$.r);
+                if (sourceCellInterface && destinationCell) {
+                    try {
+                        const finalFormula = formulaToRelativeReference(sharedFormula, sourceCellInterface, destinationCell, activeSheetName ?? "", { preserveAbsolutes: true });
+                        formulaValue = finalFormula;
+                    }
+                    catch (err) { }
+                }
+            }
+        }
+    }
+    if (formulaValue) {
+        formulaValue = normalizeFormulaSheetNames(formulaValue);
+    }
+    switch (cellType) {
+        case "s": {
+            // Shared string
+            if (hasPrimitiveValue) {
+                const stringIndex = Number(cellValueText);
+                if (!Number.isNaN(stringIndex)) {
+                    sharedStringIndex = stringIndex;
+                    rawValue =
+                        workbook.sharedStrings?.[stringIndex] ?? cellValueText ?? "";
+                }
+                else {
+                    rawValue = 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) {
+                const styleIndex = parseInt(cell.a$.s);
+                // You'll need a function to get the numFmtId from the style
+                const xf = workbook.workbookStyles.getCellXfs(styleIndex);
+                const numFmtId = xf?.a$?.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
+                const isTimeFormat = [18, 19, 20, 21, 45, 46, 47].includes(numFmtId);
+                const 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 ?? "";
+            break;
+        case "inlineStr":
+            rawValue = inlineStringValue ?? "";
+            break;
+        default:
+            rawValue = cellValueText;
+            break;
+    }
+    return {
+        rawValue,
+        formulaValue,
+        sharedStringIndex,
+        isError,
+        arrayFormulaRef,
+        sharedFormulaSpec,
+    };
+}
+function normalizeFormulaSheetNames(formula) {
+    return formula.replace(/('([^']|'')+'|[^'!,]+)!/g, (match, sheetName) => {
+        if (!sheetName.startsWith("'")) {
+            return match;
+        }
+        const unescaped = sheetName.slice(1, -1).replace(/''/g, "'");
+        if (canUnquoteSheetName(unescaped)) {
+            return `${unescaped}!`;
+        }
+        return `'${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;
+    const cellAttrs = cellXf.a$ || {};
+    const parentAttrs = parentXf.a$ || {};
+    const resolvedAttrs = { ...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.
+    const inheritIfApplyZero = (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");
+    const effectiveXf = { ...cellXf, a$: resolvedAttrs };
+    if (cellAttrs.applyAlignment === "0") {
+        const 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) {
+    const node = getNode(xf, "protection", "x:protection");
+    if (!node)
+        return undefined;
+    const attrs = node.a$ || {};
+    const lockedRaw = attrs.locked;
+    const hiddenRaw = attrs.hidden;
+    const protection = {};
+    if (lockedRaw !== undefined && lockedRaw !== null) {
+        const locked = lockedRaw === "0" || lockedRaw === "false" || lockedRaw === false
+            ? false
+            : true;
+        if (locked === false)
+            protection.locked = false;
+    }
+    if (hiddenRaw !== undefined && hiddenRaw !== null) {
+        const 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?.a$ || !cell.a$.s)
+        return undefined;
+    const styleIndex = parseInt(cell.a$.s);
+    const cellXf = workbookStyles.getCellXfs(styleIndex);
+    if (!cellXf)
+        return undefined;
+    const xfIdStr = cellXf.a$ && cellXf.a$.xfId;
+    const xfId = xfIdStr !== undefined ? parseInt(xfIdStr) : 0;
+    const parentXf = xfId > 0 ? workbookStyles.getCellStyleXf(xfId) : null;
+    const xf = buildEffectiveXf(cellXf, parentXf);
+    return readProtectionFromXf(xf);
+}
+function extractCellFormat(cell, workbookStyles, mergeContext) {
+    // Default empty cell format
+    const cellFormat = {};
+    // If no style info, return default
+    if (!cell.a$ || !cell.a$.s) {
+        return cellFormat;
+    }
+    const styleIndex = parseInt(cell.a$.s);
+    const 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).
+    const xfIdStr = cellXf.a$ && cellXf.a$.xfId;
+    const xfId = xfIdStr !== undefined ? parseInt(xfIdStr) : 0;
+    const parentXf = xfId > 0 ? workbookStyles.getCellStyleXf(xfId) : null;
+    const xf = buildEffectiveXf(cellXf, parentXf);
+    // Extract number format
+    const numberFormat = extractNumberFormat(xf, workbookStyles);
+    if (!(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.
+    const xfAlignment = getNode(xf, "alignment", "x:alignment");
+    if (xfAlignment) {
+        const alignment = xfAlignment.a$ || {};
+        if (alignment.horizontal) {
+            cellFormat.horizontalAlignment = alignment.horizontal;
+        }
+        const verticalAlignment = mapVerticalAlignment(alignment.vertical);
+        if (verticalAlignment && verticalAlignment !== "bottom") {
+            cellFormat.verticalAlignment = verticalAlignment;
+        }
+        const wrapText = alignment.wrapText === "1" || alignment.wrapText === "true"
+            ? "wrap"
+            : "overflow";
+        if (wrapText !== "overflow") {
+            cellFormat.wrapStrategy = wrapText;
+        }
+        const indent = alignment.indent ? parseInt(alignment.indent) : null;
+        if (indent)
+            cellFormat.indent = indent;
+        const relativeIndent = alignment.relativeIndent
+            ? parseInt(alignment.relativeIndent)
+            : null;
+        if (relativeIndent)
+            cellFormat.relativeIndent = relativeIndent;
+        if (alignment.textRotation) {
+            const 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.
+    const 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
+    let borders = extractBorders(xf, workbookStyles);
+    borders = mergeBordersForAnchorCell(borders, cell, workbookStyles, mergeContext);
+    if (borders)
+        cellFormat.borders = borders;
+    return cellFormat;
+}
+function mergeBordersForAnchorCell(borders, cell, workbookStyles, mergeContext) {
+    if (!mergeContext)
+        return borders;
+    const cellRef = cell?.a$?.r;
+    if (!cellRef)
+        return borders;
+    const cellPosition = addressToCell(cellRef);
+    if (!cellPosition)
+        return borders;
+    const { range, rowCellsByColumnIndex } = mergeContext;
+    const isAnchorCell = cellPosition.rowIndex === range.startRowIndex &&
+        cellPosition.columnIndex === range.startColumnIndex;
+    if (!isAnchorCell)
+        return borders;
+    const mergedBorders = borders ? { ...borders } : {};
+    const leftCell = rowCellsByColumnIndex.get(range.startColumnIndex);
+    const rightCell = rowCellsByColumnIndex.get(range.endColumnIndex);
+    const leftBorders = leftCell
+        ? extractBordersFromCell(leftCell, workbookStyles)
+        : null;
+    const rightBorders = rightCell
+        ? extractBordersFromCell(rightCell, workbookStyles)
+        : null;
+    if (!mergedBorders.left && leftBorders?.left) {
+        mergedBorders.left = leftBorders.left;
+    }
+    if (!mergedBorders.right && rightBorders?.right) {
+        mergedBorders.right = rightBorders.right;
+    }
+    if (range.startRowIndex === range.endRowIndex) {
+        const rowEdgeCell = leftCell ?? rightCell;
+        const rowBorders = rowEdgeCell
+            ? extractBordersFromCell(rowEdgeCell, workbookStyles)
+            : null;
+        if (!mergedBorders.top && rowBorders?.top) {
+            mergedBorders.top = rowBorders.top;
+        }
+        if (!mergedBorders.bottom && rowBorders?.bottom) {
+            mergedBorders.bottom = rowBorders.bottom;
+        }
+    }
+    return Object.keys(mergedBorders).length > 0 ? mergedBorders : null;
+}
+function extractBordersFromCell(cell, workbookStyles) {
+    if (!cell?.a$?.s)
+        return null;
+    const styleIndex = parseInt(cell.a$.s);
+    const 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;
+    }
+    const fontId = parseInt(xf.a$.fontId);
+    const 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) {
+    if (!font) {
+        return null;
+    }
+    // Create text format object
+    const 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`).
+    const fontName = getNode(font, "name", "x:name");
+    if (fontName?.a$?.val) {
+        textFormat.fontFamily = fontName.a$.val;
+    }
+    else {
+        const schemeVal = getNode(font, "scheme", "x:scheme")?.a$?.val;
+        const themeFonts = workbookStyles.themeFonts;
+        const resolved = schemeVal === "major"
+            ? themeFonts?.major
+            : schemeVal === "minor"
+                ? themeFonts?.minor
+                : undefined;
+        if (resolved) {
+            textFormat.fontFamily = resolved;
+        }
+    }
+    const fontSize = getNode(font, "sz", "x:sz");
+    if (fontSize?.a$?.val) {
+        textFormat.fontSize = parseInt(fontSize.a$.val);
+    }
+    const 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.
+    const isTruthyFlagNode = (node) => {
+        if (node === undefined || node === null)
+            return false;
+        const val = typeof node === "object"
+            ? (node.a$?.val ?? node["#text"] ?? node)
+            : node;
+        if (val === undefined || val === null || val === true)
+            return true;
+        const 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.
+    const uNode = getNode(font, "u", "x:u");
+    if (uNode !== undefined) {
+        const uVal = typeof uNode === "object"
+            ? (uNode.a$?.val ?? uNode["#text"])
+            : uNode;
+        const uStr = uVal === undefined || uVal === null ? "" : String(uVal).toLowerCase();
+        if (uStr !== "none") {
+            textFormat.underline = true;
+        }
+    }
+    const vertAlignNode = getNode(font, "vertAlign", "x:vertAlign");
+    if (vertAlignNode?.a$?.val) {
+        const 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) {
+        const index = parseInt(colorObj.a$.indexed);
+        // Last color
+        if (index === 64) {
+            return {
+                theme: 1,
+            };
+        }
+        if (indexedColors && indexedColors.length > 0) {
+            const 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.
+        const 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) {
+    if (!xf.a$ || !xf.a$.numFmtId)
+        return null;
+    const numFmtId = parseInt(xf.a$.numFmtId);
+    let formatCode = standardExcelFormatCodeById.get(numFmtId) ?? null;
+    // Check for custom number formats
+    if (workbookStyles.numFmts?.length) {
+        const numFmts = workbookStyles.numFmts;
+        const customFormat = numFmts.find((fmt) => 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
+    const type = mapNumberFormatType(numFmtId, formatCode) ?? "GENERAL";
+    return {
+        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)
+        const mainSection = formatCode.split(";")[0];
+        const { cleanedSection, hasBracketedTimeToken } = stripQuotedAndBracketLiterals(mainSection);
+        // Check for date components - d, m, y that aren't escaped
+        let hasDateComponent = false;
+        let i = 0;
+        while (i < cleanedSection.length) {
+            if (cleanedSection[i] === "\\") {
+                // Skip escaped character
+                i += 2;
+            }
+            else {
+                const 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, :
+            let hasTimeComponent = false;
+            i = 0;
+            while (i < cleanedSection.length) {
+                if (cleanedSection[i] === "\\") {
+                    // Skip escaped character
+                    i += 2;
+                }
+                else {
+                    const 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).
+        const localeSpecifierPattern = /\[\$-[0-9A-Fa-f]+\]/g;
+        const 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
+        let hasTimePattern = false;
+        i = 0;
+        while (i < cleanedSection.length) {
+            if (cleanedSection[i] === "\\") {
+                // Skip escaped character
+                i += 2;
+            }
+            else {
+                const 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";
+        }
+        const hasNumberPlaceholder = cleanedSection.match(/[0#?]/);
+        if (!hasNumberPlaceholder) {
+            const 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) {
+    let result = "";
+    let inQuotes = false;
+    let i = 0;
+    let hasBracketedTimeToken = false;
+    while (i < section.length) {
+        const 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 === "[") {
+            const end = section.indexOf("]", i + 1);
+            const 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 };
+}
+// 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).
+const 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) {
+    if (!xf.a$ || !xf.a$.fillId)
+        return null;
+    const fillId = parseInt(xf.a$.fillId);
+    if (fillId === 0)
+        return null;
+    const fill = workbookStyles.getFill(fillId);
+    if (!fill)
+        return null;
+    // <gradientFill> branch — extract type + stops + axis attrs.
+    const gradientFill = getNode(fill, "gradientFill", "x:gradientFill");
+    if (gradientFill) {
+        const gradient = extractGradientFill(gradientFill, workbookStyles);
+        if (gradient)
+            return { gradient };
+    }
+    const patternFill = getNode(fill, "patternFill", "x:patternFill");
+    if (!patternFill)
+        return null;
+    const patternAttrs = patternFill.a$ ?? {};
+    const patternType = patternAttrs.patternType;
+    if (patternType === "none" || patternType === undefined)
+        return null;
+    const fgColorNode = getNode(patternFill, "fgColor", "x:fgColor");
+    const bgColorNode = getNode(patternFill, "bgColor", "x:bgColor");
+    const fgColor = fgColorNode
+        ? extractColor(fgColorNode, workbookStyles.indexedColors)
+        : undefined;
+    const 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 {
+            fillPattern: "solid",
+            ...(fgColor !== undefined ? { backgroundColor: fgColor } : {}),
+        };
+    }
+    // True patterned fill — preserve all three fields.
+    return {
+        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) {
+    const attrs = gradientFill.a$ ?? {};
+    const 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.
+    let rawStops = getNode(gradientFill, "stop", "x:stop") ??
+        getNode(gradientFill, "stops", "x:stops");
+    if (rawStops == null)
+        return null;
+    if (!Array.isArray(rawStops))
+        rawStops = [rawStops];
+    const stops = [];
+    for (const s of rawStops) {
+        if (!s)
+            continue;
+        const sAttrs = s.a$ ?? {};
+        const positionRaw = sAttrs.position;
+        const position = typeof positionRaw === "number"
+            ? positionRaw
+            : positionRaw != null
+                ? parseFloat(positionRaw)
+                : NaN;
+        if (!Number.isFinite(position))
+            continue;
+        const colorNode = getNode(s, "color", "x:color");
+        if (!colorNode)
+            continue;
+        const color = extractColor(colorNode, workbookStyles.indexedColors);
+        if (color == null)
+            continue;
+        stops.push({ position, color: String(color) });
+    }
+    if (stops.length === 0)
+        return null;
+    stops.sort((a, b) => a.position - b.position);
+    const numAttr = (k) => {
+        const v = attrs[k];
+        if (v == null)
+            return undefined;
+        const n = typeof v === "number" ? v : parseFloat(v);
+        return Number.isFinite(n) ? n : undefined;
+    };
+    return {
+        type,
+        ...(type === "linear"
+            ? { degree: numAttr("degree") ?? 0 }
+            : {
+                left: numAttr("left") ?? 0,
+                right: numAttr("right") ?? 0,
+                top: numAttr("top") ?? 0,
+                bottom: numAttr("bottom") ?? 0,
+            }),
+        stops,
+    };
+}
+/**
+ * Extract borders information
+ */
+function extractBorders(xf, workbookStyles) {
+    if (!xf.a$ || !xf.a$.borderId)
+        return null;
+    const borderId = parseInt(xf.a$.borderId);
+    // Default no borders
+    if (borderId === 0)
+        return null;
+    const borders = workbookStyles.borders;
+    const border = borders[borderId];
+    if (!border)
+        return null;
+    const 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((side) => {
+        const sideNode = getNode(border, side, `x:${side}`);
+        const style = sideNode?.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.
+    const diagonalNode = getNode(border, "diagonal", "x:diagonal");
+    const diagonalStyle = diagonalNode?.a$?.style;
+    if (diagonalStyle && diagonalStyle !== "none") {
+        const diagonalBorder = {
+            style: mapBorderStyle(diagonalStyle),
+            width: mapBorderWidth(diagonalStyle),
+            color: getNode(diagonalNode, "color", "x:color")
+                ? extractColor(getNode(diagonalNode, "color", "x:color"), workbookStyles.indexedColors)
+                : null,
+        };
+        const diagonalUpFlag = border?.a$?.diagonalUp;
+        const diagonalDownFlag = border?.a$?.diagonalDown;
+        const isTruthy = (v) => 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) {
+    const 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) {
+        const 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?.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;
+}