@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,732 @@
+import { get } from "lodash-es";
+export class OdsStyles {
+    cellStyles = new Map();
+    automaticCellStyles = new Map();
+    rowStyles = new Map();
+    automaticRowStyles = new Map();
+    columnStyles = new Map();
+    automaticColumnStyles = new Map();
+    textStyles = new Map();
+    automaticTextStyles = new Map();
+    tableStyles = new Map();
+    automaticTableStyles = new Map();
+    numberFormats = new Map();
+    chartStyles = new Map();
+    constructor() { }
+    reset() {
+        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();
+    }
+    parseStylesXml(stylesXml) {
+        if (!stylesXml)
+            return;
+        const documentStyles = get(stylesXml, "office:document-styles") ||
+            get(stylesXml, "document-styles");
+        if (!documentStyles)
+            return;
+        const namedStyles = get(documentStyles, "office:styles.style:style") ||
+            get(documentStyles, "styles.style:style");
+        this.processStyles(namedStyles, false);
+        const 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"));
+    }
+    parseContentXml(contentXml) {
+        if (!contentXml)
+            return;
+        const autoStyles = get(contentXml, "office:document-content.office:automatic-styles.style:style") || get(contentXml, "document-content.automatic-styles.style");
+        this.processStyles(autoStyles, true);
+        const autoStylesContainer = get(contentXml, "office:document-content.office:automatic-styles") ||
+            get(contentXml, "document-content.automatic-styles");
+        this.processNumberStyles(contentXml, autoStylesContainer);
+    }
+    processStyles(styles, isAutomatic) {
+        if (!styles)
+            return;
+        const styleArray = Array.isArray(styles) ? styles : [styles];
+        for (const style of styleArray) {
+            const name = style["@_style:name"] || style["@_name"];
+            if (!name)
+                continue;
+            const family = style["@_style:family"] || style["@_family"];
+            if (family === "table-row") {
+                const props = this.convertRowStyle(style);
+                if (props) {
+                    (isAutomatic ? this.automaticRowStyles : this.rowStyles).set(name, props);
+                }
+                continue;
+            }
+            if (family === "table-column") {
+                const props = this.convertColumnStyle(style);
+                if (props) {
+                    (isAutomatic ? this.automaticColumnStyles : this.columnStyles).set(name, props);
+                }
+                continue;
+            }
+            if (family === "table") {
+                const format = this.normalizeCellFormat(this.convertToCellFormat(style));
+                if (format) {
+                    (isAutomatic ? this.automaticTableStyles : this.tableStyles).set(name, format);
+                }
+                continue;
+            }
+            if (family === "text") {
+                const format = this.normalizeCellFormat(this.convertToCellFormat(style));
+                (isAutomatic ? this.automaticTextStyles : this.textStyles).set(name, format);
+                continue;
+            }
+            if (family === "table-cell") {
+                const displayName = style["@_style:display-name"] || style["@_display-name"];
+                const key = displayName || name;
+                if (!key) {
+                    continue;
+                }
+                const targetMap = isAutomatic
+                    ? this.automaticCellStyles
+                    : this.cellStyles;
+                targetMap.set(key, style);
+                if (displayName && name && name !== key && !targetMap.has(name)) {
+                    targetMap.set(name, style);
+                }
+                continue;
+            }
+            if (typeof family === "string" &&
+                (family.startsWith("chart") || family === "graphic")) {
+                const color = this.convertChartStyle(style);
+                if (color) {
+                    const displayName = style["@_style:display-name"] || style["@_display-name"];
+                    const key = displayName || name;
+                    if (key) {
+                        this.chartStyles.set(key, color);
+                        if (displayName && name && name !== key) {
+                            this.chartStyles.set(name, color);
+                        }
+                    }
+                }
+                continue;
+            }
+        }
+    }
+    processNumberStyles(...containers) {
+        const 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" },
+        ];
+        for (const container of containers) {
+            if (!container)
+                continue;
+            for (const { key, kind } of definitions) {
+                const nodes = (container && container[key]) ??
+                    get(container, key) ??
+                    get(container, key.replace("number:", ""));
+                this.processNumberStyleNodes(nodes, kind);
+            }
+        }
+    }
+    processNumberStyleNodes(nodes, kind) {
+        if (!nodes)
+            return;
+        const arr = Array.isArray(nodes) ? nodes : [nodes];
+        for (const node of arr) {
+            if (!node)
+                continue;
+            const name = node["@_style:name"] || node["@_name"];
+            if (!name)
+                continue;
+            const numberFormat = this.convertNumberStyleNode(node, kind);
+            if (numberFormat) {
+                this.numberFormats.set(name, numberFormat);
+            }
+        }
+    }
+    getStyle(styleName) {
+        const style = this.automaticCellStyles.get(styleName) || this.cellStyles.get(styleName);
+        if (!style)
+            return undefined;
+        return this.convertToCellFormat(style);
+    }
+    getRowStyle(styleName) {
+        return (this.automaticRowStyles.get(styleName) || this.rowStyles.get(styleName));
+    }
+    getColumnStyle(styleName) {
+        return (this.automaticColumnStyles.get(styleName) ||
+            this.columnStyles.get(styleName));
+    }
+    getChartStyleColor(styleName) {
+        if (!styleName)
+            return undefined;
+        return this.chartStyles.get(styleName);
+    }
+    getTableCellFormat(styleName) {
+        return (this.automaticTableStyles.get(styleName) ||
+            this.tableStyles.get(styleName));
+    }
+    getTextFormat(styleName) {
+        if (!styleName)
+            return undefined;
+        const format = this.automaticTextStyles.get(styleName) || this.textStyles.get(styleName);
+        return format?.textFormat ?? undefined;
+    }
+    convertToCellFormat(style) {
+        const cellFormat = {};
+        const textPropsNode = style["style:text-properties"] || style["text-properties"];
+        const textProps = this.getAttributes(textPropsNode);
+        if (textProps) {
+            const textFormat = {};
+            const fontWeight = textProps["@_fo:font-weight"] || textProps["@_font-weight"];
+            if (fontWeight) {
+                const weight = parseInt(fontWeight, 10);
+                if (fontWeight === "bold" || (!isNaN(weight) && weight >= 700)) {
+                    textFormat.bold = true;
+                }
+            }
+            const fontStyle = textProps["@_fo:font-style"] || textProps["@_font-style"];
+            if (fontStyle === "italic") {
+                textFormat.italic = true;
+            }
+            const underline = textProps["@_style:text-underline-style"] ||
+                textProps["@_text-underline-style"];
+            if (underline && underline !== "none") {
+                textFormat.underline = true;
+            }
+            const color = textProps["@_fo:color"] || textProps["@_color"];
+            if (color) {
+                textFormat.color = this.parseColor(color);
+            }
+            const strike = textProps["@_style:text-line-through-style"] ||
+                textProps["@_text-line-through-style"];
+            if (strike && strike !== "none") {
+                textFormat.strikethrough = true;
+            }
+            const fontSize = textProps["@_fo:font-size"] || textProps["@_font-size"];
+            if (fontSize) {
+                textFormat.fontSize = parseFloat(fontSize);
+            }
+            const 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.
+            const textPosition = textProps["@_style:text-position"] || textProps["@_text-position"];
+            if (textPosition) {
+                const token = String(textPosition).trim().split(/\s+/)[0]?.toLowerCase();
+                if (token === "super") {
+                    textFormat.baselineOffset = "superscript";
+                }
+                else if (token === "sub") {
+                    textFormat.baselineOffset = "subscript";
+                }
+            }
+            if (Object.keys(textFormat).length > 0) {
+                cellFormat.textFormat = textFormat;
+            }
+        }
+        const cellPropsNode = style["style:table-cell-properties"] || style["table-cell-properties"];
+        const cellProps = this.getAttributes(cellPropsNode);
+        if (cellProps) {
+            const bgColor = cellProps["@_fo:background-color"] ||
+                cellProps["@_background-color"] ||
+                cellProps["@_draw:fill-color"];
+            if (bgColor && bgColor !== "transparent") {
+                cellFormat.backgroundColor = this.parseColor(bgColor);
+            }
+            const borderValue = cellProps["@_fo:border"] || cellProps["@_border"];
+            if (borderValue && borderValue !== "none") {
+                const borders = this.createBorders(borderValue);
+                if (borders) {
+                    cellFormat.borders = borders;
+                }
+            }
+            const 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"],
+                },
+            ];
+            for (const { key, value } of sideMap) {
+                if (!value || value === "none")
+                    continue;
+                const parsedBorder = this.parseBorder(value);
+                if (!parsedBorder)
+                    continue;
+                if (!cellFormat.borders) {
+                    cellFormat.borders = {};
+                }
+                cellFormat.borders[key] = parsedBorder;
+            }
+            // ODS diagonals: `style:diagonal-bl-tr` = bottom-left → top-right
+            // (= our diagonalUp). `style:diagonal-tl-br` = top-left → bottom-right
+            // (= our diagonalDown).
+            const 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"],
+                },
+            ];
+            for (const { key, value } of diagonalMap) {
+                if (!value || value === "none")
+                    continue;
+                const parsedBorder = this.parseBorder(value);
+                if (!parsedBorder)
+                    continue;
+                if (!cellFormat.borders) {
+                    cellFormat.borders = {};
+                }
+                cellFormat.borders[key] = parsedBorder;
+            }
+            const verticalAlign = cellProps["@_style:vertical-align"] ||
+                cellProps["@_vertical-align"] ||
+                cellProps["@_fo:vertical-align"];
+            if (verticalAlign) {
+                cellFormat.verticalAlignment =
+                    verticalAlign === "middle"
+                        ? "middle"
+                        : verticalAlign === "bottom"
+                            ? "bottom"
+                            : "top";
+            }
+            const cellTextAlign = cellProps["@_style:text-align"] ||
+                cellProps["@_text-align"] ||
+                cellProps["@_fo:text-align"];
+            const 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;
+            }
+            const wrapOption = cellProps["@_fo:wrap-option"] || cellProps["@_wrap-option"];
+            if (wrapOption === "wrap") {
+                cellFormat.wrapStrategy = "wrap";
+            }
+            const rotationAngle = cellProps["@_style:rotation-angle"] || cellProps["@_rotation-angle"];
+            if (rotationAngle !== undefined) {
+                const rotation = parseFloat(rotationAngle);
+                if (!isNaN(rotation)) {
+                    cellFormat.textRotation = rotation;
+                }
+            }
+        }
+        const paraPropsNode = style["style:paragraph-properties"] || style["paragraph-properties"];
+        const paraProps = this.getAttributes(paraPropsNode);
+        if (paraProps) {
+            const textAlign = paraProps["@_fo:text-align"] ||
+                paraProps["@_text-align"] ||
+                paraProps["@_style:text-align"];
+            const 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;
+            }
+        }
+        const dataStyleName = style["@_style:data-style-name"] || style["@_data-style-name"];
+        if (dataStyleName) {
+            const numberFormat = this.numberFormats.get(dataStyleName);
+            if (numberFormat) {
+                cellFormat.numberFormat = { ...numberFormat };
+            }
+        }
+        return cellFormat;
+    }
+    normalizeCellFormat(format) {
+        return Object.keys(format).length ? format : undefined;
+    }
+    convertRowStyle(style) {
+        const rowPropsNode = style["style:table-row-properties"] || style["table-row-properties"];
+        const rowProps = this.getAttributes(rowPropsNode);
+        const heightValue = rowProps
+            ? rowProps["@_style:row-height"] ||
+                rowProps["@_style:min-row-height"] ||
+                rowProps["@_fo:min-height"] ||
+                rowProps["@_row-height"]
+            : undefined;
+        const visibility = rowProps
+            ? rowProps["@_style:visibility"] ||
+                rowProps["@_visibility"] ||
+                rowProps["@_fo:visibility"]
+            : undefined;
+        const height = this.convertLengthToPixels(heightValue);
+        const hidden = visibility === "collapse" ||
+            visibility === "hidden" ||
+            visibility === "none";
+        const format = this.normalizeCellFormat(this.convertToCellFormat(style));
+        if (height === undefined && !hidden && !format) {
+            return undefined;
+        }
+        return {
+            height,
+            hidden,
+            format,
+        };
+    }
+    convertColumnStyle(style) {
+        const columnPropsNode = style["style:table-column-properties"] ||
+            style["table-column-properties"];
+        const columnProps = this.getAttributes(columnPropsNode);
+        const widthValue = columnProps
+            ? columnProps["@_style:column-width"] ||
+                columnProps["@_column-width"] ||
+                columnProps["@_fo:width"]
+            : undefined;
+        const visibility = columnProps
+            ? columnProps["@_style:visibility"] ||
+                columnProps["@_visibility"] ||
+                columnProps["@_fo:visibility"]
+            : undefined;
+        const width = this.convertLengthToPixels(widthValue);
+        const hidden = visibility === "collapse" ||
+            visibility === "hidden" ||
+            visibility === "none";
+        const format = this.normalizeCellFormat(this.convertToCellFormat(style));
+        if (width === undefined && !hidden && !format) {
+            return undefined;
+        }
+        return {
+            width,
+            hidden,
+            format,
+        };
+    }
+    convertChartStyle(style) {
+        const graphicProps = style["style:graphic-properties"] || style["graphic-properties"];
+        const chartProps = style["style:chart-properties"] || style["chart:chart-properties"];
+        const dataPointProps = style["chart:data-point-properties"] || style["data-point-properties"];
+        return (this.extractChartColor(graphicProps) ||
+            this.extractChartColor(chartProps) ||
+            this.extractChartColor(dataPointProps));
+    }
+    extractChartColor(node) {
+        const attrs = this.getNodeAttributes(node);
+        if (!attrs)
+            return undefined;
+        const 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;
+        }
+        const normalized = rawValue.trim().toLowerCase();
+        if (!normalized || normalized === "none" || normalized === "transparent") {
+            return undefined;
+        }
+        return this.parseColor(rawValue);
+    }
+    convertNumberStyleNode(node, kind) {
+        switch (kind) {
+            case "number": {
+                return {
+                    type: "NUMBER",
+                    pattern: this.buildNumberPattern(node),
+                };
+            }
+            case "currency": {
+                const symbolNode = this.first(this.toArray(node["number:currency-symbol"]));
+                const symbol = this.extractText(symbolNode) || "¤";
+                const position = symbolNode?.["@_number:position"] ||
+                    symbolNode?.["@_style:position"] ||
+                    symbolNode?.["@_position"];
+                const usePrefix = position !== "after";
+                const pattern = this.buildNumberPattern(node, {
+                    prefix: usePrefix ? `${symbol} ` : undefined,
+                    suffix: !usePrefix ? ` ${symbol}` : undefined,
+                    defaultFractionDigits: 2,
+                });
+                return {
+                    type: "CURRENCY",
+                    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": {
+                const dateTime = this.buildDateTimePattern(node, kind);
+                if (!dateTime)
+                    return undefined;
+                return dateTime;
+            }
+            default:
+                return undefined;
+        }
+    }
+    buildNumberPattern(node, options) {
+        const numberNode = this.first(this.toArray(node["number:number"]));
+        const decimalsRaw = numberNode?.["@_number:decimal-places"] ||
+            numberNode?.["@_decimal-places"] ||
+            (options?.defaultFractionDigits !== undefined
+                ? String(options.defaultFractionDigits)
+                : "0");
+        let decimals = parseInt(decimalsRaw ?? "0", 10);
+        if (isNaN(decimals)) {
+            decimals = options?.defaultFractionDigits ?? 0;
+        }
+        const groupingAttr = numberNode?.["@_number:grouping"] || numberNode?.["@_grouping"] || "true";
+        const grouping = groupingAttr !== "false";
+        const minIntegerDigits = Math.max(parseInt(numberNode?.["@_number:min-integer-digits"] ||
+            numberNode?.["@_min-integer-digits"] ||
+            "1", 10) || 1, 1);
+        let integerPattern = grouping ? "#,##0" : "0".repeat(minIntegerDigits);
+        if (!integerPattern) {
+            integerPattern = "0";
+        }
+        const decimalPattern = decimals > 0 ? `.${"0".repeat(decimals)}` : "";
+        let pattern = `${integerPattern}${decimalPattern}`;
+        if (options?.percent) {
+            pattern = `${pattern}%`;
+        }
+        if (options?.prefix) {
+            pattern = `${options.prefix}${pattern}`;
+        }
+        if (options?.suffix) {
+            pattern = `${pattern}${options.suffix}`;
+        }
+        return pattern || "0";
+    }
+    buildDateTimePattern(node, kind) {
+        const dateParts = [];
+        if (node["number:year"]) {
+            dateParts.push("yyyy");
+        }
+        if (node["number:month"]) {
+            dateParts.push("mm");
+        }
+        if (node["number:day"]) {
+            dateParts.push("dd");
+        }
+        const timeParts = [];
+        if (node["number:hours"]) {
+            timeParts.push("hh");
+        }
+        if (node["number:minutes"]) {
+            timeParts.push("mm");
+        }
+        if (node["number:seconds"]) {
+            timeParts.push("ss");
+        }
+        const hasAmPm = Boolean(node["number:am-pm"]);
+        if (timeParts.length && hasAmPm) {
+            timeParts.push("AM/PM");
+        }
+        const parts = [];
+        if (dateParts.length) {
+            parts.push(dateParts.join("-"));
+        }
+        if (timeParts.length) {
+            const timePattern = timeParts.length > 1 && timeParts[timeParts.length - 1] === "AM/PM"
+                ? `${timeParts.slice(0, -1).join(":")} ${timeParts[timeParts.length - 1]}`
+                : timeParts.join(":");
+            parts.push(timePattern);
+        }
+        const hasDate = dateParts.length > 0;
+        const hasTime = timeParts.length > 0;
+        let 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";
+        }
+        const pattern = parts.join(" ").trim();
+        return {
+            type,
+            pattern: pattern || undefined,
+        };
+    }
+    toArray(value) {
+        if (!value)
+            return [];
+        return Array.isArray(value) ? value : [value];
+    }
+    first(value) {
+        return value && value.length ? value[0] : undefined;
+    }
+    extractText(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;
+    }
+    getAttributes(node) {
+        if (!node)
+            return undefined;
+        if (Array.isArray(node)) {
+            return node.length ? this.getAttributes(node[0]) : undefined;
+        }
+        return node[":@"] || node;
+    }
+    createBorders(borderValue) {
+        const border = this.parseBorder(borderValue);
+        if (!border)
+            return undefined;
+        return {
+            top: border,
+            bottom: border,
+            left: border,
+            right: border,
+        };
+    }
+    parseBorder(borderValue) {
+        const parts = borderValue.trim().split(/\s+/);
+        if (!parts.length)
+            return undefined;
+        const widthToken = parts.find((part) => /\d/.test(part));
+        const width = widthToken
+            ? parseFloat(widthToken.replace("pt", ""))
+            : undefined;
+        const styleToken = parts.find((part) => ["solid", "dotted", "dashed", "double"].includes(part.toLowerCase()));
+        const colorToken = parts.find((part) => part.startsWith("#"));
+        const borderStyle = this.mapBorderStyle(styleToken, width);
+        if (!borderStyle)
+            return undefined;
+        return {
+            style: borderStyle,
+            width: this.mapBorderWidth(width),
+            color: colorToken ? this.parseColor(colorToken) : undefined,
+        };
+    }
+    getNodeAttributes(node) {
+        if (!node)
+            return undefined;
+        if (Array.isArray(node)) {
+            return node.length ? this.getNodeAttributes(node[0]) : undefined;
+        }
+        return node[":@"] || node;
+    }
+    parseColor(colorString) {
+        if (!colorString)
+            return "#000000";
+        if (colorString.startsWith("#")) {
+            return colorString.toUpperCase();
+        }
+        return colorString;
+    }
+    mapBorderStyle(odsStyle, width) {
+        if (!odsStyle)
+            return undefined;
+        const 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";
+    }
+    mapBorderWidth(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));
+    }
+    convertLengthToPixels(length) {
+        if (!length)
+            return undefined;
+        const trimmed = length.trim();
+        const match = trimmed.match(/^(-?\d*\.?\d+)(cm|mm|in|inch|pt|px)$/i);
+        if (!match)
+            return undefined;
+        const value = parseFloat(match[1]);
+        const 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;
+    }
+}