@rowsncolumns/toolkit 24.4.1

package/dist/esm/exporter/xlsx/style-builder.js

@@ -0,0 +1,795 @@
+import { getCellEffectiveFormat, getCellUserEnteredFormat, } from "@rowsncolumns/utils";
+import { BUILTIN_NUMFMT_BY_PATTERN } from "../../excel-parser/builtin-numfmts";
+const isStyleReference = (value) => !!value && typeof value === "object" && "sid" in value;
+// Built-in number-format dictionary is shared with the importer — see
+// `excel-parser/builtin-numfmts.ts`. Pattern strings are the canonical
+// Excel-writer form (quoted "$" for currency/accounting, `mmss.0` for
+// numFmtId 47 per ECMA-376). Re-aliased for backwards compat with the
+// previous local name in this file.
+const BUILT_IN_NUMFMT_BY_PATTERN = BUILTIN_NUMFMT_BY_PATTERN;
+export class StyleBuilder {
+    numberFormats = [];
+    fonts = [
+        {
+            name: "Calibri",
+            size: 11,
+        },
+    ];
+    fills = [{ pattern: "none" }, { pattern: "gray125" }];
+    borders = [{}];
+    namedCellStyles = [
+        { name: "Normal", xfId: 0, builtinId: 0 },
+    ];
+    customTableStyles = [];
+    /**
+     * Replace the named-cell-styles list emitted in `<cellStyles>`.
+     * Used for round-tripping the OOXML Heading 1 / Accent / Total /
+     * Good-Bad-Neutral gallery — the importer parses these from
+     * `xl/styles.xml` and exposes them on `workbook.workbookStyles.
+     * namedCellStyles`; hosts can forward that list back here.
+     *
+     * Excel requires at least a "Normal" entry pointing at xfId=0,
+     * builtinId=0 — when the supplied list doesn't contain one, we
+     * keep the default at the head of the list rather than risk
+     * emitting a file Excel rejects.
+     */
+    setNamedCellStyles(entries) {
+        if (!entries || entries.length === 0)
+            return;
+        const hasNormal = entries.some((e) => e.builtinId === 0 || e.name === "Normal");
+        this.namedCellStyles = hasNormal
+            ? entries.slice()
+            : [{ name: "Normal", xfId: 0, builtinId: 0 }, ...entries];
+    }
+    /**
+     * Replace the user-authored table-style list emitted in the
+     * `<tableStyles>` block. The exporter registers each element's
+     * format as a dxf at `toXml()` time, so callers pass self-contained
+     * records (no dxfIds to manage). Used for round-tripping the
+     * OOXML custom-table-style list from
+     * `workbook.workbookStyles.getCustomTableStyleExports()`.
+     */
+    setCustomTableStyles(entries) {
+        if (!entries || entries.length === 0) {
+            this.customTableStyles = [];
+            return;
+        }
+        this.customTableStyles = entries.slice();
+    }
+    cellXfs = [
+        {
+            numFmtId: 0,
+            fontId: 0,
+            fillId: 0,
+            borderId: 0,
+        },
+    ];
+    fontMap = new Map();
+    fillMap = new Map();
+    borderMap = new Map();
+    formatMap = new Map();
+    xfMap = new Map();
+    dxfs = [];
+    dxfMap = new Map();
+    constructor() {
+        this.fontMap.set(this.serializeFont(this.fonts[0]), 0);
+        this.fillMap.set(this.serializeFill(this.fills[0]), 0);
+        this.fillMap.set(this.serializeFill(this.fills[1]), 1);
+        this.borderMap.set(this.serializeBorder(this.borders[0]), 0);
+        this.xfMap.set(serializeXf(this.cellXfs[0]), 0);
+    }
+    /**
+     * Replace the workbook default font (font id 0 — what every cell without
+     * an explicit font inherits). Callers pass the source workbook's parsed
+     * default (`WorkBook.getDefaultFont()`) so an imported workbook keeps its
+     * default typeface/size instead of the hardcoded Calibri 11. Must be
+     * called before any cell registration: cells explicitly styled with the
+     * old default must not collapse into font id 0.
+     */
+    setDefaultFont(format) {
+        if (this.fonts.length > 1)
+            return;
+        const record = this.buildFontRecord(format);
+        if (!record)
+            return;
+        this.fonts[0] = record;
+        this.fontMap.clear();
+        this.fontMap.set(this.serializeFont(record), 0);
+    }
+    registerCell(cell, cellXfs, 
+    /**
+     * Number format to use when the cell itself has none. Used by the
+     * exporter to layer in the precedent-derived number format on formula
+     * cells so Excel displays them correctly without requiring a recalc.
+     */
+    derivedNumberFormat) {
+        if (!cell)
+            return 0;
+        // Match Excel's model: persist only the user-entered format. Auto-
+        // derived alignment / pattern color / formula precedent format are
+        // recomputed at render time and never serialized to disk. Legacy `ef`
+        // is still read as a fallback so old files continue to export with the
+        // formatting they originally had.
+        const userEnteredFormat = normalizeFormat(getCellUserEnteredFormat(cell), cellXfs);
+        let effectiveFormat = userEnteredFormat ??
+            normalizeFormat(getCellEffectiveFormat(cell), cellXfs) ??
+            undefined;
+        // Layer in the derived number format only when the cell's own format
+        // has nothing in that slot. User-set formats always win.
+        if (derivedNumberFormat && !effectiveFormat?.numberFormat) {
+            effectiveFormat = {
+                ...(effectiveFormat ?? {}),
+                numberFormat: derivedNumberFormat,
+            };
+        }
+        const numberFormatId = this.getNumberFormatId(effectiveFormat);
+        const fontId = this.getFontId(effectiveFormat?.textFormat);
+        const fillId = this.getFillId(effectiveFormat);
+        const borderId = this.getBorderId(effectiveFormat?.borders);
+        const xfRecord = {
+            numFmtId: numberFormatId,
+            fontId,
+            fillId,
+            borderId,
+            wrapText: effectiveFormat?.wrapStrategy === "wrap",
+            horizontalAlignment: normalizeHorizontalAlignment(effectiveFormat?.horizontalAlignment),
+            verticalAlignment: normalizeVerticalAlignment(effectiveFormat?.verticalAlignment),
+            indent: effectiveFormat?.indent ?? undefined,
+            relativeIndent: effectiveFormat?.relativeIndent ?? undefined,
+            textRotation: effectiveFormat?.textRotation ?? undefined,
+            shrinkToFit: effectiveFormat?.shrinkToFit ?? undefined,
+            // Protection lives top-level on the cell (not on the format) — read
+            // it off the cell directly. The xf still carries the flags because
+            // that's where Excel persists them; we synthesize a unique xf per
+            // protection variant via the cache key below.
+            protectionLocked: cell?.protection?.locked === false ? false : undefined,
+            protectionHidden: cell?.protection?.hidden === true ? true : undefined,
+        };
+        const key = serializeXf(xfRecord);
+        const existing = this.xfMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        const nextId = this.cellXfs.length;
+        this.cellXfs.push(xfRecord);
+        this.xfMap.set(key, nextId);
+        return nextId;
+    }
+    registerDifferentialFormat(format) {
+        if (!format)
+            return undefined;
+        const record = {};
+        if (format.backgroundColor) {
+            record.fill = {
+                color: format.backgroundColor,
+            };
+        }
+        const font = this.buildFontRecord(format.textFormat);
+        if (font) {
+            record.font = font;
+        }
+        if (!record.fill && !record.font) {
+            return undefined;
+        }
+        const key = this.serializeDxf(record);
+        const existing = this.dxfMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        const nextId = this.dxfs.length;
+        this.dxfs.push(record);
+        this.dxfMap.set(key, nextId);
+        return nextId;
+    }
+    getNumberFormatId(effectiveFormat) {
+        const pattern = effectiveFormat?.numberFormat?.pattern;
+        if (!pattern)
+            return 0;
+        // Preserve trailing whitespace in the pattern verbatim — number-format
+        // strings legitimately end with significant `\xa0` (non-breaking space)
+        // chars for column-aligned currency/accounting formats. Trimming here
+        // mangled those formats on round-trip and broke comparator equality
+        // against the source `<numFmts>` table. We still dedupe via the map
+        // using the raw pattern as key.
+        const normalizedPattern = pattern;
+        // Try Excel's built-in numFmtId table (0–49). When our pattern matches
+        // a built-in exactly, emit that ID — Excel and other readers render
+        // identically and we avoid bloating <numFmts> with a redundant
+        // custom entry.
+        const builtInId = BUILT_IN_NUMFMT_BY_PATTERN.get(normalizedPattern);
+        if (typeof builtInId === "number") {
+            return builtInId;
+        }
+        const existing = this.formatMap.get(normalizedPattern);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        // ECMA-376 §18.8.30: built-in numFmtIds occupy 0–163. Custom IDs
+        // start at 164 by convention (Excel's own writer does the same).
+        const nextId = 164 + this.numberFormats.length;
+        this.numberFormats.push({
+            id: nextId,
+            format: normalizedPattern,
+        });
+        this.formatMap.set(normalizedPattern, nextId);
+        return nextId;
+    }
+    getFontId(format) {
+        const record = this.buildFontRecord(format);
+        if (!record)
+            return 0;
+        const key = this.serializeFont(record);
+        const existing = this.fontMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        const nextId = this.fonts.length;
+        this.fonts.push(record);
+        this.fontMap.set(key, nextId);
+        return nextId;
+    }
+    getFillId(format) {
+        const fillPattern = format?.fillPattern ?? undefined;
+        const fgColor = format?.foregroundColor ?? undefined;
+        const bgColor = format?.backgroundColor ?? undefined;
+        const gradient = format?.gradient ?? undefined;
+        // Gradient fill takes precedence over pattern — Excel's UI treats
+        // them as mutually exclusive on a single cell.
+        if (gradient && gradient.stops?.length) {
+            const record = { gradient };
+            const key = this.serializeFill(record);
+            const existing = this.fillMap.get(key);
+            if (typeof existing === "number")
+                return existing;
+            const nextId = this.fills.length;
+            this.fills.push(record);
+            this.fillMap.set(key, nextId);
+            return nextId;
+        }
+        // Patterned (non-solid) fill: `color` carries the foreground (pattern)
+        // color and `bgColor` carries the under-layer that shows through the
+        // pattern gaps. Solid fill keeps the legacy single-color path.
+        if (fillPattern &&
+            fillPattern !== "none" &&
+            fillPattern !== "solid") {
+            const record = {
+                color: fgColor ?? bgColor,
+                bgColor: fgColor ? bgColor : undefined,
+                pattern: fillPattern,
+            };
+            const key = this.serializeFill(record);
+            const existing = this.fillMap.get(key);
+            if (typeof existing === "number")
+                return existing;
+            const nextId = this.fills.length;
+            this.fills.push(record);
+            this.fillMap.set(key, nextId);
+            return nextId;
+        }
+        // Solid fill: prefer explicit foregroundColor, fall back to
+        // backgroundColor for the common authored-as-bg case.
+        const color = fgColor ?? bgColor;
+        const record = {
+            color,
+            pattern: color ? "solid" : "none",
+        };
+        const key = this.serializeFill(record);
+        const existing = this.fillMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        const nextId = this.fills.length;
+        this.fills.push(record);
+        this.fillMap.set(key, nextId);
+        return nextId;
+    }
+    getBorderId(borders) {
+        // OOXML uses a single <diagonal> child plus diagonalUp/diagonalDown
+        // attributes. If both diagonals are present and identically styled the
+        // first non-null one defines the edge; otherwise each flag is set
+        // independently and both share the same painted style. This matches
+        // how Excel collapses diagonal pairs.
+        const diagonalEdge = convertBorderEdge(borders?.diagonalUp ?? borders?.diagonalDown);
+        const record = {
+            top: convertBorderEdge(borders?.top),
+            bottom: convertBorderEdge(borders?.bottom),
+            left: convertBorderEdge(borders?.left),
+            right: convertBorderEdge(borders?.right),
+            diagonal: diagonalEdge,
+            diagonalUp: !!borders?.diagonalUp,
+            diagonalDown: !!borders?.diagonalDown,
+        };
+        const key = this.serializeBorder(record);
+        const existing = this.borderMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        const nextId = this.borders.length;
+        this.borders.push(record);
+        this.borderMap.set(key, nextId);
+        return nextId;
+    }
+    serializeFont(font) {
+        return [
+            font.name ?? "",
+            font.size ?? "",
+            font.bold ? "1" : "",
+            font.italic ? "1" : "",
+            font.underline ? "1" : "",
+            font.strike ? "1" : "",
+            serializeColor(font.color),
+            font.vertAlign ?? "",
+        ].join("|");
+    }
+    buildFontRecord(format) {
+        if (!format?.bold &&
+            !format?.italic &&
+            !format?.underline &&
+            !format?.strikethrough &&
+            !format?.fontSize &&
+            !format?.fontFamily &&
+            !format?.color &&
+            !format?.baselineOffset) {
+            return undefined;
+        }
+        const vertAlign = format?.baselineOffset === "superscript" ||
+            format?.baselineOffset === "subscript"
+            ? format.baselineOffset
+            : undefined;
+        return {
+            bold: format?.bold ?? undefined,
+            italic: format?.italic ?? undefined,
+            underline: format?.underline ?? undefined,
+            strike: format?.strikethrough ?? undefined,
+            size: format?.fontSize ?? undefined,
+            name: format?.fontFamily ?? undefined,
+            color: format?.color ?? undefined,
+            vertAlign,
+        };
+    }
+    buildFontXml(font) {
+        const color = serializeColorXml(font.color);
+        const name = sanitizeFontName(font.name);
+        return `<font>${font.size ? `<sz val="${font.size}"/>` : ""}${name ? `<name val="${escapeXml(name)}"/>` : ""}${font.bold ? "<b/>" : ""}${font.italic ? "<i/>" : ""}${font.underline ? "<u/>" : ""}${font.strike ? "<strike/>" : ""}${font.vertAlign ? `<vertAlign val="${font.vertAlign}"/>` : ""}${color ? `<color ${color}/>` : ""}</font>`;
+    }
+    buildFillXml(fill, forDxf = false) {
+        // Gradient fill — emits `<gradientFill>` with `<stop>` children.
+        // Excel accepts gradients in cell fills (not dxf), so when this is
+        // requested for a dxf record we degrade to a solid using the first
+        // stop's color so the conditional format still has SOMETHING to paint.
+        if (fill.gradient && fill.gradient.stops?.length) {
+            if (forDxf) {
+                const first = fill.gradient.stops[0].color;
+                const fallback = serializeColorXml(first);
+                if (fallback) {
+                    return `<fill><patternFill patternType="solid"><fgColor ${fallback}/><bgColor ${fallback}/></patternFill></fill>`;
+                }
+                return `<fill><patternFill patternType="none"/></fill>`;
+            }
+            return this.buildGradientFillXml(fill.gradient);
+        }
+        const pattern = fill.pattern ?? (fill.color ? "solid" : "none");
+        if (pattern === "gray125" && !fill.color) {
+            return `<fill><patternFill patternType="gray125"/></fill>`;
+        }
+        const color = serializeColorXml(fill.color);
+        if (pattern === "none" || !color) {
+            return `<fill><patternFill patternType="none"/></fill>`;
+        }
+        if (pattern === "solid") {
+            if (forDxf) {
+                return `<fill><patternFill patternType="solid"><fgColor ${color}/><bgColor ${color}/></patternFill></fill>`;
+            }
+            return `<fill><patternFill patternType="solid"><fgColor ${color}/><bgColor indexed="64"/></patternFill></fill>`;
+        }
+        // True patterned fill — emit both fg and bg if available.
+        const bgColor = serializeColorXml(fill.bgColor);
+        const bgAttr = bgColor ? `<bgColor ${bgColor}/>` : `<bgColor indexed="64"/>`;
+        return `<fill><patternFill patternType="${pattern}"><fgColor ${color}/>${bgAttr}</patternFill></fill>`;
+    }
+    buildGradientFillXml(gradient) {
+        const stopsXml = gradient.stops
+            .map((s) => {
+            const color = serializeColorXml(s.color);
+            return `<stop position="${s.position}">${color ? `<color ${color}/>` : ""}</stop>`;
+        })
+            .join("");
+        const attrs = [];
+        if (gradient.type === "path") {
+            attrs.push('type="path"');
+            if (gradient.left != null)
+                attrs.push(`left="${gradient.left}"`);
+            if (gradient.right != null)
+                attrs.push(`right="${gradient.right}"`);
+            if (gradient.top != null)
+                attrs.push(`top="${gradient.top}"`);
+            if (gradient.bottom != null)
+                attrs.push(`bottom="${gradient.bottom}"`);
+        }
+        else if (gradient.degree != null && gradient.degree !== 0) {
+            attrs.push(`degree="${gradient.degree}"`);
+        }
+        const attrStr = attrs.length ? " " + attrs.join(" ") : "";
+        return `<fill><gradientFill${attrStr}>${stopsXml}</gradientFill></fill>`;
+    }
+    serializeFill(fill) {
+        const gradientKey = fill.gradient
+            ? `G:${fill.gradient.type}:${fill.gradient.degree ?? ""}:${fill.gradient.left ?? ""}:${fill.gradient.right ?? ""}:${fill.gradient.top ?? ""}:${fill.gradient.bottom ?? ""}:${fill.gradient.stops
+                .map((s) => `${s.position},${s.color}`)
+                .join("|")}`
+            : "";
+        return `${fill.pattern ?? ""}:${serializeColor(fill.color)}:${serializeColor(fill.bgColor)}:${gradientKey}`;
+    }
+    serializeBorder(border) {
+        return [
+            serializeBorderEdge(border.top),
+            serializeBorderEdge(border.bottom),
+            serializeBorderEdge(border.left),
+            serializeBorderEdge(border.right),
+            serializeBorderEdge(border.diagonal),
+            border.diagonalUp ? "1" : "",
+            border.diagonalDown ? "1" : "",
+        ].join("|");
+    }
+    serializeDxf(dxf) {
+        return `${dxf.fill ? this.serializeFill(dxf.fill) : ""}|${dxf.font ? this.serializeFont(dxf.font) : ""}`;
+    }
+    toXml() {
+        const numFmtXml = this.numberFormats.length
+            ? `<numFmts count="${this.numberFormats.length}">${this.numberFormats
+                .map((fmt) => `<numFmt numFmtId="${fmt.id}" formatCode="${escapeXml(fmt.format)}"/>`)
+                .join("")}</numFmts>`
+            : `<numFmts count="0"/>`;
+        const fontXml = `<fonts count="${this.fonts.length}">${this.fonts
+            .map((font) => this.buildFontXml(font))
+            .join("")}</fonts>`;
+        const fillXml = `<fills count="${this.fills.length}">${this.fills
+            .map((fill) => this.buildFillXml(fill, false))
+            .join("")}</fills>`;
+        const borderXml = `<borders count="${this.borders.length}">${this.borders
+            .map((border) => {
+            const top = serializeBorderEdgeXml(border.top, "top");
+            const bottom = serializeBorderEdgeXml(border.bottom, "bottom");
+            const left = serializeBorderEdgeXml(border.left, "left");
+            const right = serializeBorderEdgeXml(border.right, "right");
+            const diagonal = border.diagonal
+                ? serializeBorderEdgeXml(border.diagonal, "diagonal")
+                : "<diagonal/>";
+            const diagonalAttrs = `${border.diagonalUp ? ` diagonalUp="1"` : ""}${border.diagonalDown ? ` diagonalDown="1"` : ""}`;
+            return `<border${diagonalAttrs}>${left}${right}${top}${bottom}${diagonal}</border>`;
+        })
+            .join("")}</borders>`;
+        const cellXfsXml = `<cellXfs count="${this.cellXfs.length}">${this.cellXfs
+            .map((record) => {
+            const alignment = serializeAlignment(record);
+            const protection = serializeProtection(record);
+            // ECMA-376 §18.8.45: `applyX="1"` signals that this xf overrides
+            // the named-style parent (xfId=0) for that aspect. Excel tolerates
+            // missing applyX, but stricter readers (older LibreOffice, some
+            // headless engines) honor only the parent's value when applyX is
+            // absent. Emit each flag when the corresponding id deviates from
+            // the parent's defaults (0 across the board) or when alignment is
+            // present.
+            const applyNumberFormat = record.numFmtId !== 0 ? ` applyNumberFormat="1"` : "";
+            const applyFont = record.fontId !== 0 ? ` applyFont="1"` : "";
+            const applyFill = record.fillId !== 0 ? ` applyFill="1"` : "";
+            const applyBorder = record.borderId !== 0 ? ` applyBorder="1"` : "";
+            const applyAlignment = alignment ? ` applyAlignment="1"` : "";
+            const applyProtection = protection ? ` applyProtection="1"` : "";
+            return `<xf numFmtId="${record.numFmtId}" fontId="${record.fontId}" fillId="${record.fillId}" borderId="${record.borderId}" xfId="0"${applyNumberFormat}${applyFont}${applyFill}${applyBorder}${applyAlignment}${applyProtection}>${alignment}${protection}</xf>`;
+        })
+            .join("")}</cellXfs>`;
+        const resolvedTableStyles = this.customTableStyles.map((style) => {
+            const resolvedElements = [];
+            for (const el of style.elements) {
+                const dxfId = this.registerDifferentialFormat({
+                    ...(el.backgroundColor
+                        ? { backgroundColor: el.backgroundColor }
+                        : {}),
+                    ...(el.textColor || el.bold || el.italic
+                        ? {
+                            textFormat: {
+                                ...(el.textColor ? { color: el.textColor } : {}),
+                                ...(el.bold ? { bold: true } : {}),
+                                ...(el.italic ? { italic: true } : {}),
+                            },
+                        }
+                        : {}),
+                });
+                // Drop elements that didn't contribute any recognized format —
+                // an undefined dxfId means `registerDifferentialFormat` saw
+                // an empty record. (dxfId === 0 is the valid first-slot
+                // entry, so we explicitly exclude only `undefined`.)
+                if (dxfId === undefined)
+                    continue;
+                resolvedElements.push({
+                    type: el.type,
+                    dxfId,
+                    ...(el.size != null ? { size: el.size } : {}),
+                });
+            }
+            return {
+                name: style.name,
+                pivot: style.pivot,
+                elements: resolvedElements,
+            };
+        });
+        const dxfsXml = this.dxfs.length
+            ? `<dxfs count="${this.dxfs.length}">${this.dxfs
+                .map((dxf) => {
+                const font = dxf.font ? this.buildFontXml(dxf.font) : "";
+                const fill = dxf.fill ? this.buildFillXml(dxf.fill, true) : "";
+                return `<dxf>${font}${fill}</dxf>`;
+            })
+                .join("")}</dxfs>`
+            : `<dxfs count="0"/>`;
+        const cellStylesXml = `<cellStyles count="${this.namedCellStyles.length}">${this.namedCellStyles
+            .map((s) => {
+            const parts = [`name="${escapeXml(s.name)}"`];
+            parts.push(`xfId="${s.xfId}"`);
+            if (s.builtinId != null)
+                parts.push(`builtinId="${s.builtinId}"`);
+            if (s.iLevel != null)
+                parts.push(`iLevel="${s.iLevel}"`);
+            if (s.hidden)
+                parts.push(`hidden="1"`);
+            if (s.customBuiltin)
+                parts.push(`customBuiltin="1"`);
+            return `<cellStyle ${parts.join(" ")}/>`;
+        })
+            .join("")}</cellStyles>`;
+        // Emit user-authored table styles. Excel REQUIRES the
+        // `defaultTableStyle` + `defaultPivotStyle` attributes to be the
+        // names of built-in styles (or styles defined here) — we keep
+        // the built-in defaults regardless of whether any custom styles
+        // are present.
+        const customTableStylesXml = resolvedTableStyles
+            .filter((s) => s.elements.length > 0)
+            .map((s) => {
+            const pivotAttr = s.pivot ? ` pivot="1"` : ` pivot="0"`;
+            const elementsXml = s.elements
+                .map((el) => {
+                const sizeAttr = el.size != null ? ` size="${el.size}"` : "";
+                return `<tableStyleElement type="${escapeXml(el.type)}" dxfId="${el.dxfId}"${sizeAttr}/>`;
+            })
+                .join("");
+            return `<tableStyle name="${escapeXml(s.name)}"${pivotAttr} count="${s.elements.length}">${elementsXml}</tableStyle>`;
+        })
+            .join("");
+        const tableStylesXml = `<tableStyles count="${resolvedTableStyles.filter((s) => s.elements.length > 0).length}" defaultTableStyle="TableStyleMedium2" defaultPivotStyle="PivotStyleLight16">${customTableStylesXml}</tableStyles>`;
+        const styleXml = `${XML_DECLARATION}<styleSheet xmlns="${WORKSHEET_NS}">${numFmtXml}${fontXml}${fillXml}${borderXml}<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>${cellXfsXml}${cellStylesXml}${dxfsXml}${tableStylesXml}</styleSheet>`;
+        return styleXml;
+    }
+}
+const convertBorderEdge = (border) => {
+    if (!border || !border.style)
+        return undefined;
+    return {
+        style: mapBorderStyle(border.style),
+        color: border.color ?? undefined,
+    };
+};
+const mapBorderStyle = (style) => {
+    switch (style) {
+        case "dashed":
+            return "dashed";
+        case "dotted":
+            return "dotted";
+        case "double":
+            return "double";
+        case "solid_medium":
+            return "medium";
+        case "solid_thick":
+            return "thick";
+        case "hair":
+            return "hair";
+        case "mediumDashed":
+            return "mediumDashed";
+        case "mediumDashDot":
+            return "mediumDashDot";
+        case "dashDot":
+            return "dashDot";
+        case "dashDotDot":
+            return "dashDotDot";
+        case "slantDashDot":
+            return "slantDashDot";
+        case "thin":
+            // openpyxl/Excel's "thin" is the regular 1px border. The previous
+            // mapping returned Excel's "hair" (the lightest sub-1px border),
+            // which produced near-invisible borders for any caller — including
+            // athena-openpyxl — that explicitly asks for `Side(style="thin")`.
+            return "thin";
+        case "solid":
+        default:
+            // rowsncolumns' generic "solid" remains aliased to Excel's "thin"
+            // (the regular 1px border) when no explicit thickness is requested.
+            return "thin";
+    }
+};
+const serializeBorderEdge = (edge) => {
+    if (!edge)
+        return "";
+    return `${edge.style || ""}:${serializeColor(edge.color)}`;
+};
+const serializeBorderEdgeXml = (edge, side) => {
+    if (!edge?.style) {
+        return `<${side}/>`;
+    }
+    const color = serializeColorXml(edge.color);
+    return `<${side} style="${edge.style}">${color ? `<color ${color}/>` : ""}</${side}>`;
+};
+const serializeColor = (color) => {
+    if (!color)
+        return "";
+    if (typeof color === "string") {
+        return normalizeHex(color) ?? "";
+    }
+    return `theme${color.theme}:${color.tint ?? ""}`;
+};
+const serializeColorXml = (color) => {
+    if (!color)
+        return undefined;
+    if (typeof color === "string") {
+        const hex = normalizeHex(color);
+        return hex ? `rgb="${hex}"` : undefined;
+    }
+    const tintAttr = typeof color.tint === "number" ? ` tint="${color.tint}"` : "";
+    return `theme="${color.theme}"${tintAttr}`;
+};
+// Excel <name val=""/> expects a single font family ≤31 chars. CSS font stacks
+// (`InterVariable, system-ui, sans-serif`) make Excel reject the entire styles
+// part. Take the first family and strip surrounding quotes.
+const sanitizeFontName = (name) => {
+    if (!name || typeof name !== "string")
+        return undefined;
+    const first = name.split(",")[0].trim().replace(/^['"]|['"]$/g, "");
+    if (!first)
+        return undefined;
+    return first.length > 31 ? first.slice(0, 31) : first;
+};
+const HEX6_RE = /^[0-9A-Fa-f]{6}$/;
+const HEX8_RE = /^[0-9A-Fa-f]{8}$/;
+const RGB_FUNC_RE = /^rgba?\s*\(\s*(\d+)\s*[, ]\s*(\d+)\s*[, ]\s*(\d+)(?:\s*[, /]\s*([\d.]+))?\s*\)$/i;
+// Returns AARRGGBB hex for any recognized color string; undefined otherwise.
+// Excel rejects the whole styles.xml if rgb="" contains non-hex or unescaped
+// quotes (which CSS strings like `font-family:"Times New Roman"` would produce).
+const normalizeHex = (color) => {
+    if (typeof color !== "string")
+        return undefined;
+    const trimmed = color.trim();
+    if (!trimmed)
+        return undefined;
+    const noHash = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
+    if (HEX8_RE.test(noHash))
+        return noHash.toUpperCase();
+    if (HEX6_RE.test(noHash))
+        return `FF${noHash.toUpperCase()}`;
+    const m = RGB_FUNC_RE.exec(trimmed);
+    if (m) {
+        const toHex = (s) => {
+            const n = Math.max(0, Math.min(255, parseInt(s, 10) | 0));
+            return n.toString(16).padStart(2, "0").toUpperCase();
+        };
+        const alpha = m[4] != null
+            ? Math.max(0, Math.min(255, Math.round(parseFloat(m[4]) * 255)))
+                .toString(16)
+                .padStart(2, "0")
+                .toUpperCase()
+            : "FF";
+        return `${alpha}${toHex(m[1])}${toHex(m[2])}${toHex(m[3])}`;
+    }
+    return undefined;
+};
+const serializeAlignment = (record) => {
+    const attrs = [];
+    if (record.horizontalAlignment) {
+        attrs.push(`horizontal="${record.horizontalAlignment}"`);
+    }
+    if (record.verticalAlignment) {
+        attrs.push(`vertical="${record.verticalAlignment}"`);
+    }
+    if (record.wrapText) {
+        attrs.push(`wrapText="1"`);
+    }
+    if (typeof record.indent === "number" &&
+        Number.isFinite(record.indent) &&
+        record.indent > 0) {
+        attrs.push(`indent="${record.indent}"`);
+    }
+    if (typeof record.relativeIndent === "number" &&
+        Number.isFinite(record.relativeIndent) &&
+        record.relativeIndent !== 0) {
+        attrs.push(`relativeIndent="${record.relativeIndent}"`);
+    }
+    if (record.textRotation !== undefined && record.textRotation !== null) {
+        // Excel encodes "vertical (stacked)" text as the magic value 255.
+        const rotation = record.textRotation === "vertical" ? 255 : record.textRotation;
+        if (Number.isFinite(rotation) && rotation !== 0) {
+            attrs.push(`textRotation="${rotation}"`);
+        }
+    }
+    if (record.shrinkToFit) {
+        attrs.push(`shrinkToFit="1"`);
+    }
+    if (!attrs.length)
+        return "";
+    return `<alignment ${attrs.join(" ")}/>`;
+};
+const serializeXf = (record) => {
+    return [
+        record.numFmtId,
+        record.fontId,
+        record.fillId,
+        record.borderId,
+        record.wrapText ? 1 : 0,
+        record.horizontalAlignment ?? "",
+        record.verticalAlignment ?? "",
+        record.indent ?? "",
+        record.relativeIndent ?? "",
+        record.textRotation ?? "",
+        record.shrinkToFit ? 1 : 0,
+        record.protectionLocked === false ? 0 : "",
+        record.protectionHidden === true ? 1 : "",
+    ].join(":");
+};
+const serializeProtection = (record) => {
+    const attrs = [];
+    // Only emit when the value deviates from Excel's defaults (locked=true,
+    // hidden=false) — otherwise we'd flag every xf as having protection.
+    if (record.protectionLocked === false) {
+        attrs.push(`locked="0"`);
+    }
+    if (record.protectionHidden === true) {
+        attrs.push(`hidden="1"`);
+    }
+    if (!attrs.length)
+        return "";
+    return `<protection ${attrs.join(" ")}/>`;
+};
+const normalizeHorizontalAlignment = (value) => {
+    const allowed = new Set([
+        "general",
+        "left",
+        "center",
+        "right",
+        "fill",
+        "justify",
+        "centerContinuous",
+        "distributed",
+    ]);
+    if (!value)
+        return undefined;
+    return allowed.has(value) ? value : undefined;
+};
+const normalizeVerticalAlignment = (value) => {
+    if (!value)
+        return undefined;
+    if (value === "middle")
+        return "center";
+    const allowed = new Set([
+        "top",
+        "center",
+        "bottom",
+        "justify",
+        "distributed",
+    ]);
+    return allowed.has(value) ? value : undefined;
+};
+const XML_DECLARATION = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`;
+const WORKSHEET_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+const normalizeFormat = (format, cellXfs) => {
+    if (format && isStyleReference(format)) {
+        const styleId = format.sid ?? format.styleId;
+        if (styleId) {
+            return cellXfs?.get(styleId);
+        }
+        return undefined;
+    }
+    return format ?? undefined;
+};
+const escapeXml = (value) => value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");