@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/esm/modules/word/reader/table-properties-parsers.js

@@ -0,0 +1,234 @@
+/**
+ * DOCX Reader - Table Properties Parsers
+ *
+ * Pure parsers for `w:tblPr`, `w:tblBorders`, `w:tcMar` (cell margins).
+ * Used by both the inline table parser and the styles parser.
+ */
+import {} from "../core/internal-utils.js";
+import { attrInt, attrVal, findChildNs, safeParseInt } from "./parse-utils.js";
+import { parseBorder, parseRevisionInfo, parseShading, parseTableWidth } from "./properties-parsers.js";
+function parseTableBorders(el) {
+    const borders = {};
+    for (const side of [
+        "top",
+        "left",
+        "bottom",
+        "right",
+        "insideH",
+        "insideV",
+        "start",
+        "end",
+        "tl2br",
+        "tr2bl"
+    ]) {
+        const sideEl = findChildNs(el, side);
+        if (sideEl) {
+            borders[side] = parseBorder(sideEl);
+        }
+    }
+    return borders;
+}
+function parseTableCellMargins(el) {
+    const margins = {};
+    for (const side of ["top", "left", "bottom", "right", "start", "end"]) {
+        const sideEl = findChildNs(el, side);
+        if (sideEl) {
+            margins[side] = parseTableWidth(sideEl);
+        }
+    }
+    return margins;
+}
+function parseTableProperties(el) {
+    const props = {};
+    const styleEl = findChildNs(el, "tblStyle");
+    if (styleEl) {
+        props.style = attrVal(styleEl, "val");
+    }
+    const wEl = findChildNs(el, "tblW");
+    if (wEl) {
+        props.width = parseTableWidth(wEl);
+    }
+    const jcEl = findChildNs(el, "jc");
+    if (jcEl) {
+        props.alignment = attrVal(jcEl, "val");
+    }
+    const indEl = findChildNs(el, "tblInd");
+    if (indEl) {
+        props.indent = safeParseInt(indEl.attributes["w:w"] ?? indEl.attributes["w"], 0);
+    }
+    const bordersEl = findChildNs(el, "tblBorders");
+    if (bordersEl) {
+        props.borders = parseTableBorders(bordersEl);
+    }
+    const layoutEl = findChildNs(el, "tblLayout");
+    if (layoutEl) {
+        props.layout = attrVal(layoutEl, "type");
+    }
+    const cellMarEl = findChildNs(el, "tblCellMar");
+    if (cellMarEl) {
+        props.cellMargins = parseTableCellMargins(cellMarEl);
+    }
+    // TableLook
+    const lookEl = findChildNs(el, "tblLook");
+    if (lookEl) {
+        const look = {};
+        // Read individual attributes first (authoritative when explicit "0"/"1")
+        const readFlag = (name) => {
+            const v = attrVal(lookEl, name);
+            if (v === "1" || v === "true") {
+                return true;
+            }
+            if (v === "0" || v === "false") {
+                return false;
+            }
+            return undefined;
+        };
+        const firstRow = readFlag("firstRow");
+        const lastRow = readFlag("lastRow");
+        const firstColumn = readFlag("firstColumn");
+        const lastColumn = readFlag("lastColumn");
+        const noHBand = readFlag("noHBand");
+        const noVBand = readFlag("noVBand");
+        if (firstRow !== undefined) {
+            look.firstRow = firstRow;
+        }
+        if (lastRow !== undefined) {
+            look.lastRow = lastRow;
+        }
+        if (firstColumn !== undefined) {
+            look.firstColumn = firstColumn;
+        }
+        if (lastColumn !== undefined) {
+            look.lastColumn = lastColumn;
+        }
+        if (noHBand !== undefined) {
+            look.noHBand = noHBand;
+        }
+        if (noVBand !== undefined) {
+            look.noVBand = noVBand;
+        }
+        // Fall back to w:val bitmask ONLY if no individual attrs were specified
+        if (Object.keys(look).length === 0) {
+            const val = attrVal(lookEl, "val");
+            if (val) {
+                const v = parseInt(val, 16);
+                if (v & 0x0020) {
+                    look.firstRow = true;
+                }
+                if (v & 0x0040) {
+                    look.lastRow = true;
+                }
+                if (v & 0x0080) {
+                    look.firstColumn = true;
+                }
+                if (v & 0x0100) {
+                    look.lastColumn = true;
+                }
+                if (v & 0x0200) {
+                    look.noHBand = true;
+                }
+                if (v & 0x0400) {
+                    look.noVBand = true;
+                }
+            }
+        }
+        if (Object.keys(look).length > 0) {
+            props.look = look;
+        }
+    }
+    // TableFloat
+    const tblpPrEl = findChildNs(el, "tblpPr");
+    if (tblpPrEl) {
+        const tf = {};
+        const hAnchor = attrVal(tblpPrEl, "horzAnchor");
+        if (hAnchor) {
+            tf.horizontalAnchor = hAnchor;
+        }
+        const vAnchor = attrVal(tblpPrEl, "vertAnchor");
+        if (vAnchor) {
+            tf.verticalAnchor = vAnchor;
+        }
+        const tblpX = attrInt(tblpPrEl, "tblpX");
+        if (tblpX !== undefined) {
+            tf.absoluteHorizontalPosition = tblpX;
+        }
+        const tblpY = attrInt(tblpPrEl, "tblpY");
+        if (tblpY !== undefined) {
+            tf.absoluteVerticalPosition = tblpY;
+        }
+        const tblpXSpec = attrVal(tblpPrEl, "tblpXSpec");
+        if (tblpXSpec) {
+            tf.relativeHorizontalPosition = tblpXSpec;
+        }
+        const tblpYSpec = attrVal(tblpPrEl, "tblpYSpec");
+        if (tblpYSpec) {
+            tf.relativeVerticalPosition = tblpYSpec;
+        }
+        const topFromText = attrInt(tblpPrEl, "topFromText");
+        if (topFromText !== undefined) {
+            tf.topFromText = topFromText;
+        }
+        const bottomFromText = attrInt(tblpPrEl, "bottomFromText");
+        if (bottomFromText !== undefined) {
+            tf.bottomFromText = bottomFromText;
+        }
+        const leftFromText = attrInt(tblpPrEl, "leftFromText");
+        if (leftFromText !== undefined) {
+            tf.leftFromText = leftFromText;
+        }
+        const rightFromText = attrInt(tblpPrEl, "rightFromText");
+        if (rightFromText !== undefined) {
+            tf.rightFromText = rightFromText;
+        }
+        const overlap = attrVal(tblpPrEl, "overlap");
+        if (overlap) {
+            tf.overlap = overlap;
+        }
+        props.float = tf;
+    }
+    // w:tblOverlap is a separate sibling element of w:tblpPr (value "never"|"overlap")
+    const tblOverlapEl = findChildNs(el, "tblOverlap");
+    if (tblOverlapEl && props.float) {
+        const v = attrVal(tblOverlapEl, "val");
+        if (v === "never" || v === "overlap") {
+            props.float.overlap = v;
+        }
+    }
+    // Cell spacing
+    const csEl = findChildNs(el, "tblCellSpacing");
+    if (csEl) {
+        props.cellSpacing = parseTableWidth(csEl);
+    }
+    // Bidi visual
+    if (findChildNs(el, "bidiVisual")) {
+        props.visuallyRightToLeft = true;
+    }
+    // Shading
+    const shdEl = findChildNs(el, "shd");
+    if (shdEl) {
+        props.shading = parseShading(shdEl);
+    }
+    // Accessibility: caption and description
+    const captionEl = findChildNs(el, "tblCaption");
+    if (captionEl) {
+        props.caption = attrVal(captionEl, "val");
+    }
+    const descEl = findChildNs(el, "tblDescription");
+    if (descEl) {
+        props.description = attrVal(descEl, "val");
+    }
+    // Table property change
+    const tblPrChangeEl = findChildNs(el, "tblPrChange");
+    if (tblPrChangeEl) {
+        const rev = parseRevisionInfo(tblPrChangeEl);
+        if (rev) {
+            const prev = findChildNs(tblPrChangeEl, "tblPr");
+            props.propertyChange = {
+                revision: rev,
+                previousProperties: prev ? parseTableProperties(prev) : undefined
+            };
+        }
+    }
+    return props;
+}
+export { parseTableBorders, parseTableCellMargins, parseTableProperties };

package/dist/esm/modules/word/reader/theme-parser.js

@@ -0,0 +1,167 @@
+/**
+ * DOCX Reader - Theme Parser
+ *
+ * Parses `word/theme/theme1.xml` (`DocumentTheme`).
+ * Extracted from the original `metadata-parsers.ts`.
+ */
+import { findChild, parseXml } from "../../xml/dom.js";
+import {} from "../core/internal-utils.js";
+import { findChildNs, serializeElement } from "./parse-utils.js";
+const THEME_COLOR_NAMES = [
+    "dk1",
+    "lt1",
+    "dk2",
+    "lt2",
+    "accent1",
+    "accent2",
+    "accent3",
+    "accent4",
+    "accent5",
+    "accent6",
+    "hlink",
+    "folHlink"
+];
+export function parseThemeXml(xmlStr) {
+    const doc = parseXml(xmlStr);
+    const root = doc.root;
+    // Find a:themeElements
+    const themeElements = findChild(root, "a:themeElements") ?? findChildNs(root, "themeElements");
+    const defaultScheme = {
+        name: "Office",
+        colors: {
+            dk1: "000000",
+            lt1: "FFFFFF",
+            dk2: "44546A",
+            lt2: "E7E6E6",
+            accent1: "4472C4",
+            accent2: "ED7D31",
+            accent3: "A5A5A5",
+            accent4: "FFC000",
+            accent5: "5B9BD5",
+            accent6: "70AD47",
+            hlink: "0563C1",
+            folHlink: "954F72"
+        }
+    };
+    const defaultFontScheme = { name: "Office", majorFont: "Calibri Light", minorFont: "Calibri" };
+    if (!themeElements) {
+        return {
+            name: root.attributes["name"],
+            colorScheme: defaultScheme,
+            fontScheme: defaultFontScheme
+        };
+    }
+    // Parse color scheme
+    const clrSchemeEl = findChild(themeElements, "a:clrScheme") ?? findChildNs(themeElements, "clrScheme");
+    const colorScheme = { ...defaultScheme };
+    if (clrSchemeEl) {
+        colorScheme.name = clrSchemeEl.attributes["name"] ?? "Office";
+        for (const colorName of THEME_COLOR_NAMES) {
+            const colorEl = findChild(clrSchemeEl, `a:${colorName}`) ?? findChildNs(clrSchemeEl, colorName);
+            if (colorEl) {
+                // Color can be sysClr (with lastClr) or srgbClr (with val)
+                const srgb = findChild(colorEl, "a:srgbClr") ?? findChildNs(colorEl, "srgbClr");
+                if (srgb) {
+                    const val = srgb.attributes["val"];
+                    if (val) {
+                        colorScheme.colors[colorName] = val;
+                    }
+                }
+                else {
+                    const sys = findChild(colorEl, "a:sysClr") ?? findChildNs(colorEl, "sysClr");
+                    if (sys) {
+                        const lastClr = sys.attributes["lastClr"];
+                        if (lastClr) {
+                            colorScheme.colors[colorName] = lastClr;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Parse font scheme
+    const fontSchemeEl = findChild(themeElements, "a:fontScheme") ?? findChildNs(themeElements, "fontScheme");
+    const fontScheme = { ...defaultFontScheme };
+    if (fontSchemeEl) {
+        fontScheme.name = fontSchemeEl.attributes["name"] ?? "Office";
+        const majorEl = findChild(fontSchemeEl, "a:majorFont") ?? findChildNs(fontSchemeEl, "majorFont");
+        if (majorEl) {
+            const major = parseThemeFont(majorEl);
+            if (major) {
+                fontScheme.major = major;
+                if (major.latin) {
+                    fontScheme.majorFont = major.latin;
+                }
+            }
+        }
+        const minorEl = findChild(fontSchemeEl, "a:minorFont") ?? findChildNs(fontSchemeEl, "minorFont");
+        if (minorEl) {
+            const minor = parseThemeFont(minorEl);
+            if (minor) {
+                fontScheme.minor = minor;
+                if (minor.latin) {
+                    fontScheme.minorFont = minor.latin;
+                }
+            }
+        }
+    }
+    // Parse format scheme (preserve raw XML of its children for round-trip)
+    const fmtSchemeEl = findChild(themeElements, "a:fmtScheme") ?? findChildNs(themeElements, "fmtScheme");
+    let formatScheme;
+    if (fmtSchemeEl) {
+        let rawXml = "";
+        for (const child of fmtSchemeEl.children) {
+            if (child.type === "element") {
+                rawXml += serializeElement(child);
+            }
+        }
+        formatScheme = {
+            name: fmtSchemeEl.attributes["name"] ?? "Office",
+            rawXml: rawXml || undefined
+        };
+    }
+    // Preserve extLst (theme extensions) as raw XML
+    let extLstXml;
+    const extLstEl = findChild(root, "a:extLst") ?? findChildNs(root, "extLst");
+    if (extLstEl) {
+        extLstXml = serializeElement(extLstEl);
+    }
+    return {
+        name: root.attributes["name"],
+        colorScheme,
+        fontScheme,
+        formatScheme,
+        extLstXml
+    };
+}
+/** Parse a theme font (a:majorFont or a:minorFont). */
+function parseThemeFont(el) {
+    const font = {};
+    const latin = findChild(el, "a:latin") ?? findChildNs(el, "latin");
+    if (latin?.attributes["typeface"]) {
+        font.latin = latin.attributes["typeface"];
+    }
+    const ea = findChild(el, "a:ea") ?? findChildNs(el, "ea");
+    if (ea?.attributes["typeface"]) {
+        font.eastAsia = ea.attributes["typeface"];
+    }
+    const cs = findChild(el, "a:cs") ?? findChildNs(el, "cs");
+    if (cs?.attributes["typeface"]) {
+        font.complexScript = cs.attributes["typeface"];
+    }
+    // Supplemental fonts (a:font script="..." typeface="...")
+    const supplementalFonts = {};
+    for (const child of el.children) {
+        if (child.type === "element" && (child.name === "a:font" || child.name === "font")) {
+            const script = child.attributes["script"];
+            const typeface = child.attributes["typeface"];
+            if (script && typeface) {
+                supplementalFonts[script] = typeface;
+            }
+        }
+    }
+    if (Object.keys(supplementalFonts).length > 0) {
+        font.supplementalFonts = supplementalFonts;
+    }
+    return font.latin !== undefined ? font : undefined;
+}

package/dist/esm/modules/word/reader/watermark-parser.js

@@ -0,0 +1,110 @@
+/**
+ * DOCX reader — header watermark detection.
+ *
+ * Watermarks are stored as a VML shape inside the first `<w:p>` of a header
+ * part. We detect them by walking the header XML tree looking for a shape
+ * whose id contains "WaterMark"; the surrounding header content is parsed
+ * by the regular header-content parser.
+ *
+ * Self-contained — no dependency on the body parser, so it lives in its
+ * own file to keep `docx-reader.ts` focused on package orchestration.
+ */
+import { findChild } from "../../xml/dom.js";
+/** Detect a watermark shape inside a header XML root, if present. */
+export function detectWatermarkFromRoot(root) {
+    // Look for VML shape with id containing "WaterMark"
+    for (const pEl of root.children) {
+        if (pEl.type !== "element") {
+            continue;
+        }
+        for (const rEl of pEl.children) {
+            if (rEl.type !== "element") {
+                continue;
+            }
+            // Look for w:pict or w:r > w:pict
+            const pictEls = [];
+            const rName = rEl.name.replace(/^w:/, "");
+            if (rName === "pict") {
+                pictEls.push(rEl);
+            }
+            else if (rName === "r") {
+                for (const rc of rEl.children) {
+                    if (rc.type === "element" && rc.name.replace(/^w:/, "") === "pict") {
+                        pictEls.push(rc);
+                    }
+                }
+            }
+            for (const pictEl of pictEls) {
+                for (const shapeEl of pictEl.children) {
+                    if (shapeEl.type !== "element") {
+                        continue;
+                    }
+                    const shapeId = shapeEl.attributes["id"] ?? "";
+                    if (!shapeId.toLowerCase().includes("watermark")) {
+                        continue;
+                    }
+                    // Found watermark shape
+                    const shapeType = shapeEl.attributes["type"] ?? "";
+                    if (shapeType.includes("136")) {
+                        // WordArt text watermark (shapetype 136)
+                        return parseTextWatermark(shapeEl);
+                    }
+                    // Check for image watermark (has v:imagedata)
+                    const imgData = findChild(shapeEl, "v:imagedata");
+                    if (imgData) {
+                        return parseImageWatermark(shapeEl, imgData);
+                    }
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function parseTextWatermark(shapeEl) {
+    const fillColor = shapeEl.attributes["fillcolor"] ?? "#C0C0C0";
+    const color = fillColor.replace(/^#/, "");
+    // Parse rotation from style
+    const style = shapeEl.attributes["style"] ?? "";
+    let rotation = -45;
+    const rotMatch = style.match(/rotation:\s*(-?\d+)/);
+    if (rotMatch) {
+        rotation = parseInt(rotMatch[1], 10);
+    }
+    // Get opacity from v:fill
+    const fillEl = findChild(shapeEl, "v:fill");
+    const opacity = fillEl?.attributes["opacity"] ?? ".5";
+    const semiTransparent = opacity !== "1";
+    // Get text and font from v:textpath
+    const textpathEl = findChild(shapeEl, "v:textpath");
+    const text = textpathEl?.attributes["string"] ?? "";
+    const tpStyle = textpathEl?.attributes["style"] ?? "";
+    let font;
+    let fontSize;
+    const fontMatch = tpStyle.match(/font-family:\s*"?([^";]+)"?/);
+    if (fontMatch) {
+        font = fontMatch[1].replace(/&quot;/g, "");
+    }
+    const sizeMatch = tpStyle.match(/font-size:\s*(\d+(?:\.\d+)?)\s*pt/);
+    if (sizeMatch) {
+        fontSize = Math.round(parseFloat(sizeMatch[1]) * 2); // convert pt to half-points
+    }
+    return {
+        type: "text",
+        text,
+        font,
+        fontSize,
+        color,
+        semiTransparent,
+        rotation
+    };
+}
+function parseImageWatermark(shapeEl, imgDataEl) {
+    const rId = imgDataEl.attributes["r:id"] ?? "";
+    const gain = imgDataEl.attributes["gain"] ?? "";
+    const washout = gain.startsWith("19661") || gain === "";
+    return {
+        type: "image",
+        rId,
+        washout
+    };
+}