@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,808 @@
+import { __assign, __values } from "tslib";
+import { get } from "lodash-es";
+var OdsStyles = /** @class */ (function () {
+    function OdsStyles() {
+        this.cellStyles = new Map();
+        this.automaticCellStyles = new Map();
+        this.rowStyles = new Map();
+        this.automaticRowStyles = new Map();
+        this.columnStyles = new Map();
+        this.automaticColumnStyles = new Map();
+        this.textStyles = new Map();
+        this.automaticTextStyles = new Map();
+        this.tableStyles = new Map();
+        this.automaticTableStyles = new Map();
+        this.numberFormats = new Map();
+        this.chartStyles = new Map();
+    }
+    OdsStyles.prototype.reset = function () {
+        this.cellStyles.clear();
+        this.automaticCellStyles.clear();
+        this.rowStyles.clear();
+        this.automaticRowStyles.clear();
+        this.columnStyles.clear();
+        this.automaticColumnStyles.clear();
+        this.textStyles.clear();
+        this.automaticTextStyles.clear();
+        this.tableStyles.clear();
+        this.automaticTableStyles.clear();
+        this.numberFormats.clear();
+        this.chartStyles.clear();
+    };
+    OdsStyles.prototype.parseStylesXml = function (stylesXml) {
+        if (!stylesXml)
+            return;
+        var documentStyles = get(stylesXml, "office:document-styles") ||
+            get(stylesXml, "document-styles");
+        if (!documentStyles)
+            return;
+        var namedStyles = get(documentStyles, "office:styles.style:style") ||
+            get(documentStyles, "styles.style:style");
+        this.processStyles(namedStyles, false);
+        var automaticStyles = get(documentStyles, "office:automatic-styles.style:style") ||
+            get(documentStyles, "automatic-styles.style:style");
+        this.processStyles(automaticStyles, false);
+        this.processNumberStyles(documentStyles, get(documentStyles, "office:styles") || get(documentStyles, "styles"), get(documentStyles, "office:automatic-styles") ||
+            get(documentStyles, "automatic-styles"));
+    };
+    OdsStyles.prototype.parseContentXml = function (contentXml) {
+        if (!contentXml)
+            return;
+        var autoStyles = get(contentXml, "office:document-content.office:automatic-styles.style:style") || get(contentXml, "document-content.automatic-styles.style");
+        this.processStyles(autoStyles, true);
+        var autoStylesContainer = get(contentXml, "office:document-content.office:automatic-styles") ||
+            get(contentXml, "document-content.automatic-styles");
+        this.processNumberStyles(contentXml, autoStylesContainer);
+    };
+    OdsStyles.prototype.processStyles = function (styles, isAutomatic) {
+        var e_1, _a;
+        if (!styles)
+            return;
+        var styleArray = Array.isArray(styles) ? styles : [styles];
+        try {
+            for (var styleArray_1 = __values(styleArray), styleArray_1_1 = styleArray_1.next(); !styleArray_1_1.done; styleArray_1_1 = styleArray_1.next()) {
+                var style = styleArray_1_1.value;
+                var name_1 = style["@_style:name"] || style["@_name"];
+                if (!name_1)
+                    continue;
+                var family = style["@_style:family"] || style["@_family"];
+                if (family === "table-row") {
+                    var props = this.convertRowStyle(style);
+                    if (props) {
+                        (isAutomatic ? this.automaticRowStyles : this.rowStyles).set(name_1, props);
+                    }
+                    continue;
+                }
+                if (family === "table-column") {
+                    var props = this.convertColumnStyle(style);
+                    if (props) {
+                        (isAutomatic ? this.automaticColumnStyles : this.columnStyles).set(name_1, props);
+                    }
+                    continue;
+                }
+                if (family === "table") {
+                    var format = this.normalizeCellFormat(this.convertToCellFormat(style));
+                    if (format) {
+                        (isAutomatic ? this.automaticTableStyles : this.tableStyles).set(name_1, format);
+                    }
+                    continue;
+                }
+                if (family === "text") {
+                    var format = this.normalizeCellFormat(this.convertToCellFormat(style));
+                    (isAutomatic ? this.automaticTextStyles : this.textStyles).set(name_1, format);
+                    continue;
+                }
+                if (family === "table-cell") {
+                    var displayName = style["@_style:display-name"] || style["@_display-name"];
+                    var key = displayName || name_1;
+                    if (!key) {
+                        continue;
+                    }
+                    var targetMap = isAutomatic
+                        ? this.automaticCellStyles
+                        : this.cellStyles;
+                    targetMap.set(key, style);
+                    if (displayName && name_1 && name_1 !== key && !targetMap.has(name_1)) {
+                        targetMap.set(name_1, style);
+                    }
+                    continue;
+                }
+                if (typeof family === "string" &&
+                    (family.startsWith("chart") || family === "graphic")) {
+                    var color = this.convertChartStyle(style);
+                    if (color) {
+                        var displayName = style["@_style:display-name"] || style["@_display-name"];
+                        var key = displayName || name_1;
+                        if (key) {
+                            this.chartStyles.set(key, color);
+                            if (displayName && name_1 && name_1 !== key) {
+                                this.chartStyles.set(name_1, color);
+                            }
+                        }
+                    }
+                    continue;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (styleArray_1_1 && !styleArray_1_1.done && (_a = styleArray_1.return)) _a.call(styleArray_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    OdsStyles.prototype.processNumberStyles = function () {
+        var e_2, _a, e_3, _b;
+        var _c, _d;
+        var containers = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            containers[_i] = arguments[_i];
+        }
+        var definitions = [
+            { key: "number:number-style", kind: "number" },
+            { key: "number:currency-style", kind: "currency" },
+            { key: "number:percentage-style", kind: "percentage" },
+            { key: "number:date-style", kind: "date" },
+            { key: "number:time-style", kind: "time" },
+            { key: "number:date-time-style", kind: "date-time" },
+            { key: "number:scientific-number-style", kind: "scientific" },
+        ];
+        try {
+            for (var containers_1 = __values(containers), containers_1_1 = containers_1.next(); !containers_1_1.done; containers_1_1 = containers_1.next()) {
+                var container = containers_1_1.value;
+                if (!container)
+                    continue;
+                try {
+                    for (var definitions_1 = (e_3 = void 0, __values(definitions)), definitions_1_1 = definitions_1.next(); !definitions_1_1.done; definitions_1_1 = definitions_1.next()) {
+                        var _e = definitions_1_1.value, key = _e.key, kind = _e.kind;
+                        var nodes = (_d = (_c = (container && container[key])) !== null && _c !== void 0 ? _c : get(container, key)) !== null && _d !== void 0 ? _d : get(container, key.replace("number:", ""));
+                        this.processNumberStyleNodes(nodes, kind);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (definitions_1_1 && !definitions_1_1.done && (_b = definitions_1.return)) _b.call(definitions_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (containers_1_1 && !containers_1_1.done && (_a = containers_1.return)) _a.call(containers_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    OdsStyles.prototype.processNumberStyleNodes = function (nodes, kind) {
+        var e_4, _a;
+        if (!nodes)
+            return;
+        var arr = Array.isArray(nodes) ? nodes : [nodes];
+        try {
+            for (var arr_1 = __values(arr), arr_1_1 = arr_1.next(); !arr_1_1.done; arr_1_1 = arr_1.next()) {
+                var node = arr_1_1.value;
+                if (!node)
+                    continue;
+                var name_2 = node["@_style:name"] || node["@_name"];
+                if (!name_2)
+                    continue;
+                var numberFormat = this.convertNumberStyleNode(node, kind);
+                if (numberFormat) {
+                    this.numberFormats.set(name_2, numberFormat);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (arr_1_1 && !arr_1_1.done && (_a = arr_1.return)) _a.call(arr_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    OdsStyles.prototype.getStyle = function (styleName) {
+        var style = this.automaticCellStyles.get(styleName) || this.cellStyles.get(styleName);
+        if (!style)
+            return undefined;
+        return this.convertToCellFormat(style);
+    };
+    OdsStyles.prototype.getRowStyle = function (styleName) {
+        return (this.automaticRowStyles.get(styleName) || this.rowStyles.get(styleName));
+    };
+    OdsStyles.prototype.getColumnStyle = function (styleName) {
+        return (this.automaticColumnStyles.get(styleName) ||
+            this.columnStyles.get(styleName));
+    };
+    OdsStyles.prototype.getChartStyleColor = function (styleName) {
+        if (!styleName)
+            return undefined;
+        return this.chartStyles.get(styleName);
+    };
+    OdsStyles.prototype.getTableCellFormat = function (styleName) {
+        return (this.automaticTableStyles.get(styleName) ||
+            this.tableStyles.get(styleName));
+    };
+    OdsStyles.prototype.getTextFormat = function (styleName) {
+        var _a;
+        if (!styleName)
+            return undefined;
+        var format = this.automaticTextStyles.get(styleName) || this.textStyles.get(styleName);
+        return (_a = format === null || format === void 0 ? void 0 : format.textFormat) !== null && _a !== void 0 ? _a : undefined;
+    };
+    OdsStyles.prototype.convertToCellFormat = function (style) {
+        var e_5, _a, e_6, _b;
+        var _c;
+        var cellFormat = {};
+        var textPropsNode = style["style:text-properties"] || style["text-properties"];
+        var textProps = this.getAttributes(textPropsNode);
+        if (textProps) {
+            var textFormat = {};
+            var fontWeight = textProps["@_fo:font-weight"] || textProps["@_font-weight"];
+            if (fontWeight) {
+                var weight = parseInt(fontWeight, 10);
+                if (fontWeight === "bold" || (!isNaN(weight) && weight >= 700)) {
+                    textFormat.bold = true;
+                }
+            }
+            var fontStyle = textProps["@_fo:font-style"] || textProps["@_font-style"];
+            if (fontStyle === "italic") {
+                textFormat.italic = true;
+            }
+            var underline = textProps["@_style:text-underline-style"] ||
+                textProps["@_text-underline-style"];
+            if (underline && underline !== "none") {
+                textFormat.underline = true;
+            }
+            var color = textProps["@_fo:color"] || textProps["@_color"];
+            if (color) {
+                textFormat.color = this.parseColor(color);
+            }
+            var strike = textProps["@_style:text-line-through-style"] ||
+                textProps["@_text-line-through-style"];
+            if (strike && strike !== "none") {
+                textFormat.strikethrough = true;
+            }
+            var fontSize = textProps["@_fo:font-size"] || textProps["@_font-size"];
+            if (fontSize) {
+                textFormat.fontSize = parseFloat(fontSize);
+            }
+            var fontFamily = textProps["@_style:font-name"] ||
+                textProps["@_style:font-name-asian"] ||
+                textProps["@_font-name"];
+            if (fontFamily) {
+                textFormat.fontFamily = fontFamily;
+            }
+            // ODS encodes super/subscript as `style:text-position="super 58%"` or
+            // `style:text-position="sub 58%"`. We only model the kind, not the
+            // percentage — the renderer applies a fixed 58% scale.
+            var textPosition = textProps["@_style:text-position"] || textProps["@_text-position"];
+            if (textPosition) {
+                var token = (_c = String(textPosition).trim().split(/\s+/)[0]) === null || _c === void 0 ? void 0 : _c.toLowerCase();
+                if (token === "super") {
+                    textFormat.baselineOffset = "superscript";
+                }
+                else if (token === "sub") {
+                    textFormat.baselineOffset = "subscript";
+                }
+            }
+            if (Object.keys(textFormat).length > 0) {
+                cellFormat.textFormat = textFormat;
+            }
+        }
+        var cellPropsNode = style["style:table-cell-properties"] || style["table-cell-properties"];
+        var cellProps = this.getAttributes(cellPropsNode);
+        if (cellProps) {
+            var bgColor = cellProps["@_fo:background-color"] ||
+                cellProps["@_background-color"] ||
+                cellProps["@_draw:fill-color"];
+            if (bgColor && bgColor !== "transparent") {
+                cellFormat.backgroundColor = this.parseColor(bgColor);
+            }
+            var borderValue = cellProps["@_fo:border"] || cellProps["@_border"];
+            if (borderValue && borderValue !== "none") {
+                var borders = this.createBorders(borderValue);
+                if (borders) {
+                    cellFormat.borders = borders;
+                }
+            }
+            var sideMap = [
+                {
+                    key: "top",
+                    value: cellProps["@_fo:border-top"] ||
+                        cellProps["@_border-top"] ||
+                        cellProps["@_style:border-top"],
+                },
+                {
+                    key: "bottom",
+                    value: cellProps["@_fo:border-bottom"] ||
+                        cellProps["@_border-bottom"] ||
+                        cellProps["@_style:border-bottom"],
+                },
+                {
+                    key: "left",
+                    value: cellProps["@_fo:border-left"] ||
+                        cellProps["@_border-left"] ||
+                        cellProps["@_style:border-left"],
+                },
+                {
+                    key: "right",
+                    value: cellProps["@_fo:border-right"] ||
+                        cellProps["@_border-right"] ||
+                        cellProps["@_style:border-right"],
+                },
+            ];
+            try {
+                for (var sideMap_1 = __values(sideMap), sideMap_1_1 = sideMap_1.next(); !sideMap_1_1.done; sideMap_1_1 = sideMap_1.next()) {
+                    var _d = sideMap_1_1.value, key = _d.key, value = _d.value;
+                    if (!value || value === "none")
+                        continue;
+                    var parsedBorder = this.parseBorder(value);
+                    if (!parsedBorder)
+                        continue;
+                    if (!cellFormat.borders) {
+                        cellFormat.borders = {};
+                    }
+                    cellFormat.borders[key] = parsedBorder;
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (sideMap_1_1 && !sideMap_1_1.done && (_a = sideMap_1.return)) _a.call(sideMap_1);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            // ODS diagonals: `style:diagonal-bl-tr` = bottom-left → top-right
+            // (= our diagonalUp). `style:diagonal-tl-br` = top-left → bottom-right
+            // (= our diagonalDown).
+            var diagonalMap = [
+                {
+                    key: "diagonalUp",
+                    value: cellProps["@_style:diagonal-bl-tr"] ||
+                        cellProps["@_diagonal-bl-tr"],
+                },
+                {
+                    key: "diagonalDown",
+                    value: cellProps["@_style:diagonal-tl-br"] ||
+                        cellProps["@_diagonal-tl-br"],
+                },
+            ];
+            try {
+                for (var diagonalMap_1 = __values(diagonalMap), diagonalMap_1_1 = diagonalMap_1.next(); !diagonalMap_1_1.done; diagonalMap_1_1 = diagonalMap_1.next()) {
+                    var _e = diagonalMap_1_1.value, key = _e.key, value = _e.value;
+                    if (!value || value === "none")
+                        continue;
+                    var parsedBorder = this.parseBorder(value);
+                    if (!parsedBorder)
+                        continue;
+                    if (!cellFormat.borders) {
+                        cellFormat.borders = {};
+                    }
+                    cellFormat.borders[key] = parsedBorder;
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (diagonalMap_1_1 && !diagonalMap_1_1.done && (_b = diagonalMap_1.return)) _b.call(diagonalMap_1);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            var verticalAlign = cellProps["@_style:vertical-align"] ||
+                cellProps["@_vertical-align"] ||
+                cellProps["@_fo:vertical-align"];
+            if (verticalAlign) {
+                cellFormat.verticalAlignment =
+                    verticalAlign === "middle"
+                        ? "middle"
+                        : verticalAlign === "bottom"
+                            ? "bottom"
+                            : "top";
+            }
+            var cellTextAlign = cellProps["@_style:text-align"] ||
+                cellProps["@_text-align"] ||
+                cellProps["@_fo:text-align"];
+            var cellTextAlignSource = cellProps["@_style:text-align-source"] ||
+                cellProps["@_text-align-source"];
+            if (cellTextAlign) {
+                cellFormat.horizontalAlignment =
+                    cellTextAlign === "center"
+                        ? "center"
+                        : cellTextAlign === "end" || cellTextAlign === "right"
+                            ? "right"
+                            : "left";
+            }
+            else if (!cellFormat.horizontalAlignment &&
+                cellTextAlignSource === "value-type") {
+                cellFormat.__alignValueType = true;
+            }
+            var wrapOption = cellProps["@_fo:wrap-option"] || cellProps["@_wrap-option"];
+            if (wrapOption === "wrap") {
+                cellFormat.wrapStrategy = "wrap";
+            }
+            var rotationAngle = cellProps["@_style:rotation-angle"] || cellProps["@_rotation-angle"];
+            if (rotationAngle !== undefined) {
+                var rotation = parseFloat(rotationAngle);
+                if (!isNaN(rotation)) {
+                    cellFormat.textRotation = rotation;
+                }
+            }
+        }
+        var paraPropsNode = style["style:paragraph-properties"] || style["paragraph-properties"];
+        var paraProps = this.getAttributes(paraPropsNode);
+        if (paraProps) {
+            var textAlign = paraProps["@_fo:text-align"] ||
+                paraProps["@_text-align"] ||
+                paraProps["@_style:text-align"];
+            var textAlignSource = paraProps["@_style:text-align-source"] ||
+                paraProps["@_text-align-source"];
+            if (textAlign) {
+                cellFormat.horizontalAlignment =
+                    textAlign === "center"
+                        ? "center"
+                        : textAlign === "end" || textAlign === "right"
+                            ? "right"
+                            : "left";
+            }
+            else if (textAlignSource === "value-type") {
+                cellFormat.__alignValueType = true;
+            }
+        }
+        var dataStyleName = style["@_style:data-style-name"] || style["@_data-style-name"];
+        if (dataStyleName) {
+            var numberFormat = this.numberFormats.get(dataStyleName);
+            if (numberFormat) {
+                cellFormat.numberFormat = __assign({}, numberFormat);
+            }
+        }
+        return cellFormat;
+    };
+    OdsStyles.prototype.normalizeCellFormat = function (format) {
+        return Object.keys(format).length ? format : undefined;
+    };
+    OdsStyles.prototype.convertRowStyle = function (style) {
+        var rowPropsNode = style["style:table-row-properties"] || style["table-row-properties"];
+        var rowProps = this.getAttributes(rowPropsNode);
+        var heightValue = rowProps
+            ? rowProps["@_style:row-height"] ||
+                rowProps["@_style:min-row-height"] ||
+                rowProps["@_fo:min-height"] ||
+                rowProps["@_row-height"]
+            : undefined;
+        var visibility = rowProps
+            ? rowProps["@_style:visibility"] ||
+                rowProps["@_visibility"] ||
+                rowProps["@_fo:visibility"]
+            : undefined;
+        var height = this.convertLengthToPixels(heightValue);
+        var hidden = visibility === "collapse" ||
+            visibility === "hidden" ||
+            visibility === "none";
+        var format = this.normalizeCellFormat(this.convertToCellFormat(style));
+        if (height === undefined && !hidden && !format) {
+            return undefined;
+        }
+        return {
+            height: height,
+            hidden: hidden,
+            format: format,
+        };
+    };
+    OdsStyles.prototype.convertColumnStyle = function (style) {
+        var columnPropsNode = style["style:table-column-properties"] ||
+            style["table-column-properties"];
+        var columnProps = this.getAttributes(columnPropsNode);
+        var widthValue = columnProps
+            ? columnProps["@_style:column-width"] ||
+                columnProps["@_column-width"] ||
+                columnProps["@_fo:width"]
+            : undefined;
+        var visibility = columnProps
+            ? columnProps["@_style:visibility"] ||
+                columnProps["@_visibility"] ||
+                columnProps["@_fo:visibility"]
+            : undefined;
+        var width = this.convertLengthToPixels(widthValue);
+        var hidden = visibility === "collapse" ||
+            visibility === "hidden" ||
+            visibility === "none";
+        var format = this.normalizeCellFormat(this.convertToCellFormat(style));
+        if (width === undefined && !hidden && !format) {
+            return undefined;
+        }
+        return {
+            width: width,
+            hidden: hidden,
+            format: format,
+        };
+    };
+    OdsStyles.prototype.convertChartStyle = function (style) {
+        var graphicProps = style["style:graphic-properties"] || style["graphic-properties"];
+        var chartProps = style["style:chart-properties"] || style["chart:chart-properties"];
+        var dataPointProps = style["chart:data-point-properties"] || style["data-point-properties"];
+        return (this.extractChartColor(graphicProps) ||
+            this.extractChartColor(chartProps) ||
+            this.extractChartColor(dataPointProps));
+    };
+    OdsStyles.prototype.extractChartColor = function (node) {
+        var attrs = this.getNodeAttributes(node);
+        if (!attrs)
+            return undefined;
+        var rawValue = attrs["@_draw:fill-color"] ||
+            attrs["@_svg:fill-color"] ||
+            attrs["@_chart:color"] ||
+            attrs["@_fo:background-color"] ||
+            attrs["@_style:background-color"] ||
+            attrs["@_loext:fill-color"];
+        if (!rawValue || typeof rawValue !== "string") {
+            return undefined;
+        }
+        var normalized = rawValue.trim().toLowerCase();
+        if (!normalized || normalized === "none" || normalized === "transparent") {
+            return undefined;
+        }
+        return this.parseColor(rawValue);
+    };
+    OdsStyles.prototype.convertNumberStyleNode = function (node, kind) {
+        switch (kind) {
+            case "number": {
+                return {
+                    type: "NUMBER",
+                    pattern: this.buildNumberPattern(node),
+                };
+            }
+            case "currency": {
+                var symbolNode = this.first(this.toArray(node["number:currency-symbol"]));
+                var symbol = this.extractText(symbolNode) || "¤";
+                var position = (symbolNode === null || symbolNode === void 0 ? void 0 : symbolNode["@_number:position"]) ||
+                    (symbolNode === null || symbolNode === void 0 ? void 0 : symbolNode["@_style:position"]) ||
+                    (symbolNode === null || symbolNode === void 0 ? void 0 : symbolNode["@_position"]);
+                var usePrefix = position !== "after";
+                var pattern = this.buildNumberPattern(node, {
+                    prefix: usePrefix ? "".concat(symbol, " ") : undefined,
+                    suffix: !usePrefix ? " ".concat(symbol) : undefined,
+                    defaultFractionDigits: 2,
+                });
+                return {
+                    type: "CURRENCY",
+                    pattern: pattern,
+                };
+            }
+            case "percentage": {
+                return {
+                    type: "PERCENT",
+                    pattern: this.buildNumberPattern(node, { percent: true }),
+                };
+            }
+            case "scientific": {
+                return {
+                    type: "SCIENTIFIC",
+                    pattern: "0.00E+00",
+                };
+            }
+            case "date":
+            case "time":
+            case "date-time": {
+                var dateTime = this.buildDateTimePattern(node, kind);
+                if (!dateTime)
+                    return undefined;
+                return dateTime;
+            }
+            default:
+                return undefined;
+        }
+    };
+    OdsStyles.prototype.buildNumberPattern = function (node, options) {
+        var _a;
+        var numberNode = this.first(this.toArray(node["number:number"]));
+        var decimalsRaw = (numberNode === null || numberNode === void 0 ? void 0 : numberNode["@_number:decimal-places"]) ||
+            (numberNode === null || numberNode === void 0 ? void 0 : numberNode["@_decimal-places"]) ||
+            ((options === null || options === void 0 ? void 0 : options.defaultFractionDigits) !== undefined
+                ? String(options.defaultFractionDigits)
+                : "0");
+        var decimals = parseInt(decimalsRaw !== null && decimalsRaw !== void 0 ? decimalsRaw : "0", 10);
+        if (isNaN(decimals)) {
+            decimals = (_a = options === null || options === void 0 ? void 0 : options.defaultFractionDigits) !== null && _a !== void 0 ? _a : 0;
+        }
+        var groupingAttr = (numberNode === null || numberNode === void 0 ? void 0 : numberNode["@_number:grouping"]) || (numberNode === null || numberNode === void 0 ? void 0 : numberNode["@_grouping"]) || "true";
+        var grouping = groupingAttr !== "false";
+        var minIntegerDigits = Math.max(parseInt((numberNode === null || numberNode === void 0 ? void 0 : numberNode["@_number:min-integer-digits"]) ||
+            (numberNode === null || numberNode === void 0 ? void 0 : numberNode["@_min-integer-digits"]) ||
+            "1", 10) || 1, 1);
+        var integerPattern = grouping ? "#,##0" : "0".repeat(minIntegerDigits);
+        if (!integerPattern) {
+            integerPattern = "0";
+        }
+        var decimalPattern = decimals > 0 ? ".".concat("0".repeat(decimals)) : "";
+        var pattern = "".concat(integerPattern).concat(decimalPattern);
+        if (options === null || options === void 0 ? void 0 : options.percent) {
+            pattern = "".concat(pattern, "%");
+        }
+        if (options === null || options === void 0 ? void 0 : options.prefix) {
+            pattern = "".concat(options.prefix).concat(pattern);
+        }
+        if (options === null || options === void 0 ? void 0 : options.suffix) {
+            pattern = "".concat(pattern).concat(options.suffix);
+        }
+        return pattern || "0";
+    };
+    OdsStyles.prototype.buildDateTimePattern = function (node, kind) {
+        var dateParts = [];
+        if (node["number:year"]) {
+            dateParts.push("yyyy");
+        }
+        if (node["number:month"]) {
+            dateParts.push("mm");
+        }
+        if (node["number:day"]) {
+            dateParts.push("dd");
+        }
+        var timeParts = [];
+        if (node["number:hours"]) {
+            timeParts.push("hh");
+        }
+        if (node["number:minutes"]) {
+            timeParts.push("mm");
+        }
+        if (node["number:seconds"]) {
+            timeParts.push("ss");
+        }
+        var hasAmPm = Boolean(node["number:am-pm"]);
+        if (timeParts.length && hasAmPm) {
+            timeParts.push("AM/PM");
+        }
+        var parts = [];
+        if (dateParts.length) {
+            parts.push(dateParts.join("-"));
+        }
+        if (timeParts.length) {
+            var timePattern = timeParts.length > 1 && timeParts[timeParts.length - 1] === "AM/PM"
+                ? "".concat(timeParts.slice(0, -1).join(":"), " ").concat(timeParts[timeParts.length - 1])
+                : timeParts.join(":");
+            parts.push(timePattern);
+        }
+        var hasDate = dateParts.length > 0;
+        var hasTime = timeParts.length > 0;
+        var type = kind === "time" ? "TIME" : kind === "date-time" ? "DATE_TIME" : "DATE";
+        if (hasDate && hasTime) {
+            type = "DATE_TIME";
+        }
+        else if (hasTime && !hasDate) {
+            type = "TIME";
+        }
+        else {
+            type = "DATE";
+        }
+        var pattern = parts.join(" ").trim();
+        return {
+            type: type,
+            pattern: pattern || undefined,
+        };
+    };
+    OdsStyles.prototype.toArray = function (value) {
+        if (!value)
+            return [];
+        return Array.isArray(value) ? value : [value];
+    };
+    OdsStyles.prototype.first = function (value) {
+        return value && value.length ? value[0] : undefined;
+    };
+    OdsStyles.prototype.extractText = function (node) {
+        if (!node)
+            return undefined;
+        if (typeof node === "string")
+            return node;
+        if (Array.isArray(node)) {
+            return this.extractText(node[0]);
+        }
+        return node["#text"] || node["@_text"] || node._ || undefined;
+    };
+    OdsStyles.prototype.getAttributes = function (node) {
+        if (!node)
+            return undefined;
+        if (Array.isArray(node)) {
+            return node.length ? this.getAttributes(node[0]) : undefined;
+        }
+        return node[":@"] || node;
+    };
+    OdsStyles.prototype.createBorders = function (borderValue) {
+        var border = this.parseBorder(borderValue);
+        if (!border)
+            return undefined;
+        return {
+            top: border,
+            bottom: border,
+            left: border,
+            right: border,
+        };
+    };
+    OdsStyles.prototype.parseBorder = function (borderValue) {
+        var parts = borderValue.trim().split(/\s+/);
+        if (!parts.length)
+            return undefined;
+        var widthToken = parts.find(function (part) { return /\d/.test(part); });
+        var width = widthToken
+            ? parseFloat(widthToken.replace("pt", ""))
+            : undefined;
+        var styleToken = parts.find(function (part) {
+            return ["solid", "dotted", "dashed", "double"].includes(part.toLowerCase());
+        });
+        var colorToken = parts.find(function (part) { return part.startsWith("#"); });
+        var borderStyle = this.mapBorderStyle(styleToken, width);
+        if (!borderStyle)
+            return undefined;
+        return {
+            style: borderStyle,
+            width: this.mapBorderWidth(width),
+            color: colorToken ? this.parseColor(colorToken) : undefined,
+        };
+    };
+    OdsStyles.prototype.getNodeAttributes = function (node) {
+        if (!node)
+            return undefined;
+        if (Array.isArray(node)) {
+            return node.length ? this.getNodeAttributes(node[0]) : undefined;
+        }
+        return node[":@"] || node;
+    };
+    OdsStyles.prototype.parseColor = function (colorString) {
+        if (!colorString)
+            return "#000000";
+        if (colorString.startsWith("#")) {
+            return colorString.toUpperCase();
+        }
+        return colorString;
+    };
+    OdsStyles.prototype.mapBorderStyle = function (odsStyle, width) {
+        if (!odsStyle)
+            return undefined;
+        var normalized = odsStyle.toLowerCase();
+        if (normalized === "dotted")
+            return "dotted";
+        if (normalized === "dashed")
+            return "dashed";
+        if (normalized === "double")
+            return "double";
+        if (normalized === "solid") {
+            if (width && width >= 2)
+                return "solid_thick";
+            if (width && width >= 1)
+                return "solid_medium";
+            return "solid";
+        }
+        return "solid";
+    };
+    OdsStyles.prototype.mapBorderWidth = function (width) {
+        if (!width || isNaN(width))
+            return 1;
+        // Convert from pt to pixels approximately (1pt ≈ 1.333px)
+        return Math.max(1, Math.round(width * 1.333));
+    };
+    OdsStyles.prototype.convertLengthToPixels = function (length) {
+        if (!length)
+            return undefined;
+        var trimmed = length.trim();
+        var match = trimmed.match(/^(-?\d*\.?\d+)(cm|mm|in|inch|pt|px)$/i);
+        if (!match)
+            return undefined;
+        var value = parseFloat(match[1]);
+        var unit = match[2].toLowerCase();
+        if (unit === "px")
+            return value;
+        if (unit === "pt")
+            return value * (96 / 72);
+        if (unit === "cm")
+            return value * 37.7952755906;
+        if (unit === "mm")
+            return value * 3.77952755906;
+        if (unit === "in" || unit === "inch")
+            return value * 96;
+        return undefined;
+    };
+    return OdsStyles;
+}());
+export { OdsStyles };