npm - @cj-tech-master/excelts - Versions diffs - 9.5.4 → 9.5.5 - Mend

@cj-tech-master/excelts 9.5.4 → 9.5.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (767) hide show

package/dist/cjs/modules/word/convert/html/html-import.js ADDED Viewed

@@ -0,0 +1,1910 @@
+"use strict";
+/**
+ * DOCX Module - HTML to DOCX Converter
+ *
+ * Converts an HTML string into DOCX document body content (paragraphs, tables, etc.).
+ * Handles common HTML elements: p, h1-h6, strong, em, a, ul, ol, li, table, img, br, span.
+ *
+ * This is NOT a full HTML rendering engine — it covers the structural elements
+ * that map cleanly to WordprocessingML concepts.
+ *
+ * @example
+ * ```ts
+ * import { htmlToDocxBody } from "excelts/word/html";
+ * import { Document, toBuffer } from "excelts/word";
+ *
+ * const body = htmlToDocxBody("<h1>Hello</h1><p>World</p>");
+ * const h = Document.create();
+ * for (const block of body) {
+ *   Document.addBodyContent(h, block);
+ * }
+ * const buffer = await toBuffer(Document.build(h));
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlToDocxBody = htmlToDocxBody;
+const internal_utils_1 = require("../../core/internal-utils");
+const units_1 = require("../../units");
+/**
+ * Convert an HTML string into an array of DOCX body content blocks.
+ *
+ * Supported elements:
+ * - Block: p, div, h1-h6, blockquote, pre, hr
+ * - List: ul, ol, li
+ * - Table: table, thead, tbody, tr, th, td (colspan, rowspan, border styles)
+ * - Inline: strong/b, em/i, u, s/strike/del, a, br, span, sub, sup, code
+ * - Images: img (base64 data URLs as InlineImageContent, http(s) as placeholder)
+ * - Page break: div with style="page-break-before: always" or class="page-break"
+ * - CSS inline styles: font-family, font-size, color, background-color, font-weight,
+ *   font-style, text-decoration, text-align
+ *
+ * @param html - The HTML string to convert.
+ * @param options - Optional conversion settings.
+ * @returns Array of BodyContent blocks.
+ */
+function htmlToDocxBody(html, options) {
+    const blocks = [];
+    const tokens = tokenize(html);
+    // Extract <style> rules and merge with user-provided classStyles
+    const extractedStyles = extractStyleRules(tokens);
+    const classStyles = {
+        ...extractedStyles,
+        ...(options?.classStyles ?? {})
+    };
+    // Seed the inline context with the caller-supplied defaults so plain text
+    // runs actually carry the requested font/size. Without this the options
+    // were effectively ignored.
+    const initialCtx = {};
+    if (options?.defaultFont) {
+        initialCtx.fontFamily = options.defaultFont;
+    }
+    if (options?.defaultFontSize !== undefined) {
+        initialCtx.fontSize = options.defaultFontSize;
+    }
+    parseBlocks(tokens, 0, blocks, initialCtx, classStyles);
+    return blocks;
+}
+function tokenize(html) {
+    const tokens = [];
+    // Strip HTML comments, doctype declarations and SGML processing
+    // instructions before tokenising — none of them should appear as text
+    // in the document body. The previous regex treated `<!doctype html>`
+    // as a text node containing `"!doctype html>"`.
+    const stripped = html
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/<!doctype[^>]*>/gi, "")
+        .replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "")
+        .replace(/<\?[\s\S]*?\?>/g, "");
+    // Match a tag, OR a run of text. Text is anything-up-to-the-next-tag,
+    // with the addition that a `<` not followed by a tag-like character is
+    // treated as literal text (so "1 < 2" / "a<b" / "<<" survive instead
+    // of being silently swallowed).
+    const re = /<\/?([a-zA-Z][a-zA-Z0-9]*)((?:\s+[^>]*?)?)\/?\s*>|((?:[^<]|<(?![/a-zA-Z]))+)/g;
+    const tagRe = /^<(\/?)([a-zA-Z][a-zA-Z0-9]*)((?:\s+[^>]*?)?)(\/?)\s*>$/;
+    let m;
+    while ((m = re.exec(stripped)) !== null) {
+        const fullMatch = m[0];
+        if (m[3] !== undefined) {
+            // Text node
+            const text = decodeHtmlEntities(m[3]);
+            if (text) {
+                tokens.push({ type: "text", value: text });
+            }
+        }
+        else {
+            const tagMatch = tagRe.exec(fullMatch);
+            if (tagMatch) {
+                const isClose = tagMatch[1] === "/";
+                const tag = tagMatch[2].toLowerCase();
+                const attrStr = tagMatch[3];
+                const selfClose = tagMatch[4] === "/" || VOID_ELEMENTS.has(tag);
+                const attrs = parseHtmlAttrs(attrStr);
+                if (isClose) {
+                    tokens.push({ type: "close", tag, attrs: {} });
+                }
+                else if (selfClose) {
+                    tokens.push({ type: "selfclose", tag, attrs });
+                }
+                else {
+                    tokens.push({ type: "open", tag, attrs });
+                    // Raw-text elements: their body must not be parsed as markup. Skip
+                    // forward to the matching close tag and either capture the body as
+                    // a single text token (for <style>, which is post-processed by
+                    // extractStyleRules) or discard it entirely (for <script>, etc.).
+                    // Without this, embedded scripts would leak into the document body.
+                    if (RAW_TEXT_ELEMENTS.has(tag)) {
+                        const closeRe = new RegExp(`</${tag}\\s*>`, "i");
+                        closeRe.lastIndex = re.lastIndex;
+                        const startBody = re.lastIndex;
+                        const closeMatch = closeRe.exec(stripped);
+                        if (closeMatch) {
+                            const body = stripped.slice(startBody, closeMatch.index);
+                            if (RAW_TEXT_PRESERVE_BODY.has(tag)) {
+                                tokens.push({ type: "text", value: body });
+                            }
+                            tokens.push({ type: "close", tag, attrs: {} });
+                            re.lastIndex = closeMatch.index + closeMatch[0].length;
+                        }
+                        else {
+                            // No closing tag — discard the rest of the input for this
+                            // raw-text element to avoid emitting markup as text.
+                            re.lastIndex = stripped.length;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return tokens;
+}
+/**
+ * HTML elements whose body is not parsed as markup. Their content is either
+ * preserved (style) for downstream processing or discarded entirely.
+ */
+const RAW_TEXT_ELEMENTS = new Set([
+    "script",
+    "style",
+    "noscript",
+    "iframe",
+    "noframes",
+    "textarea",
+    "title"
+]);
+/** Subset of RAW_TEXT_ELEMENTS whose body is kept (as a single text token). */
+const RAW_TEXT_PRESERVE_BODY = new Set(["style"]);
+const VOID_ELEMENTS = new Set([
+    "br",
+    "hr",
+    "img",
+    "input",
+    "col",
+    "area",
+    "base",
+    "link",
+    "meta",
+    "source",
+    "wbr"
+]);
+/**
+ * Extract simple class rules from `<style>` tokens in the token stream.
+ * Only supports simple selectors: `.className { property: value; ... }`
+ * Does not support nested rules, media queries, pseudo-classes, combinators, etc.
+ * Returns a map of className → inline style string.
+ */
+function extractStyleRules(tokens) {
+    const result = {};
+    let i = 0;
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (tok.type === "open" && tok.tag === "style") {
+            // Collect text content until </style>
+            let cssText = "";
+            i++;
+            while (i < tokens.length) {
+                const inner = tokens[i];
+                if (inner.type === "close" && inner.tag === "style") {
+                    i++;
+                    break;
+                }
+                if (inner.type === "text") {
+                    cssText += inner.value;
+                }
+                i++;
+            }
+            // Parse simple class rules: .className { ... }
+            const ruleRe = /\.([a-zA-Z_][\w-]*)\s*\{([^}]*)\}/g;
+            let ruleMatch;
+            while ((ruleMatch = ruleRe.exec(cssText)) !== null) {
+                const className = ruleMatch[1];
+                const body = ruleMatch[2].trim();
+                if (body && !result[className]) {
+                    result[className] = body;
+                }
+            }
+            continue;
+        }
+        i++;
+    }
+    return result;
+}
+function parseHtmlAttrs(str) {
+    const attrs = {};
+    const re = /([a-zA-Z_][\w-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+    let m;
+    while ((m = re.exec(str)) !== null) {
+        attrs[m[1].toLowerCase()] = m[2] ?? m[3] ?? m[4] ?? "";
+    }
+    return attrs;
+}
+function decodeHtmlEntities(text) {
+    return text
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, "\u00A0")
+        .replace(/&#(\d+);/g, (_, n) => safeFromCodePoint(parseInt(n, 10)))
+        .replace(/&#x([a-fA-F0-9]+);/g, (_, n) => safeFromCodePoint(parseInt(n, 16)))
+        .replace(/&([a-zA-Z]+);/g, (match, name) => HTML_ENTITIES[name] ?? match);
+}
+/**
+ * Convert a numeric character reference to a string. Uses fromCodePoint so
+ * astral characters (e.g. emoji like &#128512;) are encoded as a proper
+ * surrogate pair instead of a single invalid UTF-16 unit. Out-of-range or
+ * non-finite values fall back to the Unicode replacement character.
+ */
+function safeFromCodePoint(cp) {
+    if (!Number.isFinite(cp) || cp < 0 || cp > 0x10ffff) {
+        return "\uFFFD";
+    }
+    // Surrogate halves are not valid scalar values.
+    if (cp >= 0xd800 && cp <= 0xdfff) {
+        return "\uFFFD";
+    }
+    return String.fromCodePoint(cp);
+}
+/** Common HTML named entities mapped to their Unicode characters. */
+const HTML_ENTITIES = {
+    // Punctuation & Typography
+    mdash: "\u2014",
+    ndash: "\u2013",
+    hellip: "\u2026",
+    laquo: "\u00AB",
+    raquo: "\u00BB",
+    lsquo: "\u2018",
+    rsquo: "\u2019",
+    ldquo: "\u201C",
+    rdquo: "\u201D",
+    sbquo: "\u201A",
+    bdquo: "\u201E",
+    bull: "\u2022",
+    middot: "\u00B7",
+    prime: "\u2032",
+    Prime: "\u2033",
+    oline: "\u203E",
+    iquest: "\u00BF",
+    iexcl: "\u00A1",
+    sect: "\u00A7",
+    para: "\u00B6",
+    dagger: "\u2020",
+    Dagger: "\u2021",
+    permil: "\u2030",
+    // Symbols & Legal
+    copy: "\u00A9",
+    reg: "\u00AE",
+    trade: "\u2122",
+    // Math & Science
+    deg: "\u00B0",
+    plusmn: "\u00B1",
+    times: "\u00D7",
+    divide: "\u00F7",
+    minus: "\u2212",
+    lowast: "\u2217",
+    radic: "\u221A",
+    infin: "\u221E",
+    sum: "\u2211",
+    prod: "\u220F",
+    int: "\u222B",
+    part: "\u2202",
+    nabla: "\u2207",
+    ne: "\u2260",
+    equiv: "\u2261",
+    asymp: "\u2248",
+    le: "\u2264",
+    ge: "\u2265",
+    sub: "\u2282",
+    sup: "\u2283",
+    nsub: "\u2284",
+    sube: "\u2286",
+    supe: "\u2287",
+    oplus: "\u2295",
+    otimes: "\u2297",
+    perp: "\u22A5",
+    and: "\u2227",
+    or: "\u2228",
+    not: "\u00AC",
+    exist: "\u2203",
+    forall: "\u2200",
+    empty: "\u2205",
+    isin: "\u2208",
+    notin: "\u2209",
+    ni: "\u220B",
+    there4: "\u2234",
+    sim: "\u223C",
+    cong: "\u2245",
+    prop: "\u221D",
+    // Currency
+    euro: "\u20AC",
+    pound: "\u00A3",
+    yen: "\u00A5",
+    cent: "\u00A2",
+    curren: "\u00A4",
+    fnof: "\u0192",
+    // Greek letters (lowercase)
+    alpha: "\u03B1",
+    beta: "\u03B2",
+    gamma: "\u03B3",
+    delta: "\u03B4",
+    epsilon: "\u03B5",
+    zeta: "\u03B6",
+    eta: "\u03B7",
+    theta: "\u03B8",
+    iota: "\u03B9",
+    kappa: "\u03BA",
+    lambda: "\u03BB",
+    mu: "\u03BC",
+    nu: "\u03BD",
+    xi: "\u03BE",
+    omicron: "\u03BF",
+    pi: "\u03C0",
+    rho: "\u03C1",
+    sigma: "\u03C3",
+    tau: "\u03C4",
+    upsilon: "\u03C5",
+    phi: "\u03C6",
+    chi: "\u03C7",
+    psi: "\u03C8",
+    omega: "\u03C9",
+    // Greek letters (uppercase)
+    Alpha: "\u0391",
+    Beta: "\u0392",
+    Gamma: "\u0393",
+    Delta: "\u0394",
+    Epsilon: "\u0395",
+    Zeta: "\u0396",
+    Eta: "\u0397",
+    Theta: "\u0398",
+    Iota: "\u0399",
+    Kappa: "\u039A",
+    Lambda: "\u039B",
+    Mu: "\u039C",
+    Nu: "\u039D",
+    Xi: "\u039E",
+    Omicron: "\u039F",
+    Pi: "\u03A0",
+    Rho: "\u03A1",
+    Sigma: "\u03A3",
+    Tau: "\u03A4",
+    Upsilon: "\u03A5",
+    Phi: "\u03A6",
+    Chi: "\u03A7",
+    Psi: "\u03A8",
+    Omega: "\u03A9",
+    // Arrows
+    larr: "\u2190",
+    uarr: "\u2191",
+    rarr: "\u2192",
+    darr: "\u2193",
+    harr: "\u2194",
+    lArr: "\u21D0",
+    uArr: "\u21D1",
+    rArr: "\u21D2",
+    dArr: "\u21D3",
+    hArr: "\u21D4",
+    crarr: "\u21B5",
+    // Fractions
+    frac12: "\u00BD",
+    frac14: "\u00BC",
+    frac34: "\u00BE",
+    frac13: "\u2153",
+    frac23: "\u2154",
+    frac15: "\u2155",
+    frac18: "\u215B",
+    frac38: "\u215C",
+    frac58: "\u215D",
+    frac78: "\u215E",
+    // Spaces
+    ensp: "\u2002",
+    emsp: "\u2003",
+    thinsp: "\u2009",
+    zwnj: "\u200C",
+    zwj: "\u200D",
+    lrm: "\u200E",
+    rlm: "\u200F",
+    // Misc Symbols
+    spades: "\u2660",
+    clubs: "\u2663",
+    hearts: "\u2665",
+    diams: "\u2666",
+    loz: "\u25CA",
+    circ: "\u02C6",
+    tilde: "\u02DC",
+    shy: "\u00AD",
+    macr: "\u00AF",
+    acute: "\u00B4",
+    cedil: "\u00B8",
+    micro: "\u00B5",
+    sup1: "\u00B9",
+    sup2: "\u00B2",
+    sup3: "\u00B3",
+    ordf: "\u00AA",
+    ordm: "\u00BA"
+};
+/** Parse a CSS inline style string into structured values. */
+function parseCssStyle(styleStr) {
+    const result = {};
+    if (!styleStr) {
+        return result;
+    }
+    const declarations = styleStr.split(";");
+    for (const decl of declarations) {
+        const colonIdx = decl.indexOf(":");
+        if (colonIdx < 0) {
+            continue;
+        }
+        const prop = decl.slice(0, colonIdx).trim().toLowerCase();
+        const value = decl
+            .slice(colonIdx + 1)
+            .trim()
+            .toLowerCase();
+        switch (prop) {
+            case "font-family":
+                result.fontFamily = parseFontFamily(value);
+                break;
+            case "font-size":
+                result.fontSize = parseFontSize(value);
+                break;
+            case "color":
+                result.color = parseCssColor(value);
+                break;
+            case "background-color":
+                result.backgroundColor = parseCssColor(value);
+                break;
+            case "font-weight":
+                if (value === "bold" || value === "bolder" || parseInt(value, 10) >= 700) {
+                    result.bold = true;
+                }
+                break;
+            case "font-style":
+                if (value === "italic" || value === "oblique") {
+                    result.italic = true;
+                }
+                break;
+            case "text-decoration":
+            case "text-decoration-line":
+                if (value.includes("underline")) {
+                    result.underline = true;
+                }
+                if (value.includes("line-through")) {
+                    result.lineThrough = true;
+                }
+                break;
+            case "text-align":
+                if (value === "left" || value === "start") {
+                    result.textAlign = "left";
+                }
+                else if (value === "center") {
+                    result.textAlign = "center";
+                }
+                else if (value === "right" || value === "end") {
+                    result.textAlign = "right";
+                }
+                else if (value === "justify") {
+                    result.textAlign = "both";
+                }
+                break;
+            case "page-break-before":
+                if (value === "always") {
+                    result.pageBreakBefore = true;
+                }
+                break;
+            case "margin-left": {
+                const twips = parseLengthToTwips(value);
+                if (twips !== undefined) {
+                    result.marginLeft = twips;
+                }
+                break;
+            }
+            case "line-height": {
+                const spacing = parseLineHeight(value);
+                if (spacing !== undefined) {
+                    result.lineHeight = spacing;
+                }
+                break;
+            }
+            case "border": {
+                // Shorthand: border: 1px solid black
+                const parts = value.split(/\s+/);
+                for (const part of parts) {
+                    if (/^\d/.test(part)) {
+                        result.borderWidth = parseBorderWidth(part);
+                    }
+                    else if (isBorderStyleKeyword(part)) {
+                        result.borderStyle = part;
+                    }
+                    else {
+                        const c = parseCssColor(part);
+                        if (c) {
+                            result.borderColor = c;
+                        }
+                    }
+                }
+                break;
+            }
+            case "border-style":
+                result.borderStyle = value.split(/\s+/)[0];
+                break;
+            case "border-width":
+                result.borderWidth = parseBorderWidth(value.split(/\s+/)[0]);
+                break;
+            case "border-color": {
+                const c = parseCssColor(value.split(/\s+/)[0]);
+                if (c) {
+                    result.borderColor = c;
+                }
+                break;
+            }
+            case "width": {
+                const twips = parseLengthToTwips(value);
+                if (twips !== undefined) {
+                    result.width = twips;
+                }
+                break;
+            }
+        }
+    }
+    return result;
+}
+/** Extract the first font-family name from a CSS font-family value. */
+function parseFontFamily(value) {
+    // Take the original (non-lowercased) value for font names — but our parser
+    // already lowered it. We'll capitalize for common fonts. Instead, let's
+    // just strip quotes and return as-is (already lowered).
+    // Actually we need the original casing. Let's re-parse from the raw value.
+    // Since we already lowercased, we'll just clean it up:
+    const first = value.split(",")[0].trim();
+    // Remove quotes
+    const cleaned = first.replace(/["']/g, "").trim();
+    // Capitalize each word for display
+    return cleaned
+        .split(/\s+/)
+        .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+}
+/** Parse CSS font-size into half-points. */
+function parseFontSize(value) {
+    // Support px, pt, em, rem
+    const match = /^([\d.]+)\s*(px|pt|em|rem)?$/.exec(value);
+    if (!match) {
+        return undefined;
+    }
+    const num = parseFloat(match[1]);
+    const unit = match[2] || "px";
+    switch (unit) {
+        case "pt":
+            return Math.round(num * 2); // half-points
+        case "px":
+            // 1px ≈ 0.75pt
+            return Math.round(num * 0.75 * 2);
+        case "em":
+        case "rem":
+            // Assume 1em = 12pt = 24 half-points
+            return Math.round(num * 24);
+        default:
+            return undefined;
+    }
+}
+/** Parse a CSS color value into a 6-digit hex string (without #). */
+function parseCssColor(value) {
+    // #RGB or #RRGGBB
+    if (value.startsWith("#")) {
+        const hex = value.slice(1);
+        if (hex.length === 3) {
+            return hex
+                .split("")
+                .map(c => c + c)
+                .join("")
+                .toUpperCase();
+        }
+        if (hex.length === 6) {
+            return hex.toUpperCase();
+        }
+        return undefined;
+    }
+    // rgb(r, g, b) or rgba(r, g, b, a)
+    const rgbMatch = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/.exec(value);
+    if (rgbMatch) {
+        const r = Math.min(255, parseInt(rgbMatch[1], 10));
+        const g = Math.min(255, parseInt(rgbMatch[2], 10));
+        const b = Math.min(255, parseInt(rgbMatch[3], 10));
+        return (r.toString(16).padStart(2, "0") +
+            g.toString(16).padStart(2, "0") +
+            b.toString(16).padStart(2, "0")).toUpperCase();
+    }
+    // Named colors (common subset)
+    const named = CSS_NAMED_COLORS[value];
+    if (named) {
+        return named;
+    }
+    return undefined;
+}
+/** Common CSS named colors mapped to hex. */
+const CSS_NAMED_COLORS = {
+    black: "000000",
+    white: "FFFFFF",
+    red: "FF0000",
+    green: "008000",
+    blue: "0000FF",
+    yellow: "FFFF00",
+    cyan: "00FFFF",
+    magenta: "FF00FF",
+    gray: "808080",
+    grey: "808080",
+    silver: "C0C0C0",
+    maroon: "800000",
+    olive: "808000",
+    lime: "00FF00",
+    aqua: "00FFFF",
+    teal: "008080",
+    navy: "000080",
+    fuchsia: "FF00FF",
+    purple: "800080",
+    orange: "FFA500",
+    pink: "FFC0CB",
+    brown: "A52A2A",
+    coral: "FF7F50",
+    crimson: "DC143C",
+    darkblue: "00008B",
+    darkgreen: "006400",
+    darkred: "8B0000",
+    gold: "FFD700",
+    indigo: "4B0082",
+    ivory: "FFFFF0",
+    khaki: "F0E68C",
+    lavender: "E6E6FA",
+    lightblue: "ADD8E6",
+    lightgray: "D3D3D3",
+    lightgrey: "D3D3D3",
+    lightgreen: "90EE90",
+    lightyellow: "FFFFE0",
+    darkgray: "A9A9A9",
+    darkgrey: "A9A9A9",
+    dimgray: "696969",
+    dimgrey: "696969",
+    tomato: "FF6347",
+    violet: "EE82EE",
+    wheat: "F5DEB3"
+};
+/** Parse a CSS length value (px, pt, in, cm, mm) into twips. 1 inch = 1440 twips. */
+function parseLengthToTwips(value) {
+    const match = /^([\d.]+)\s*(px|pt|in|cm|mm|em|rem)?$/.exec(value);
+    if (!match) {
+        return undefined;
+    }
+    const num = parseFloat(match[1]);
+    const unit = match[2] || "px";
+    switch (unit) {
+        case "pt":
+            return Math.round(num * 20); // 1pt = 20 twips
+        case "px":
+            return Math.round(num * 15); // 1px ≈ 0.75pt ≈ 15 twips
+        case "in":
+            return Math.round(num * 1440); // 1in = 1440 twips
+        case "cm":
+            return Math.round(num * 567); // 1cm ≈ 567 twips
+        case "mm":
+            return Math.round(num * 56.7); // 1mm ≈ 56.7 twips
+        case "em":
+        case "rem":
+            // Assume 1em = 12pt = 240 twips
+            return Math.round(num * 240);
+        default:
+            return undefined;
+    }
+}
+/** Parse CSS line-height into 240ths of a line for WordprocessingML spacing. */
+function parseLineHeight(value) {
+    // Unitless number: e.g., "1.5" means 1.5 lines → 360 (240 * 1.5)
+    const unitlessMatch = /^([\d.]+)$/.exec(value);
+    if (unitlessMatch) {
+        const num = parseFloat(unitlessMatch[1]);
+        return Math.round(num * 240);
+    }
+    // Percentage: e.g., "150%" means 1.5 lines → 360
+    const percentMatch = /^([\d.]+)%$/.exec(value);
+    if (percentMatch) {
+        const num = parseFloat(percentMatch[1]);
+        return Math.round((num / 100) * 240);
+    }
+    // With units (px, pt): convert to twips and use "exact" style — but the "auto" rule
+    // uses 240ths of a line, so we approximate with the unitless conversion
+    const unitMatch = /^([\d.]+)\s*(px|pt|em|rem)$/.exec(value);
+    if (unitMatch) {
+        const num = parseFloat(unitMatch[1]);
+        const unit = unitMatch[2];
+        switch (unit) {
+            case "pt":
+                // Convert pt to 240ths of a line: 12pt = 240 (single line)
+                return Math.round((num / 12) * 240);
+            case "px":
+                // 1px ≈ 0.75pt; 16px ≈ 12pt = single
+                return Math.round(((num * 0.75) / 12) * 240);
+            case "em":
+            case "rem":
+                return Math.round(num * 240);
+        }
+    }
+    return undefined;
+}
+const _BLOCK_TAGS = new Set([
+    "p",
+    "div",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "blockquote",
+    "pre",
+    "li",
+    "dt",
+    "dd",
+    "dl",
+    "section",
+    "article",
+    "main",
+    "aside",
+    "header",
+    "footer",
+    "figure",
+    "figcaption",
+    "details",
+    "summary",
+    "address"
+]);
+function parseBlocks(tokens, start, blocks, parentCtx, classStyles) {
+    let i = start;
+    let pendingInline;
+    const flushPending = () => {
+        if (pendingInline && pendingInline.runs.length > 0) {
+            blocks.push({
+                type: "paragraph",
+                children: pendingInline.runs
+            });
+        }
+        pendingInline = undefined;
+    };
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (tok.type === "close") {
+            flushPending();
+            return i + 1; // consumed the close tag
+        }
+        if (tok.type === "text") {
+            if (!pendingInline) {
+                pendingInline = { runs: [], ctx: parentCtx };
+            }
+            const run = makeRun(tok.value, parentCtx);
+            pendingInline.runs.push(run);
+            i++;
+            continue;
+        }
+        // Open or self-close tag
+        const tag = tok.type === "open" || tok.type === "selfclose" ? tok.tag : "";
+        // Document scaffolding (<html>, <body>) is transparent — descend into
+        // its children. <head> and its leaf children carry no body-text and
+        // are skipped entirely so their whitespace/newlines don't leak as
+        // empty paragraphs into the document.
+        if (tag === "html" || tag === "body") {
+            if (tok.type === "open") {
+                flushPending();
+                i = parseBlocks(tokens, i + 1, blocks, parentCtx, classStyles);
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (tag === "head") {
+            // Fast-forward to </head>; ignore everything in between (titles,
+            // meta, link, etc.). <style> bodies were already extracted by
+            // tokenize+extractStyleRules and stripped from the token stream
+            // through RAW_TEXT_ELEMENTS handling.
+            if (tok.type === "open") {
+                let depth = 1;
+                i++;
+                while (i < tokens.length && depth > 0) {
+                    const t = tokens[i];
+                    if (t.type === "open" && t.tag === "head") {
+                        depth++;
+                    }
+                    else if (t.type === "close" && t.tag === "head") {
+                        depth--;
+                    }
+                    i++;
+                }
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (tag === "title" || tag === "meta" || tag === "link" || tag === "base") {
+            // Should never reach here because <head> handler swallows them, but
+            // guard against malformed HTML where they appear at body level.
+            if (tok.type === "open") {
+                let depth = 1;
+                i++;
+                while (i < tokens.length && depth > 0) {
+                    const t = tokens[i];
+                    if (t.type === "open" && t.tag === tag) {
+                        depth++;
+                    }
+                    else if (t.type === "close" && t.tag === tag) {
+                        depth--;
+                    }
+                    i++;
+                }
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (tag === "br") {
+            if (!pendingInline) {
+                pendingInline = { runs: [], ctx: parentCtx };
+            }
+            pendingInline.runs.push({ content: [{ type: "break" }] });
+            i++;
+            continue;
+        }
+        if (tag === "hr") {
+            flushPending();
+            blocks.push({
+                type: "paragraph",
+                properties: {
+                    borders: {
+                        bottom: { style: "single", size: 6, space: 1, color: "auto" }
+                    }
+                },
+                children: []
+            });
+            i++;
+            continue;
+        }
+        // Headings
+        if (/^h[1-6]$/.test(tag)) {
+            flushPending();
+            const level = parseInt(tag[1], 10);
+            const style = parseCssStyle(resolveEffectiveStyle(tok.attrs, classStyles));
+            const children = [];
+            const headingCtx = { ...parentCtx, bold: true };
+            applyCssToInlineContext(headingCtx, style);
+            i = parseInlines(tokens, i + 1, children, headingCtx, tag, classStyles);
+            const props = {
+                style: `Heading${level}`,
+                ...(style.textAlign ? { alignment: style.textAlign } : {})
+            };
+            if (style.marginLeft !== undefined) {
+                props.indent = { left: style.marginLeft };
+            }
+            if (style.lineHeight !== undefined) {
+                props.spacing = { line: style.lineHeight, lineRule: "auto" };
+            }
+            blocks.push({
+                type: "paragraph",
+                properties: props,
+                children
+            });
+            continue;
+        }
+        // Page-break detection: <div style="page-break-before: always"> or <div class="page-break">
+        if (tag === "div" && tok.type === "open") {
+            const attrs = tok.attrs;
+            const style = parseCssStyle(resolveEffectiveStyle(attrs, classStyles));
+            const hasPageBreakClass = (attrs["class"] || "").split(/\s+/).includes("page-break");
+            if (style.pageBreakBefore || hasPageBreakClass) {
+                flushPending();
+                // Emit a page break paragraph
+                blocks.push({
+                    type: "paragraph",
+                    children: [{ content: [{ type: "break", breakType: "page" }] }]
+                });
+                // Continue parsing the div's children as normal content
+                i = parseBlocks(tokens, i + 1, blocks, parentCtx, classStyles);
+                continue;
+            }
+        }
+        // Paragraph-like blocks
+        if (tag === "p" || tag === "div" || tag === "blockquote" || tag === "pre" || tag === "aside") {
+            flushPending();
+            const attrs = tok.attrs;
+            const style = parseCssStyle(resolveEffectiveStyle(attrs, classStyles));
+            const children = [];
+            const ctx = tag === "pre" ? { ...parentCtx, code: true } : { ...parentCtx };
+            applyCssToInlineContext(ctx, style);
+            i = parseInlines(tokens, i + 1, children, ctx, tag, classStyles);
+            const props = {};
+            if (tag === "blockquote" || tag === "aside") {
+                props.indent = { left: 720 }; // 0.5 inch indent
+            }
+            if (style.marginLeft !== undefined) {
+                // margin-left → paragraph indentation (merges with blockquote indent)
+                const existing = props.indent || {};
+                props.indent = { ...existing, left: style.marginLeft };
+            }
+            if (style.textAlign) {
+                props.alignment = style.textAlign;
+            }
+            if (style.lineHeight !== undefined) {
+                props.spacing = { line: style.lineHeight, lineRule: "auto" };
+            }
+            blocks.push({
+                type: "paragraph",
+                ...(Object.keys(props).length > 0 ? { properties: props } : {}),
+                children
+            });
+            continue;
+        }
+        // Container elements: figure, details — recurse into children
+        if (tag === "figure" || tag === "details") {
+            flushPending();
+            i = parseBlocks(tokens, i + 1, blocks, parentCtx, classStyles);
+            continue;
+        }
+        // figcaption — paragraph with Caption style
+        if (tag === "figcaption") {
+            flushPending();
+            const attrs = tok.attrs;
+            const style = parseCssStyle(resolveEffectiveStyle(attrs, classStyles));
+            const children = [];
+            const ctx = { ...parentCtx };
+            applyCssToInlineContext(ctx, style);
+            i = parseInlines(tokens, i + 1, children, ctx, tag, classStyles);
+            blocks.push({
+                type: "paragraph",
+                properties: { style: "Caption" },
+                children
+            });
+            continue;
+        }
+        // summary — bold paragraph
+        if (tag === "summary") {
+            flushPending();
+            const children = [];
+            const ctx = { ...parentCtx, bold: true };
+            i = parseInlines(tokens, i + 1, children, ctx, tag, classStyles);
+            blocks.push({
+                type: "paragraph",
+                children
+            });
+            continue;
+        }
+        // Definition list: dl is a container, dt is bold, dd is indented
+        if (tag === "dl") {
+            flushPending();
+            i = parseBlocks(tokens, i + 1, blocks, parentCtx, classStyles);
+            continue;
+        }
+        if (tag === "dt") {
+            flushPending();
+            const children = [];
+            const ctx = { ...parentCtx, bold: true };
+            i = parseInlines(tokens, i + 1, children, ctx, tag, classStyles);
+            blocks.push({
+                type: "paragraph",
+                children
+            });
+            continue;
+        }
+        if (tag === "dd") {
+            flushPending();
+            const children = [];
+            const ctx = { ...parentCtx };
+            i = parseInlines(tokens, i + 1, children, ctx, tag, classStyles);
+            blocks.push({
+                type: "paragraph",
+                properties: { indent: { left: 720 } },
+                children
+            });
+            continue;
+        }
+        // address — italic paragraph
+        if (tag === "address") {
+            flushPending();
+            const children = [];
+            const ctx = { ...parentCtx, italic: true };
+            i = parseInlines(tokens, i + 1, children, ctx, tag, classStyles);
+            blocks.push({
+                type: "paragraph",
+                children
+            });
+            continue;
+        }
+        // Lists
+        if (tag === "ul" || tag === "ol") {
+            flushPending();
+            i = parseList(tokens, i + 1, blocks, parentCtx, tag === "ol", 0, tag, classStyles);
+            continue;
+        }
+        // Tables
+        if (tag === "table") {
+            flushPending();
+            const table = parseTable(tokens, i + 1, tok.attrs, classStyles);
+            blocks.push(table.table);
+            i = table.endIdx;
+            continue;
+        }
+        // Inline elements treated at block level (wrap in paragraph)
+        if (INLINE_TAGS.has(tag) || tok.type === "selfclose") {
+            if (!pendingInline) {
+                pendingInline = { runs: [], ctx: parentCtx };
+            }
+            i = parseInlineTag(tokens, i, pendingInline.runs, parentCtx, classStyles);
+            continue;
+        }
+        // Unknown block: recurse
+        if (tok.type === "open") {
+            flushPending();
+            i = parseBlocks(tokens, i + 1, blocks, parentCtx, classStyles);
+            continue;
+        }
+        i++;
+    }
+    flushPending();
+    return i;
+}
+const INLINE_TAGS = new Set([
+    "strong",
+    "b",
+    "em",
+    "i",
+    "u",
+    "s",
+    "strike",
+    "del",
+    "a",
+    "span",
+    "code",
+    "sub",
+    "sup",
+    "mark",
+    "small",
+    "abbr",
+    "q",
+    "cite",
+    "time",
+    "kbd",
+    "var",
+    "samp",
+    "img"
+]);
+// =============================================================================
+// Inline parser
+// =============================================================================
+function parseInlines(tokens, start, runs, ctx, untilClose, classStyles) {
+    let i = start;
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (tok.type === "close" && tok.tag === untilClose) {
+            return i + 1;
+        }
+        if (tok.type === "text") {
+            runs.push(makeRun(tok.value, ctx));
+            i++;
+        }
+        else if (tok.type === "close") {
+            // Mismatched close tag, just skip
+            return i + 1;
+        }
+        else {
+            i = parseInlineTag(tokens, i, runs, ctx, classStyles);
+        }
+    }
+    return i;
+}
+function parseInlineTag(tokens, idx, runs, ctx, classStyles) {
+    const tok = tokens[idx];
+    const tag = tok.tag;
+    if (tok.type === "selfclose" || tag === "br") {
+        if (tag === "br") {
+            runs.push({ content: [{ type: "break" }] });
+        }
+        else if (tag === "img") {
+            const imgContent = buildImageContent(tok.attrs);
+            if (imgContent) {
+                runs.push({ content: [imgContent] });
+            }
+            else {
+                // Fallback placeholder text
+                const alt = tok.attrs["alt"] || "image";
+                runs.push(makeRun(`[Image: ${alt}]`, ctx));
+            }
+        }
+        return idx + 1;
+    }
+    // Open tags
+    const newCtx = { ...ctx };
+    const style = parseCssStyle(resolveEffectiveStyle(tok.attrs, classStyles));
+    applyCssToInlineContext(newCtx, style);
+    if (tag === "strong" || tag === "b") {
+        newCtx.bold = true;
+    }
+    else if (tag === "em" || tag === "i") {
+        newCtx.italic = true;
+    }
+    else if (tag === "u") {
+        newCtx.underline = true;
+    }
+    else if (tag === "s" || tag === "strike" || tag === "del") {
+        newCtx.strikethrough = true;
+    }
+    else if (tag === "sub") {
+        newCtx.subscript = true;
+    }
+    else if (tag === "sup") {
+        newCtx.superscript = true;
+    }
+    else if (tag === "mark") {
+        if (!newCtx.backgroundColor) {
+            newCtx.backgroundColor = "FFFF00"; // default highlight
+        }
+    }
+    else if (tag === "cite") {
+        newCtx.italic = true;
+    }
+    else if (tag === "small") {
+        // 80% of default font size (default 24 half-points = 12pt)
+        const baseSize = newCtx.fontSize || 24;
+        newCtx.fontSize = Math.round(baseSize * 0.8);
+    }
+    else if (tag === "code" || tag === "kbd" || tag === "samp") {
+        newCtx.code = true;
+    }
+    else if (tag === "a") {
+        // Collect inner runs and wrap them in a Hyperlink
+        const innerRuns = [];
+        // Drop unsafe schemes (javascript:/vbscript:/...) silently — the link
+        // text is still preserved as plain runs.
+        const safeHref = (0, internal_utils_1.sanitizeUrl)(tok.attrs["href"]);
+        let i = idx + 1;
+        while (i < tokens.length) {
+            const t = tokens[i];
+            if (t.type === "close" && t.tag === tag) {
+                const hyperlink = {
+                    type: "hyperlink",
+                    url: safeHref ?? "",
+                    children: innerRuns
+                };
+                runs.push(hyperlink);
+                return i + 1;
+            }
+            if (t.type === "text") {
+                innerRuns.push(makeRun(t.value, { ...ctx }));
+                i++;
+            }
+            else if (t.type === "close") {
+                const hyperlink = {
+                    type: "hyperlink",
+                    url: safeHref ?? "",
+                    children: innerRuns
+                };
+                runs.push(hyperlink);
+                return i + 1;
+            }
+            else {
+                const childRuns = [];
+                i = parseInlineTag(tokens, i, childRuns, { ...ctx }, classStyles);
+                for (const r of childRuns) {
+                    if ("content" in r && !("type" in r)) {
+                        innerRuns.push(r);
+                    }
+                    else if ("type" in r && r.type === "hyperlink") {
+                        // Flatten nested hyperlink children
+                        for (const c of r.children) {
+                            innerRuns.push(c);
+                        }
+                    }
+                }
+            }
+        }
+        // EOF fallback: tokens ran out without a matching `</a>`. Use the
+        // already-sanitized href so an unclosed `<a href="javascript:...">`
+        // can't smuggle a dangerous URL into the model.
+        const hyperlink = {
+            type: "hyperlink",
+            url: safeHref ?? "",
+            children: innerRuns
+        };
+        runs.push(hyperlink);
+        return i;
+    }
+    // Parse inner content
+    let i = idx + 1;
+    while (i < tokens.length) {
+        const t = tokens[i];
+        if (t.type === "close" && t.tag === tag) {
+            return i + 1;
+        }
+        if (t.type === "text") {
+            runs.push(makeRun(t.value, newCtx));
+            i++;
+        }
+        else if (t.type === "close") {
+            return i + 1;
+        }
+        else {
+            i = parseInlineTag(tokens, i, runs, newCtx, classStyles);
+        }
+    }
+    return i;
+}
+// =============================================================================
+// List parser
+// =============================================================================
+function parseList(tokens, start, blocks, ctx, ordered, level, untilClose, classStyles) {
+    let i = start;
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (tok.type === "close" && tok.tag === untilClose) {
+            return i + 1;
+        }
+        if (tok.type === "open" && tok.tag === "li") {
+            i = parseListItem(tokens, i + 1, blocks, ctx, ordered, level, classStyles);
+        }
+        else if (tok.type === "open" && (tok.tag === "ul" || tok.tag === "ol")) {
+            // Nested list directly under ul/ol (without li wrapper) — increase level
+            i = parseList(tokens, i + 1, blocks, ctx, tok.tag === "ol", level + 1, tok.tag, classStyles);
+        }
+        else {
+            i++;
+        }
+    }
+    return i;
+}
+/** Parse contents of a single `<li>`, handling nested `<ul>/<ol>` inside it. */
+function parseListItem(tokens, start, blocks, ctx, ordered, level, classStyles) {
+    const children = [];
+    let i = start;
+    let hasEmittedContent = false;
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        // End of this <li>
+        if (tok.type === "close" && tok.tag === "li") {
+            // Only emit a paragraph if there's content, or if we haven't emitted any paragraph for this item yet
+            if (children.length > 0 || !hasEmittedContent) {
+                blocks.push({
+                    type: "paragraph",
+                    properties: {
+                        numbering: {
+                            numId: ordered ? 2 : 1,
+                            level: level
+                        }
+                    },
+                    children
+                });
+            }
+            return i + 1;
+        }
+        // Nested list inside <li>: emit current inline content as paragraph, then recurse
+        if (tok.type === "open" && (tok.tag === "ul" || tok.tag === "ol")) {
+            // Emit any collected inline content as the list item paragraph first
+            if (children.length > 0 || !hasEmittedContent) {
+                blocks.push({
+                    type: "paragraph",
+                    properties: {
+                        numbering: {
+                            numId: ordered ? 2 : 1,
+                            level: level
+                        }
+                    },
+                    children: [...children]
+                });
+                children.length = 0;
+                hasEmittedContent = true;
+            }
+            // Parse the nested list at the next level
+            const nestedOrdered = tok.tag === "ol";
+            i = parseList(tokens, i + 1, blocks, ctx, nestedOrdered, level + 1, tok.tag, classStyles);
+            continue;
+        }
+        // Text content
+        if (tok.type === "text") {
+            children.push(makeRun(tok.value, ctx));
+            i++;
+            continue;
+        }
+        // Inline tags
+        if (tok.type === "open" || tok.type === "selfclose") {
+            if (INLINE_TAGS.has(tok.tag) || tok.type === "selfclose") {
+                i = parseInlineTag(tokens, i, children, ctx, classStyles);
+            }
+            else if (tok.tag === "br") {
+                children.push({ content: [{ type: "break" }] });
+                i++;
+            }
+            else {
+                // Some other block-level tag inside <li> (e.g., <p>, <div>) — treat as inline
+                i = parseInlineTag(tokens, i, children, ctx, classStyles);
+            }
+            continue;
+        }
+        // Mismatched close tag
+        if (tok.type === "close") {
+            // Emit what we have and stop
+            blocks.push({
+                type: "paragraph",
+                properties: {
+                    numbering: {
+                        numId: ordered ? 2 : 1,
+                        level: level
+                    }
+                },
+                children
+            });
+            return i + 1;
+        }
+        i++;
+    }
+    // Ran out of tokens without seeing </li> — emit what we have
+    if (children.length > 0) {
+        blocks.push({
+            type: "paragraph",
+            properties: {
+                numbering: {
+                    numId: ordered ? 2 : 1,
+                    level: level
+                }
+            },
+            children
+        });
+    }
+    return i;
+}
+// =============================================================================
+// Table parser
+// =============================================================================
+function parseTable(tokens, start, tableAttrs, classStyles) {
+    const rows = [];
+    let i = start;
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (tok.type === "close" && tok.tag === "table") {
+            i++;
+            break;
+        }
+        if (tok.type === "open" &&
+            (tok.tag === "thead" || tok.tag === "tbody" || tok.tag === "tfoot")) {
+            i++;
+            continue;
+        }
+        if (tok.type === "close" &&
+            (tok.tag === "thead" || tok.tag === "tbody" || tok.tag === "tfoot")) {
+            i++;
+            continue;
+        }
+        if (tok.type === "open" && tok.tag === "tr") {
+            const row = parseTableRow(tokens, i + 1, classStyles);
+            rows.push(row.row);
+            i = row.endIdx;
+            continue;
+        }
+        i++;
+    }
+    // Apply rowspan: insert vMerge "continue" cells in subsequent rows
+    applyRowSpan(rows);
+    // Parse table border style from attributes
+    const tableBorders = parseTableBorders(tableAttrs);
+    // Parse table width from style
+    const tableStyle = parseCssStyle(tableAttrs["style"]);
+    const tableProps = {};
+    if (tableBorders) {
+        tableProps.borders = tableBorders;
+    }
+    if (tableStyle.width) {
+        tableProps.width = { value: tableStyle.width, type: "dxa" };
+    }
+    return {
+        table: {
+            type: "table",
+            ...(Object.keys(tableProps).length > 0 ? { properties: tableProps } : {}),
+            rows
+        },
+        endIdx: i
+    };
+}
+function parseTableRow(tokens, start, classStyles) {
+    const cells = [];
+    let i = start;
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (tok.type === "close" && tok.tag === "tr") {
+            return { row: { cells }, endIdx: i + 1 };
+        }
+        if (tok.type === "open" && (tok.tag === "td" || tok.tag === "th")) {
+            const isHeader = tok.tag === "th";
+            const attrs = tok.attrs;
+            const children = [];
+            const cellCtx = isHeader ? { bold: true } : {};
+            const style = parseCssStyle(resolveEffectiveStyle(attrs, classStyles));
+            applyCssToInlineContext(cellCtx, style);
+            i = parseInlines(tokens, i + 1, children, cellCtx, tok.tag, classStyles);
+            // Build cell properties
+            const cellProps = buildCellProperties(attrs, style);
+            // Build paragraph properties for text-align
+            const paraProps = {};
+            if (style.textAlign) {
+                paraProps.alignment = style.textAlign;
+            }
+            cells.push({
+                ...(cellProps ? { properties: cellProps } : {}),
+                content: [
+                    {
+                        type: "paragraph",
+                        ...(Object.keys(paraProps).length > 0
+                            ? { properties: paraProps }
+                            : {}),
+                        children
+                    }
+                ]
+            });
+            continue;
+        }
+        i++;
+    }
+    return { row: { cells }, endIdx: i };
+}
+/** Build TableCellProperties from HTML attributes (colspan, rowspan, borders). */
+function buildCellProperties(attrs, style) {
+    const props = {};
+    // colspan → gridSpan
+    const colspan = parseInt(attrs["colspan"], 10);
+    if (colspan > 1) {
+        props.gridSpan = colspan;
+    }
+    // rowspan → verticalMerge restart (the continuation cells need "continue")
+    const rowspan = parseInt(attrs["rowspan"], 10);
+    if (rowspan > 1) {
+        props.verticalMerge = "restart";
+        props.rowSpan = rowspan;
+    }
+    // Cell width from style or width attribute
+    if (style.width) {
+        props.width = { value: style.width, type: "dxa" };
+    }
+    else if (attrs["width"]) {
+        const w = parseCellWidthAttr(attrs["width"]);
+        if (w) {
+            props.width = w;
+        }
+    }
+    // Background color from style
+    if (style.backgroundColor) {
+        props.shading = { pattern: "clear", fill: style.backgroundColor };
+    }
+    // Cell borders from inline style
+    const cellBorders = parseCellBordersFromStyle(attrs["style"]);
+    if (cellBorders) {
+        props.borders = cellBorders;
+    }
+    return Object.keys(props).length > 0 ? props : undefined;
+}
+/** Parse a cell width attribute value (number in px, percentage, or plain number). */
+function parseCellWidthAttr(value) {
+    if (!value) {
+        return undefined;
+    }
+    // Percentage: "50%" → pct (fiftieths of a percent: 50% = 2500)
+    const pctMatch = /^([\d.]+)%$/.exec(value.trim());
+    if (pctMatch) {
+        return { value: Math.round(parseFloat(pctMatch[1]) * 50), type: "pct" };
+    }
+    // Numeric (pixels): "200" or "200px" → convert to twips
+    const pxMatch = /^(\d+)(?:px)?$/.exec(value.trim());
+    if (pxMatch) {
+        return { value: parseInt(pxMatch[1], 10) * 15, type: "dxa" };
+    }
+    return undefined;
+}
+/**
+ * Post-process rows to insert vMerge "continue" cells for rowspan.
+ * Scans rows for cells with rowSpan > 1, then inserts placeholder cells
+ * with verticalMerge: "continue" in the appropriate positions in subsequent rows.
+ */
+function applyRowSpan(rows) {
+    const activeSpans = new Map();
+    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+        const row = rows[rowIdx];
+        const newCells = [];
+        let cellIdx = 0; // index into original cells
+        let colIdx = 0; // logical column position
+        // Insert vMerge "continue" cells for active rowspans
+        while (colIdx < 1000) {
+            // safety limit
+            const span = activeSpans.get(colIdx);
+            if (span && span.remaining > 0) {
+                // Insert a continuation cell
+                const contCell = {
+                    properties: {
+                        verticalMerge: "continue",
+                        ...(span.gridSpan > 1 ? { gridSpan: span.gridSpan } : {})
+                    },
+                    content: [{ type: "paragraph", children: [] }]
+                };
+                newCells.push(contCell);
+                span.remaining--;
+                if (span.remaining === 0) {
+                    activeSpans.delete(colIdx);
+                }
+                colIdx += span.gridSpan;
+                continue;
+            }
+            // No active span at this column: use the next original cell
+            if (cellIdx >= row.cells.length) {
+                break;
+            }
+            const cell = row.cells[cellIdx];
+            const cellGridSpan = cell.properties?.gridSpan || 1;
+            const cellRowSpan = cell.properties?.rowSpan;
+            // Register new rowspan
+            if (cellRowSpan && cellRowSpan > 1) {
+                activeSpans.set(colIdx, { remaining: cellRowSpan - 1, gridSpan: cellGridSpan });
+            }
+            newCells.push(cell);
+            colIdx += cellGridSpan;
+            cellIdx++;
+        }
+        // Replace the row's cells with the new array (including continuation cells)
+        // We need to cast away readonly for mutation during this post-processing step
+        rows[rowIdx].cells = newCells;
+    }
+}
+/** Parse table-level borders from table attributes. */
+function parseTableBorders(attrs) {
+    const style = parseCssStyle(attrs["style"]);
+    const borderAttr = attrs["border"];
+    // Check for border="1" attribute (common HTML table pattern)
+    if (borderAttr && parseInt(borderAttr, 10) > 0) {
+        const size = Math.max(4, parseInt(borderAttr, 10) * 4); // eighths of a point
+        const border = { style: "single", size, color: "000000" };
+        return {
+            top: border,
+            left: border,
+            bottom: border,
+            right: border,
+            insideH: border,
+            insideV: border
+        };
+    }
+    // Check style attribute for border
+    const borderStyle = parseBorderStyleFromCss(attrs["style"]);
+    if (borderStyle) {
+        return {
+            top: borderStyle,
+            left: borderStyle,
+            bottom: borderStyle,
+            right: borderStyle,
+            insideH: borderStyle,
+            insideV: borderStyle
+        };
+    }
+    // background-color at table level can influence shading (handled separately)
+    void style;
+    return undefined;
+}
+/** Parse border CSS shorthand to a Border object. */
+function parseBorderStyleFromCss(styleStr) {
+    if (!styleStr) {
+        return undefined;
+    }
+    // Match border: <width> <style> <color> or border-style, border-width, border-color
+    const declarations = styleStr.split(";");
+    let borderWidth;
+    let borderStyleVal;
+    let borderColor;
+    for (const decl of declarations) {
+        const colonIdx = decl.indexOf(":");
+        if (colonIdx < 0) {
+            continue;
+        }
+        const prop = decl.slice(0, colonIdx).trim().toLowerCase();
+        const value = decl
+            .slice(colonIdx + 1)
+            .trim()
+            .toLowerCase();
+        if (prop === "border") {
+            // Shorthand: border: 1px solid black
+            const parts = value.split(/\s+/);
+            for (const part of parts) {
+                if (/^\d/.test(part)) {
+                    borderWidth = parseBorderWidth(part);
+                }
+                else if (isBorderStyleKeyword(part)) {
+                    borderStyleVal = part;
+                }
+                else {
+                    borderColor = parseCssColor(part) || borderColor;
+                }
+            }
+        }
+        else if (prop === "border-style") {
+            borderStyleVal = value.split(/\s+/)[0];
+        }
+        else if (prop === "border-width") {
+            borderWidth = parseBorderWidth(value.split(/\s+/)[0]);
+        }
+        else if (prop === "border-color") {
+            borderColor = parseCssColor(value.split(/\s+/)[0]) || borderColor;
+        }
+    }
+    if (borderStyleVal && borderStyleVal !== "none" && borderStyleVal !== "hidden") {
+        return {
+            style: mapCssBorderStyle(borderStyleVal),
+            size: borderWidth || 4,
+            color: borderColor || "000000"
+        };
+    }
+    return undefined;
+}
+/** Parse cell-level borders from inline style string. */
+function parseCellBordersFromStyle(styleStr) {
+    if (!styleStr) {
+        return undefined;
+    }
+    const borderDef = parseBorderStyleFromCss(styleStr);
+    if (!borderDef) {
+        return undefined;
+    }
+    return {
+        top: borderDef,
+        left: borderDef,
+        bottom: borderDef,
+        right: borderDef
+    };
+}
+function parseBorderWidth(value) {
+    const match = /^([\d.]+)\s*(px|pt)?$/.exec(value);
+    if (!match) {
+        return 4;
+    }
+    const num = parseFloat(match[1]);
+    const unit = match[2] || "px";
+    if (unit === "pt") {
+        return Math.round(num * 8); // eighths of a point
+    }
+    // px: approximate 1px ≈ 0.75pt → 6 eighths
+    return Math.round(num * 6);
+}
+function isBorderStyleKeyword(value) {
+    return [
+        "none",
+        "hidden",
+        "dotted",
+        "dashed",
+        "solid",
+        "double",
+        "groove",
+        "ridge",
+        "inset",
+        "outset"
+    ].includes(value);
+}
+function mapCssBorderStyle(cssStyle) {
+    switch (cssStyle) {
+        case "solid":
+        case "groove":
+        case "ridge":
+        case "inset":
+        case "outset":
+            return "single";
+        case "double":
+            return "double";
+        case "dotted":
+            return "dotted";
+        case "dashed":
+            return "dashed";
+        case "none":
+        case "hidden":
+            return "none";
+        default:
+            return "single";
+    }
+}
+// =============================================================================
+// Image content builder
+// =============================================================================
+/** Build InlineImageContent from img attributes or return undefined if not applicable. */
+function buildImageContent(attrs) {
+    const src = attrs["src"] || "";
+    const alt = attrs["alt"] || "";
+    // Parse width/height from attributes first, then fall back to style
+    let width = parseImageDimension(attrs["width"]);
+    let height = parseImageDimension(attrs["height"]);
+    // Also check inline style for width/height
+    if (!width || !height) {
+        const styleDims = parseImageDimensionsFromStyle(attrs["style"]);
+        if (!width && styleDims.width) {
+            width = styleDims.width;
+        }
+        if (!height && styleDims.height) {
+            height = styleDims.height;
+        }
+    }
+    // Convert pixels to EMU
+    const widthEmu = (width || 100) * units_1.EMU_PER_PX;
+    const heightEmu = (height || 100) * units_1.EMU_PER_PX;
+    // Both data: and http(s) URLs become placeholders. The DOCX writer needs
+    // a real ImageDef registered in `doc.images` plus a corresponding
+    // relationship; htmlToDocxBody returns BodyContent[] only and cannot do
+    // that registration. We surface the original src in the alt text so the
+    // user can post-process if they need real embedded images.
+    if (src.startsWith("data:") || src.startsWith("http://") || src.startsWith("https://")) {
+        return {
+            type: "image",
+            rId: "", // empty rId → renderer treats this as a placeholder
+            width: widthEmu,
+            height: heightEmu,
+            altText: alt || `[Image placeholder: ${src.slice(0, 64)}${src.length > 64 ? "…" : ""}]`,
+            name: alt || "image"
+        };
+    }
+    return undefined;
+}
+/** Parse an image dimension from HTML attribute value (number or "Npx"). */
+function parseImageDimension(value) {
+    if (!value) {
+        return undefined;
+    }
+    const match = /^(\d+)(?:px)?$/.exec(value.trim());
+    return match ? parseInt(match[1], 10) : undefined;
+}
+/** Parse width and height from an inline style string (for <img> elements). */
+function parseImageDimensionsFromStyle(styleStr) {
+    const result = {};
+    if (!styleStr) {
+        return result;
+    }
+    const declarations = styleStr.split(";");
+    for (const decl of declarations) {
+        const colonIdx = decl.indexOf(":");
+        if (colonIdx < 0) {
+            continue;
+        }
+        const prop = decl.slice(0, colonIdx).trim().toLowerCase();
+        const value = decl
+            .slice(colonIdx + 1)
+            .trim()
+            .toLowerCase();
+        if (prop === "width") {
+            const px = parseImageCssDimension(value);
+            if (px !== undefined) {
+                result.width = px;
+            }
+        }
+        else if (prop === "height") {
+            const px = parseImageCssDimension(value);
+            if (px !== undefined) {
+                result.height = px;
+            }
+        }
+    }
+    return result;
+}
+/** Parse a CSS dimension value for images into pixels. */
+function parseImageCssDimension(value) {
+    const match = /^([\d.]+)\s*(px|pt|in|cm|mm)?$/.exec(value);
+    if (!match) {
+        return undefined;
+    }
+    const num = parseFloat(match[1]);
+    const unit = match[2] || "px";
+    switch (unit) {
+        case "px":
+            return Math.round(num);
+        case "pt":
+            // 1pt = 1.333px
+            return Math.round(num * 1.333);
+        case "in":
+            // 1in = 96px
+            return Math.round(num * 96);
+        case "cm":
+            // 1cm ≈ 37.8px
+            return Math.round(num * 37.8);
+        case "mm":
+            // 1mm ≈ 3.78px
+            return Math.round(num * 3.78);
+        default:
+            return undefined;
+    }
+}
+// =============================================================================
+// CSS → InlineContext helper
+// =============================================================================
+/** Apply parsed CSS styles to an InlineContext. */
+function applyCssToInlineContext(ctx, style) {
+    if (style.bold) {
+        ctx.bold = true;
+    }
+    if (style.italic) {
+        ctx.italic = true;
+    }
+    if (style.underline) {
+        ctx.underline = true;
+    }
+    if (style.lineThrough) {
+        ctx.strikethrough = true;
+    }
+    if (style.color) {
+        ctx.color = style.color;
+    }
+    if (style.backgroundColor) {
+        ctx.backgroundColor = style.backgroundColor;
+    }
+    if (style.fontFamily) {
+        ctx.fontFamily = style.fontFamily;
+    }
+    if (style.fontSize) {
+        ctx.fontSize = style.fontSize;
+    }
+}
+/**
+ * Resolve the effective inline style string for an element by merging class-based styles
+ * with inline styles. Inline styles take priority over class-based styles.
+ */
+function resolveEffectiveStyle(attrs, classStyles) {
+    const classAttr = attrs["class"];
+    let merged;
+    if (classAttr) {
+        const classNames = classAttr.split(/\s+/).filter(Boolean);
+        const parts = [];
+        for (const name of classNames) {
+            const s = classStyles[name];
+            if (s) {
+                parts.push(s);
+            }
+        }
+        if (parts.length > 0) {
+            merged = parts.join("; ");
+        }
+    }
+    const inlineStyle = attrs["style"];
+    if (merged && inlineStyle) {
+        // Inline style overrides: append after class-based style so later declarations win
+        return merged + "; " + inlineStyle;
+    }
+    return inlineStyle || merged;
+}
+// =============================================================================
+// Run builder
+// =============================================================================
+function makeRun(text, ctx) {
+    const props = {};
+    if (ctx.bold) {
+        props.bold = true;
+    }
+    if (ctx.italic) {
+        props.italic = true;
+    }
+    if (ctx.underline) {
+        props.underline = "single";
+    }
+    if (ctx.strikethrough) {
+        props.strike = true;
+    }
+    if (ctx.superscript) {
+        props.vertAlign = "superscript";
+    }
+    if (ctx.subscript) {
+        props.vertAlign = "subscript";
+    }
+    if (ctx.code) {
+        props.font = { ascii: "Courier New", hAnsi: "Courier New" };
+    }
+    else if (ctx.fontFamily) {
+        props.font = { ascii: ctx.fontFamily, hAnsi: ctx.fontFamily };
+    }
+    if (ctx.fontSize) {
+        props.size = ctx.fontSize;
+    }
+    if (ctx.color) {
+        props.color = ctx.color;
+    }
+    if (ctx.backgroundColor) {
+        props.shading = { pattern: "clear", fill: ctx.backgroundColor };
+    }
+    const run = {
+        ...(Object.keys(props).length > 0 ? { properties: props } : {}),
+        content: [{ type: "text", text }]
+    };
+    return run;
+}