@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,813 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { getCellEffectiveFormat, getCellUserEnteredFormat, } from "@rowsncolumns/utils";
+import { BUILTIN_NUMFMT_BY_PATTERN } from "../../excel-parser/builtin-numfmts";
+var isStyleReference = function (value) {
+    return !!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.
+var BUILT_IN_NUMFMT_BY_PATTERN = BUILTIN_NUMFMT_BY_PATTERN;
+var StyleBuilder = /** @class */ (function () {
+    function StyleBuilder() {
+        this.numberFormats = [];
+        this.fonts = [
+            {
+                name: "Calibri",
+                size: 11,
+            },
+        ];
+        this.fills = [{ pattern: "none" }, { pattern: "gray125" }];
+        this.borders = [{}];
+        this.namedCellStyles = [
+            { name: "Normal", xfId: 0, builtinId: 0 },
+        ];
+        this.customTableStyles = [];
+        this.cellXfs = [
+            {
+                numFmtId: 0,
+                fontId: 0,
+                fillId: 0,
+                borderId: 0,
+            },
+        ];
+        this.fontMap = new Map();
+        this.fillMap = new Map();
+        this.borderMap = new Map();
+        this.formatMap = new Map();
+        this.xfMap = new Map();
+        this.dxfs = [];
+        this.dxfMap = new Map();
+        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 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.
+     */
+    StyleBuilder.prototype.setNamedCellStyles = function (entries) {
+        if (!entries || entries.length === 0)
+            return;
+        var hasNormal = entries.some(function (e) { return e.builtinId === 0 || e.name === "Normal"; });
+        this.namedCellStyles = hasNormal
+            ? entries.slice()
+            : __spreadArray([{ name: "Normal", xfId: 0, builtinId: 0 }], __read(entries), false);
+    };
+    /**
+     * 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()`.
+     */
+    StyleBuilder.prototype.setCustomTableStyles = function (entries) {
+        if (!entries || entries.length === 0) {
+            this.customTableStyles = [];
+            return;
+        }
+        this.customTableStyles = entries.slice();
+    };
+    /**
+     * 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.
+     */
+    StyleBuilder.prototype.setDefaultFont = function (format) {
+        if (this.fonts.length > 1)
+            return;
+        var record = this.buildFontRecord(format);
+        if (!record)
+            return;
+        this.fonts[0] = record;
+        this.fontMap.clear();
+        this.fontMap.set(this.serializeFont(record), 0);
+    };
+    StyleBuilder.prototype.registerCell = function (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) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        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.
+        var userEnteredFormat = normalizeFormat(getCellUserEnteredFormat(cell), cellXfs);
+        var effectiveFormat = (_a = userEnteredFormat !== null && userEnteredFormat !== void 0 ? userEnteredFormat : normalizeFormat(getCellEffectiveFormat(cell), cellXfs)) !== null && _a !== void 0 ? _a : 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 === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.numberFormat)) {
+            effectiveFormat = __assign(__assign({}, (effectiveFormat !== null && effectiveFormat !== void 0 ? effectiveFormat : {})), { numberFormat: derivedNumberFormat });
+        }
+        var numberFormatId = this.getNumberFormatId(effectiveFormat);
+        var fontId = this.getFontId(effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.textFormat);
+        var fillId = this.getFillId(effectiveFormat);
+        var borderId = this.getBorderId(effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.borders);
+        var xfRecord = {
+            numFmtId: numberFormatId,
+            fontId: fontId,
+            fillId: fillId,
+            borderId: borderId,
+            wrapText: (effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.wrapStrategy) === "wrap",
+            horizontalAlignment: normalizeHorizontalAlignment(effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.horizontalAlignment),
+            verticalAlignment: normalizeVerticalAlignment(effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.verticalAlignment),
+            indent: (_b = effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.indent) !== null && _b !== void 0 ? _b : undefined,
+            relativeIndent: (_c = effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.relativeIndent) !== null && _c !== void 0 ? _c : undefined,
+            textRotation: (_d = effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.textRotation) !== null && _d !== void 0 ? _d : undefined,
+            shrinkToFit: (_e = effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.shrinkToFit) !== null && _e !== void 0 ? _e : 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: ((_f = cell === null || cell === void 0 ? void 0 : cell.protection) === null || _f === void 0 ? void 0 : _f.locked) === false ? false : undefined,
+            protectionHidden: ((_g = cell === null || cell === void 0 ? void 0 : cell.protection) === null || _g === void 0 ? void 0 : _g.hidden) === true ? true : undefined,
+        };
+        var key = serializeXf(xfRecord);
+        var existing = this.xfMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        var nextId = this.cellXfs.length;
+        this.cellXfs.push(xfRecord);
+        this.xfMap.set(key, nextId);
+        return nextId;
+    };
+    StyleBuilder.prototype.registerDifferentialFormat = function (format) {
+        if (!format)
+            return undefined;
+        var record = {};
+        if (format.backgroundColor) {
+            record.fill = {
+                color: format.backgroundColor,
+            };
+        }
+        var font = this.buildFontRecord(format.textFormat);
+        if (font) {
+            record.font = font;
+        }
+        if (!record.fill && !record.font) {
+            return undefined;
+        }
+        var key = this.serializeDxf(record);
+        var existing = this.dxfMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        var nextId = this.dxfs.length;
+        this.dxfs.push(record);
+        this.dxfMap.set(key, nextId);
+        return nextId;
+    };
+    StyleBuilder.prototype.getNumberFormatId = function (effectiveFormat) {
+        var _a;
+        var pattern = (_a = effectiveFormat === null || effectiveFormat === void 0 ? void 0 : effectiveFormat.numberFormat) === null || _a === void 0 ? void 0 : _a.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.
+        var 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.
+        var builtInId = BUILT_IN_NUMFMT_BY_PATTERN.get(normalizedPattern);
+        if (typeof builtInId === "number") {
+            return builtInId;
+        }
+        var 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).
+        var nextId = 164 + this.numberFormats.length;
+        this.numberFormats.push({
+            id: nextId,
+            format: normalizedPattern,
+        });
+        this.formatMap.set(normalizedPattern, nextId);
+        return nextId;
+    };
+    StyleBuilder.prototype.getFontId = function (format) {
+        var record = this.buildFontRecord(format);
+        if (!record)
+            return 0;
+        var key = this.serializeFont(record);
+        var existing = this.fontMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        var nextId = this.fonts.length;
+        this.fonts.push(record);
+        this.fontMap.set(key, nextId);
+        return nextId;
+    };
+    StyleBuilder.prototype.getFillId = function (format) {
+        var _a, _b, _c, _d, _e;
+        var fillPattern = (_a = format === null || format === void 0 ? void 0 : format.fillPattern) !== null && _a !== void 0 ? _a : undefined;
+        var fgColor = (_b = format === null || format === void 0 ? void 0 : format.foregroundColor) !== null && _b !== void 0 ? _b : undefined;
+        var bgColor = (_c = format === null || format === void 0 ? void 0 : format.backgroundColor) !== null && _c !== void 0 ? _c : undefined;
+        var gradient = (_d = format === null || format === void 0 ? void 0 : format.gradient) !== null && _d !== void 0 ? _d : undefined;
+        // Gradient fill takes precedence over pattern — Excel's UI treats
+        // them as mutually exclusive on a single cell.
+        if (gradient && ((_e = gradient.stops) === null || _e === void 0 ? void 0 : _e.length)) {
+            var record_1 = { gradient: gradient };
+            var key_1 = this.serializeFill(record_1);
+            var existing_1 = this.fillMap.get(key_1);
+            if (typeof existing_1 === "number")
+                return existing_1;
+            var nextId_1 = this.fills.length;
+            this.fills.push(record_1);
+            this.fillMap.set(key_1, nextId_1);
+            return nextId_1;
+        }
+        // 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") {
+            var record_2 = {
+                color: fgColor !== null && fgColor !== void 0 ? fgColor : bgColor,
+                bgColor: fgColor ? bgColor : undefined,
+                pattern: fillPattern,
+            };
+            var key_2 = this.serializeFill(record_2);
+            var existing_2 = this.fillMap.get(key_2);
+            if (typeof existing_2 === "number")
+                return existing_2;
+            var nextId_2 = this.fills.length;
+            this.fills.push(record_2);
+            this.fillMap.set(key_2, nextId_2);
+            return nextId_2;
+        }
+        // Solid fill: prefer explicit foregroundColor, fall back to
+        // backgroundColor for the common authored-as-bg case.
+        var color = fgColor !== null && fgColor !== void 0 ? fgColor : bgColor;
+        var record = {
+            color: color,
+            pattern: color ? "solid" : "none",
+        };
+        var key = this.serializeFill(record);
+        var existing = this.fillMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        var nextId = this.fills.length;
+        this.fills.push(record);
+        this.fillMap.set(key, nextId);
+        return nextId;
+    };
+    StyleBuilder.prototype.getBorderId = function (borders) {
+        var _a;
+        // 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.
+        var diagonalEdge = convertBorderEdge((_a = borders === null || borders === void 0 ? void 0 : borders.diagonalUp) !== null && _a !== void 0 ? _a : borders === null || borders === void 0 ? void 0 : borders.diagonalDown);
+        var record = {
+            top: convertBorderEdge(borders === null || borders === void 0 ? void 0 : borders.top),
+            bottom: convertBorderEdge(borders === null || borders === void 0 ? void 0 : borders.bottom),
+            left: convertBorderEdge(borders === null || borders === void 0 ? void 0 : borders.left),
+            right: convertBorderEdge(borders === null || borders === void 0 ? void 0 : borders.right),
+            diagonal: diagonalEdge,
+            diagonalUp: !!(borders === null || borders === void 0 ? void 0 : borders.diagonalUp),
+            diagonalDown: !!(borders === null || borders === void 0 ? void 0 : borders.diagonalDown),
+        };
+        var key = this.serializeBorder(record);
+        var existing = this.borderMap.get(key);
+        if (typeof existing === "number") {
+            return existing;
+        }
+        var nextId = this.borders.length;
+        this.borders.push(record);
+        this.borderMap.set(key, nextId);
+        return nextId;
+    };
+    StyleBuilder.prototype.serializeFont = function (font) {
+        var _a, _b, _c;
+        return [
+            (_a = font.name) !== null && _a !== void 0 ? _a : "",
+            (_b = font.size) !== null && _b !== void 0 ? _b : "",
+            font.bold ? "1" : "",
+            font.italic ? "1" : "",
+            font.underline ? "1" : "",
+            font.strike ? "1" : "",
+            serializeColor(font.color),
+            (_c = font.vertAlign) !== null && _c !== void 0 ? _c : "",
+        ].join("|");
+    };
+    StyleBuilder.prototype.buildFontRecord = function (format) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!(format === null || format === void 0 ? void 0 : format.bold) &&
+            !(format === null || format === void 0 ? void 0 : format.italic) &&
+            !(format === null || format === void 0 ? void 0 : format.underline) &&
+            !(format === null || format === void 0 ? void 0 : format.strikethrough) &&
+            !(format === null || format === void 0 ? void 0 : format.fontSize) &&
+            !(format === null || format === void 0 ? void 0 : format.fontFamily) &&
+            !(format === null || format === void 0 ? void 0 : format.color) &&
+            !(format === null || format === void 0 ? void 0 : format.baselineOffset)) {
+            return undefined;
+        }
+        var vertAlign = (format === null || format === void 0 ? void 0 : format.baselineOffset) === "superscript" ||
+            (format === null || format === void 0 ? void 0 : format.baselineOffset) === "subscript"
+            ? format.baselineOffset
+            : undefined;
+        return {
+            bold: (_a = format === null || format === void 0 ? void 0 : format.bold) !== null && _a !== void 0 ? _a : undefined,
+            italic: (_b = format === null || format === void 0 ? void 0 : format.italic) !== null && _b !== void 0 ? _b : undefined,
+            underline: (_c = format === null || format === void 0 ? void 0 : format.underline) !== null && _c !== void 0 ? _c : undefined,
+            strike: (_d = format === null || format === void 0 ? void 0 : format.strikethrough) !== null && _d !== void 0 ? _d : undefined,
+            size: (_e = format === null || format === void 0 ? void 0 : format.fontSize) !== null && _e !== void 0 ? _e : undefined,
+            name: (_f = format === null || format === void 0 ? void 0 : format.fontFamily) !== null && _f !== void 0 ? _f : undefined,
+            color: (_g = format === null || format === void 0 ? void 0 : format.color) !== null && _g !== void 0 ? _g : undefined,
+            vertAlign: vertAlign,
+        };
+    };
+    StyleBuilder.prototype.buildFontXml = function (font) {
+        var color = serializeColorXml(font.color);
+        var name = sanitizeFontName(font.name);
+        return "<font>".concat(font.size ? "<sz val=\"".concat(font.size, "\"/>") : "").concat(name ? "<name val=\"".concat(escapeXml(name), "\"/>") : "").concat(font.bold ? "<b/>" : "").concat(font.italic ? "<i/>" : "").concat(font.underline ? "<u/>" : "").concat(font.strike ? "<strike/>" : "").concat(font.vertAlign ? "<vertAlign val=\"".concat(font.vertAlign, "\"/>") : "").concat(color ? "<color ".concat(color, "/>") : "", "</font>");
+    };
+    StyleBuilder.prototype.buildFillXml = function (fill, forDxf) {
+        var _a, _b;
+        if (forDxf === void 0) { 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 && ((_a = fill.gradient.stops) === null || _a === void 0 ? void 0 : _a.length)) {
+            if (forDxf) {
+                var first = fill.gradient.stops[0].color;
+                var fallback = serializeColorXml(first);
+                if (fallback) {
+                    return "<fill><patternFill patternType=\"solid\"><fgColor ".concat(fallback, "/><bgColor ").concat(fallback, "/></patternFill></fill>");
+                }
+                return "<fill><patternFill patternType=\"none\"/></fill>";
+            }
+            return this.buildGradientFillXml(fill.gradient);
+        }
+        var pattern = (_b = fill.pattern) !== null && _b !== void 0 ? _b : (fill.color ? "solid" : "none");
+        if (pattern === "gray125" && !fill.color) {
+            return "<fill><patternFill patternType=\"gray125\"/></fill>";
+        }
+        var 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 ".concat(color, "/><bgColor ").concat(color, "/></patternFill></fill>");
+            }
+            return "<fill><patternFill patternType=\"solid\"><fgColor ".concat(color, "/><bgColor indexed=\"64\"/></patternFill></fill>");
+        }
+        // True patterned fill — emit both fg and bg if available.
+        var bgColor = serializeColorXml(fill.bgColor);
+        var bgAttr = bgColor ? "<bgColor ".concat(bgColor, "/>") : "<bgColor indexed=\"64\"/>";
+        return "<fill><patternFill patternType=\"".concat(pattern, "\"><fgColor ").concat(color, "/>").concat(bgAttr, "</patternFill></fill>");
+    };
+    StyleBuilder.prototype.buildGradientFillXml = function (gradient) {
+        var stopsXml = gradient.stops
+            .map(function (s) {
+            var color = serializeColorXml(s.color);
+            return "<stop position=\"".concat(s.position, "\">").concat(color ? "<color ".concat(color, "/>") : "", "</stop>");
+        })
+            .join("");
+        var attrs = [];
+        if (gradient.type === "path") {
+            attrs.push('type="path"');
+            if (gradient.left != null)
+                attrs.push("left=\"".concat(gradient.left, "\""));
+            if (gradient.right != null)
+                attrs.push("right=\"".concat(gradient.right, "\""));
+            if (gradient.top != null)
+                attrs.push("top=\"".concat(gradient.top, "\""));
+            if (gradient.bottom != null)
+                attrs.push("bottom=\"".concat(gradient.bottom, "\""));
+        }
+        else if (gradient.degree != null && gradient.degree !== 0) {
+            attrs.push("degree=\"".concat(gradient.degree, "\""));
+        }
+        var attrStr = attrs.length ? " " + attrs.join(" ") : "";
+        return "<fill><gradientFill".concat(attrStr, ">").concat(stopsXml, "</gradientFill></fill>");
+    };
+    StyleBuilder.prototype.serializeFill = function (fill) {
+        var _a, _b, _c, _d, _e, _f;
+        var gradientKey = fill.gradient
+            ? "G:".concat(fill.gradient.type, ":").concat((_a = fill.gradient.degree) !== null && _a !== void 0 ? _a : "", ":").concat((_b = fill.gradient.left) !== null && _b !== void 0 ? _b : "", ":").concat((_c = fill.gradient.right) !== null && _c !== void 0 ? _c : "", ":").concat((_d = fill.gradient.top) !== null && _d !== void 0 ? _d : "", ":").concat((_e = fill.gradient.bottom) !== null && _e !== void 0 ? _e : "", ":").concat(fill.gradient.stops
+                .map(function (s) { return "".concat(s.position, ",").concat(s.color); })
+                .join("|"))
+            : "";
+        return "".concat((_f = fill.pattern) !== null && _f !== void 0 ? _f : "", ":").concat(serializeColor(fill.color), ":").concat(serializeColor(fill.bgColor), ":").concat(gradientKey);
+    };
+    StyleBuilder.prototype.serializeBorder = function (border) {
+        return [
+            serializeBorderEdge(border.top),
+            serializeBorderEdge(border.bottom),
+            serializeBorderEdge(border.left),
+            serializeBorderEdge(border.right),
+            serializeBorderEdge(border.diagonal),
+            border.diagonalUp ? "1" : "",
+            border.diagonalDown ? "1" : "",
+        ].join("|");
+    };
+    StyleBuilder.prototype.serializeDxf = function (dxf) {
+        return "".concat(dxf.fill ? this.serializeFill(dxf.fill) : "", "|").concat(dxf.font ? this.serializeFont(dxf.font) : "");
+    };
+    StyleBuilder.prototype.toXml = function () {
+        var _this = this;
+        var numFmtXml = this.numberFormats.length
+            ? "<numFmts count=\"".concat(this.numberFormats.length, "\">").concat(this.numberFormats
+                .map(function (fmt) {
+                return "<numFmt numFmtId=\"".concat(fmt.id, "\" formatCode=\"").concat(escapeXml(fmt.format), "\"/>");
+            })
+                .join(""), "</numFmts>")
+            : "<numFmts count=\"0\"/>";
+        var fontXml = "<fonts count=\"".concat(this.fonts.length, "\">").concat(this.fonts
+            .map(function (font) { return _this.buildFontXml(font); })
+            .join(""), "</fonts>");
+        var fillXml = "<fills count=\"".concat(this.fills.length, "\">").concat(this.fills
+            .map(function (fill) { return _this.buildFillXml(fill, false); })
+            .join(""), "</fills>");
+        var borderXml = "<borders count=\"".concat(this.borders.length, "\">").concat(this.borders
+            .map(function (border) {
+            var top = serializeBorderEdgeXml(border.top, "top");
+            var bottom = serializeBorderEdgeXml(border.bottom, "bottom");
+            var left = serializeBorderEdgeXml(border.left, "left");
+            var right = serializeBorderEdgeXml(border.right, "right");
+            var diagonal = border.diagonal
+                ? serializeBorderEdgeXml(border.diagonal, "diagonal")
+                : "<diagonal/>";
+            var diagonalAttrs = "".concat(border.diagonalUp ? " diagonalUp=\"1\"" : "").concat(border.diagonalDown ? " diagonalDown=\"1\"" : "");
+            return "<border".concat(diagonalAttrs, ">").concat(left).concat(right).concat(top).concat(bottom).concat(diagonal, "</border>");
+        })
+            .join(""), "</borders>");
+        var cellXfsXml = "<cellXfs count=\"".concat(this.cellXfs.length, "\">").concat(this.cellXfs
+            .map(function (record) {
+            var alignment = serializeAlignment(record);
+            var 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.
+            var applyNumberFormat = record.numFmtId !== 0 ? " applyNumberFormat=\"1\"" : "";
+            var applyFont = record.fontId !== 0 ? " applyFont=\"1\"" : "";
+            var applyFill = record.fillId !== 0 ? " applyFill=\"1\"" : "";
+            var applyBorder = record.borderId !== 0 ? " applyBorder=\"1\"" : "";
+            var applyAlignment = alignment ? " applyAlignment=\"1\"" : "";
+            var applyProtection = protection ? " applyProtection=\"1\"" : "";
+            return "<xf numFmtId=\"".concat(record.numFmtId, "\" fontId=\"").concat(record.fontId, "\" fillId=\"").concat(record.fillId, "\" borderId=\"").concat(record.borderId, "\" xfId=\"0\"").concat(applyNumberFormat).concat(applyFont).concat(applyFill).concat(applyBorder).concat(applyAlignment).concat(applyProtection, ">").concat(alignment).concat(protection, "</xf>");
+        })
+            .join(""), "</cellXfs>");
+        var resolvedTableStyles = this.customTableStyles.map(function (style) {
+            var e_1, _a;
+            var resolvedElements = [];
+            try {
+                for (var _b = __values(style.elements), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var el = _c.value;
+                    var dxfId = _this.registerDifferentialFormat(__assign(__assign({}, (el.backgroundColor
+                        ? { backgroundColor: el.backgroundColor }
+                        : {})), (el.textColor || el.bold || el.italic
+                        ? {
+                            textFormat: __assign(__assign(__assign({}, (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(__assign({ type: el.type, dxfId: dxfId }, (el.size != null ? { size: el.size } : {})));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return {
+                name: style.name,
+                pivot: style.pivot,
+                elements: resolvedElements,
+            };
+        });
+        var dxfsXml = this.dxfs.length
+            ? "<dxfs count=\"".concat(this.dxfs.length, "\">").concat(this.dxfs
+                .map(function (dxf) {
+                var font = dxf.font ? _this.buildFontXml(dxf.font) : "";
+                var fill = dxf.fill ? _this.buildFillXml(dxf.fill, true) : "";
+                return "<dxf>".concat(font).concat(fill, "</dxf>");
+            })
+                .join(""), "</dxfs>")
+            : "<dxfs count=\"0\"/>";
+        var cellStylesXml = "<cellStyles count=\"".concat(this.namedCellStyles.length, "\">").concat(this.namedCellStyles
+            .map(function (s) {
+            var parts = ["name=\"".concat(escapeXml(s.name), "\"")];
+            parts.push("xfId=\"".concat(s.xfId, "\""));
+            if (s.builtinId != null)
+                parts.push("builtinId=\"".concat(s.builtinId, "\""));
+            if (s.iLevel != null)
+                parts.push("iLevel=\"".concat(s.iLevel, "\""));
+            if (s.hidden)
+                parts.push("hidden=\"1\"");
+            if (s.customBuiltin)
+                parts.push("customBuiltin=\"1\"");
+            return "<cellStyle ".concat(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.
+        var customTableStylesXml = resolvedTableStyles
+            .filter(function (s) { return s.elements.length > 0; })
+            .map(function (s) {
+            var pivotAttr = s.pivot ? " pivot=\"1\"" : " pivot=\"0\"";
+            var elementsXml = s.elements
+                .map(function (el) {
+                var sizeAttr = el.size != null ? " size=\"".concat(el.size, "\"") : "";
+                return "<tableStyleElement type=\"".concat(escapeXml(el.type), "\" dxfId=\"").concat(el.dxfId, "\"").concat(sizeAttr, "/>");
+            })
+                .join("");
+            return "<tableStyle name=\"".concat(escapeXml(s.name), "\"").concat(pivotAttr, " count=\"").concat(s.elements.length, "\">").concat(elementsXml, "</tableStyle>");
+        })
+            .join("");
+        var tableStylesXml = "<tableStyles count=\"".concat(resolvedTableStyles.filter(function (s) { return s.elements.length > 0; }).length, "\" defaultTableStyle=\"TableStyleMedium2\" defaultPivotStyle=\"PivotStyleLight16\">").concat(customTableStylesXml, "</tableStyles>");
+        var styleXml = "".concat(XML_DECLARATION, "<styleSheet xmlns=\"").concat(WORKSHEET_NS, "\">").concat(numFmtXml).concat(fontXml).concat(fillXml).concat(borderXml, "<cellStyleXfs count=\"1\"><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\"/></cellStyleXfs>").concat(cellXfsXml).concat(cellStylesXml).concat(dxfsXml).concat(tableStylesXml, "</styleSheet>");
+        return styleXml;
+    };
+    return StyleBuilder;
+}());
+export { StyleBuilder };
+var convertBorderEdge = function (border) {
+    var _a;
+    if (!border || !border.style)
+        return undefined;
+    return {
+        style: mapBorderStyle(border.style),
+        color: (_a = border.color) !== null && _a !== void 0 ? _a : undefined,
+    };
+};
+var mapBorderStyle = function (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";
+    }
+};
+var serializeBorderEdge = function (edge) {
+    if (!edge)
+        return "";
+    return "".concat(edge.style || "", ":").concat(serializeColor(edge.color));
+};
+var serializeBorderEdgeXml = function (edge, side) {
+    if (!(edge === null || edge === void 0 ? void 0 : edge.style)) {
+        return "<".concat(side, "/>");
+    }
+    var color = serializeColorXml(edge.color);
+    return "<".concat(side, " style=\"").concat(edge.style, "\">").concat(color ? "<color ".concat(color, "/>") : "", "</").concat(side, ">");
+};
+var serializeColor = function (color) {
+    var _a, _b;
+    if (!color)
+        return "";
+    if (typeof color === "string") {
+        return (_a = normalizeHex(color)) !== null && _a !== void 0 ? _a : "";
+    }
+    return "theme".concat(color.theme, ":").concat((_b = color.tint) !== null && _b !== void 0 ? _b : "");
+};
+var serializeColorXml = function (color) {
+    if (!color)
+        return undefined;
+    if (typeof color === "string") {
+        var hex = normalizeHex(color);
+        return hex ? "rgb=\"".concat(hex, "\"") : undefined;
+    }
+    var tintAttr = typeof color.tint === "number" ? " tint=\"".concat(color.tint, "\"") : "";
+    return "theme=\"".concat(color.theme, "\"").concat(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.
+var sanitizeFontName = function (name) {
+    if (!name || typeof name !== "string")
+        return undefined;
+    var first = name.split(",")[0].trim().replace(/^['"]|['"]$/g, "");
+    if (!first)
+        return undefined;
+    return first.length > 31 ? first.slice(0, 31) : first;
+};
+var HEX6_RE = /^[0-9A-Fa-f]{6}$/;
+var HEX8_RE = /^[0-9A-Fa-f]{8}$/;
+var 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).
+var normalizeHex = function (color) {
+    if (typeof color !== "string")
+        return undefined;
+    var trimmed = color.trim();
+    if (!trimmed)
+        return undefined;
+    var noHash = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
+    if (HEX8_RE.test(noHash))
+        return noHash.toUpperCase();
+    if (HEX6_RE.test(noHash))
+        return "FF".concat(noHash.toUpperCase());
+    var m = RGB_FUNC_RE.exec(trimmed);
+    if (m) {
+        var toHex = function (s) {
+            var n = Math.max(0, Math.min(255, parseInt(s, 10) | 0));
+            return n.toString(16).padStart(2, "0").toUpperCase();
+        };
+        var alpha = m[4] != null
+            ? Math.max(0, Math.min(255, Math.round(parseFloat(m[4]) * 255)))
+                .toString(16)
+                .padStart(2, "0")
+                .toUpperCase()
+            : "FF";
+        return "".concat(alpha).concat(toHex(m[1])).concat(toHex(m[2])).concat(toHex(m[3]));
+    }
+    return undefined;
+};
+var serializeAlignment = function (record) {
+    var attrs = [];
+    if (record.horizontalAlignment) {
+        attrs.push("horizontal=\"".concat(record.horizontalAlignment, "\""));
+    }
+    if (record.verticalAlignment) {
+        attrs.push("vertical=\"".concat(record.verticalAlignment, "\""));
+    }
+    if (record.wrapText) {
+        attrs.push("wrapText=\"1\"");
+    }
+    if (typeof record.indent === "number" &&
+        Number.isFinite(record.indent) &&
+        record.indent > 0) {
+        attrs.push("indent=\"".concat(record.indent, "\""));
+    }
+    if (typeof record.relativeIndent === "number" &&
+        Number.isFinite(record.relativeIndent) &&
+        record.relativeIndent !== 0) {
+        attrs.push("relativeIndent=\"".concat(record.relativeIndent, "\""));
+    }
+    if (record.textRotation !== undefined && record.textRotation !== null) {
+        // Excel encodes "vertical (stacked)" text as the magic value 255.
+        var rotation = record.textRotation === "vertical" ? 255 : record.textRotation;
+        if (Number.isFinite(rotation) && rotation !== 0) {
+            attrs.push("textRotation=\"".concat(rotation, "\""));
+        }
+    }
+    if (record.shrinkToFit) {
+        attrs.push("shrinkToFit=\"1\"");
+    }
+    if (!attrs.length)
+        return "";
+    return "<alignment ".concat(attrs.join(" "), "/>");
+};
+var serializeXf = function (record) {
+    var _a, _b, _c, _d, _e;
+    return [
+        record.numFmtId,
+        record.fontId,
+        record.fillId,
+        record.borderId,
+        record.wrapText ? 1 : 0,
+        (_a = record.horizontalAlignment) !== null && _a !== void 0 ? _a : "",
+        (_b = record.verticalAlignment) !== null && _b !== void 0 ? _b : "",
+        (_c = record.indent) !== null && _c !== void 0 ? _c : "",
+        (_d = record.relativeIndent) !== null && _d !== void 0 ? _d : "",
+        (_e = record.textRotation) !== null && _e !== void 0 ? _e : "",
+        record.shrinkToFit ? 1 : 0,
+        record.protectionLocked === false ? 0 : "",
+        record.protectionHidden === true ? 1 : "",
+    ].join(":");
+};
+var serializeProtection = function (record) {
+    var 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 ".concat(attrs.join(" "), "/>");
+};
+var normalizeHorizontalAlignment = function (value) {
+    var allowed = new Set([
+        "general",
+        "left",
+        "center",
+        "right",
+        "fill",
+        "justify",
+        "centerContinuous",
+        "distributed",
+    ]);
+    if (!value)
+        return undefined;
+    return allowed.has(value) ? value : undefined;
+};
+var normalizeVerticalAlignment = function (value) {
+    if (!value)
+        return undefined;
+    if (value === "middle")
+        return "center";
+    var allowed = new Set([
+        "top",
+        "center",
+        "bottom",
+        "justify",
+        "distributed",
+    ]);
+    return allowed.has(value) ? value : undefined;
+};
+var XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
+var WORKSHEET_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+var normalizeFormat = function (format, cellXfs) {
+    var _a;
+    if (format && isStyleReference(format)) {
+        var styleId = (_a = format.sid) !== null && _a !== void 0 ? _a : format.styleId;
+        if (styleId) {
+            return cellXfs === null || cellXfs === void 0 ? void 0 : cellXfs.get(styleId);
+        }
+        return undefined;
+    }
+    return format !== null && format !== void 0 ? format : undefined;
+};
+var escapeXml = function (value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+};