@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/esm/modules/word/reader/drawing-helpers.js

@@ -0,0 +1,84 @@
+/**
+ * DOCX Reader - Drawing/Image Helpers
+ *
+ * Shared parsing helpers for DrawingML elements (used by both inline image,
+ * floating image, and drawing shape parsers).
+ */
+import { findChild, findChildren } from "../../xml/dom.js";
+import { findChildNs } from "./parse-utils.js";
+/** Parse `a:xfrm` element for rotation and flip properties. */
+export function parseXfrm(spPrEl, target) {
+    const xfrmEl = findChild(spPrEl, "a:xfrm");
+    if (xfrmEl) {
+        const rot = xfrmEl.attributes["rot"];
+        if (rot !== undefined && rot !== "") {
+            target.rotation = parseInt(rot, 10);
+        }
+        if (xfrmEl.attributes["flipH"] === "1") {
+            target.flipHorizontal = true;
+        }
+        if (xfrmEl.attributes["flipV"] === "1") {
+            target.flipVertical = true;
+        }
+    }
+}
+/** Parse outline (`a:ln`) element. */
+export function parseOutline(spPrEl) {
+    const lnEl = findChild(spPrEl, "a:ln");
+    if (!lnEl) {
+        return undefined;
+    }
+    const outline = {};
+    const w = lnEl.attributes["w"];
+    if (w) {
+        outline.width = parseInt(w, 10);
+    }
+    const sfEl = findChild(lnEl, "a:solidFill");
+    const srgbEl = sfEl ? findChild(sfEl, "a:srgbClr") : undefined;
+    if (srgbEl) {
+        outline.color = srgbEl.attributes["val"];
+    }
+    return Object.keys(outline).length > 0 ? outline : undefined;
+}
+/** Parse source rectangle (crop) from `a:blipFill`. */
+export function parseSrcRect(blipFillEl) {
+    const srcRectEl = findChild(blipFillEl, "a:srcRect");
+    if (!srcRectEl) {
+        return undefined;
+    }
+    const sr = {};
+    const lAttr = srcRectEl.attributes["l"];
+    const tAttr = srcRectEl.attributes["t"];
+    const rAttr = srcRectEl.attributes["r"];
+    const bAttr = srcRectEl.attributes["b"];
+    if (lAttr !== undefined) {
+        sr.l = parseInt(lAttr, 10);
+    }
+    if (tAttr !== undefined) {
+        sr.t = parseInt(tAttr, 10);
+    }
+    if (rAttr !== undefined) {
+        sr.r = parseInt(rAttr, 10);
+    }
+    if (bAttr !== undefined) {
+        sr.b = parseInt(bAttr, 10);
+    }
+    return Object.keys(sr).length > 0 ? sr : undefined;
+}
+/** Parse SVG blip reference from `a:extLst` inside `a:blip`. */
+export function parseSvgBlip(blipEl) {
+    const extLst = findChild(blipEl, "a:extLst");
+    if (!extLst) {
+        return undefined;
+    }
+    for (const ext of findChildren(extLst, "a:ext")) {
+        const svgBlip = findChild(ext, "asvg:svgBlip") ?? findChildNs(ext, "svgBlip");
+        if (svgBlip) {
+            const svgEmbed = svgBlip.attributes["r:embed"];
+            if (svgEmbed) {
+                return svgEmbed;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/esm/modules/word/reader/form-field-parser.js

@@ -0,0 +1,82 @@
+/**
+ * DOCX Reader - Form Field Parser
+ *
+ * Standalone parser for `w:ffData` elements (legacy form fields).
+ * Used by the run content parser when encountering form-field-bearing fields.
+ */
+import { attrInt, attrVal, findChildNs, findChildrenNs } from "./parse-utils.js";
+/**
+ * Parse a `w:ffData` element into a `FormField`.
+ *
+ * Supports the three legacy form field types:
+ * - `w:textInput` → text field
+ * - `w:checkBox` → checkbox field
+ * - `w:ddList` → drop-down list field
+ *
+ * Common properties (name, enabled, helpText, statusText) are extracted.
+ *
+ * @returns A `FormField` object, or undefined if no recognized field type was found.
+ */
+export function parseFfData(el) {
+    const nameEl = findChildNs(el, "name");
+    const name = nameEl ? attrVal(nameEl, "val") : undefined;
+    const enabledEl = findChildNs(el, "enabled");
+    const enabled = enabledEl ? attrVal(enabledEl, "val") !== "0" : undefined;
+    const helpTextEl = findChildNs(el, "helpText");
+    const helpText = helpTextEl ? attrVal(helpTextEl, "val") : undefined;
+    const statusTextEl = findChildNs(el, "statusText");
+    const statusText = statusTextEl ? attrVal(statusTextEl, "val") : undefined;
+    // Text input
+    const textInputEl = findChildNs(el, "textInput");
+    if (textInputEl) {
+        const defEl = findChildNs(textInputEl, "default");
+        const maxLenEl = findChildNs(textInputEl, "maxLength");
+        const fmtEl = findChildNs(textInputEl, "format");
+        return {
+            type: "text",
+            name,
+            default: defEl ? attrVal(defEl, "val") : undefined,
+            maxLength: maxLenEl ? attrInt(maxLenEl, "val") : undefined,
+            format: fmtEl ? attrVal(fmtEl, "val") : undefined,
+            helpText,
+            statusText,
+            enabled
+        };
+    }
+    // CheckBox
+    const cbEl = findChildNs(el, "checkBox");
+    if (cbEl) {
+        const checkedEl = findChildNs(cbEl, "checked");
+        const defEl = findChildNs(cbEl, "default");
+        const sizeEl = findChildNs(cbEl, "size");
+        return {
+            type: "checkBox",
+            name,
+            checked: checkedEl ? attrVal(checkedEl, "val") !== "0" : undefined,
+            default: defEl ? attrVal(defEl, "val") !== "0" : undefined,
+            size: sizeEl ? attrInt(sizeEl, "val") : undefined
+        };
+    }
+    // Drop-down list
+    const ddlEl = findChildNs(el, "ddList");
+    if (ddlEl) {
+        const defEl = findChildNs(ddlEl, "default");
+        const entries = [];
+        for (const le of findChildrenNs(ddlEl, "listEntry")) {
+            const v = attrVal(le, "val");
+            if (v !== undefined) {
+                entries.push(v);
+            }
+        }
+        return {
+            type: "dropDown",
+            name,
+            entries: entries.length > 0 ? entries : undefined,
+            default: defEl ? attrInt(defEl, "val") : undefined,
+            helpText,
+            statusText,
+            enabled
+        };
+    }
+    return undefined;
+}

package/dist/esm/modules/word/reader/image-parsers.js

@@ -0,0 +1,291 @@
+/**
+ * DOCX Reader - Image Parsers
+ *
+ * Parsers for inline and floating images (wp:inline / wp:anchor).
+ * These are pure parsers that don't depend on ReaderContext.
+ */
+import { findChild, textContent } from "../../xml/dom.js";
+import {} from "../core/internal-utils.js";
+import { parseOutline, parseSrcRect, parseSvgBlip, parseXfrm } from "./drawing-helpers.js";
+import { safeParseInt, serializeElement } from "./parse-utils.js";
+function parseDrawingContent(drawingEl, content) {
+    // Look for wp:inline
+    const inlineEl = findChild(drawingEl, "wp:inline");
+    if (inlineEl) {
+        const extentEl = findChild(inlineEl, "wp:extent");
+        const docPrEl = findChild(inlineEl, "wp:docPr");
+        const graphicEl = findChild(inlineEl, "a:graphic");
+        const graphicDataEl = graphicEl ? findChild(graphicEl, "a:graphicData") : undefined;
+        const picEl = graphicDataEl ? findChild(graphicDataEl, "pic:pic") : undefined;
+        const blipFillEl = picEl ? findChild(picEl, "pic:blipFill") : undefined;
+        const blipEl = blipFillEl ? findChild(blipFillEl, "a:blip") : undefined;
+        const rId = blipEl?.attributes["r:embed"];
+        if (!rId) {
+            // Non-picture inline drawing (chart, SmartArt, OLE, generic shape).
+            // Preserve the entire <w:drawing>…</w:drawing> as an opaque run content
+            // so the element survives a parse → write round-trip even when the
+            // surrounding paragraph lives inside a table cell, header, footer or
+            // SDT — locations where the body-level floating-content extractor
+            // never runs.
+            content.push({
+                type: "opaqueRun",
+                rawXml: serializeElement(drawingEl)
+            });
+            return;
+        }
+        const cx = safeParseInt(extentEl?.attributes["cx"], 0);
+        const cy = safeParseInt(extentEl?.attributes["cy"], 0);
+        const img = {
+            type: "image",
+            rId,
+            width: cx,
+            height: cy,
+            altText: docPrEl?.attributes["descr"],
+            name: docPrEl?.attributes["name"],
+            drawingId: docPrEl ? safeParseInt(docPrEl.attributes["id"], 1) : undefined
+        };
+        // Parse xfrm for rotation/flip + outline
+        const spPrEl = picEl ? findChild(picEl, "pic:spPr") : undefined;
+        if (spPrEl) {
+            parseXfrm(spPrEl, img);
+            const outline = parseOutline(spPrEl);
+            if (outline) {
+                img.outline = outline;
+            }
+        }
+        // Source rectangle (crop)
+        if (blipFillEl) {
+            const srcRect = parseSrcRect(blipFillEl);
+            if (srcRect) {
+                img.srcRect = srcRect;
+            }
+        }
+        // SVG blip in a:extLst
+        if (blipEl) {
+            const svgRId = parseSvgBlip(blipEl);
+            if (svgRId) {
+                img.svgRId = svgRId;
+            }
+        }
+        content.push(img);
+    }
+}
+// =============================================================================
+// Floating Image Parser
+// =============================================================================
+function parseFloatingImage(anchorEl) {
+    const docPrEl = findChild(anchorEl, "wp:docPr");
+    const extentEl = findChild(anchorEl, "wp:extent");
+    const graphicEl = findChild(anchorEl, "a:graphic");
+    const graphicDataEl = graphicEl ? findChild(graphicEl, "a:graphicData") : undefined;
+    const picEl = graphicDataEl ? findChild(graphicDataEl, "pic:pic") : undefined;
+    const blipFillEl = picEl ? findChild(picEl, "pic:blipFill") : undefined;
+    const blipEl = blipFillEl ? findChild(blipFillEl, "a:blip") : undefined;
+    const rId = blipEl?.attributes["r:embed"];
+    if (!rId) {
+        return undefined;
+    }
+    const cx = safeParseInt(extentEl?.attributes["cx"], 0);
+    const cy = safeParseInt(extentEl?.attributes["cy"], 0);
+    const img = {
+        type: "floatingImage",
+        rId,
+        width: cx,
+        height: cy,
+        altText: docPrEl?.attributes["descr"],
+        name: docPrEl?.attributes["name"],
+        drawingId: docPrEl ? safeParseInt(docPrEl.attributes["id"], 1) : undefined
+    };
+    // Attributes
+    if (anchorEl.attributes["behindDoc"] === "1") {
+        img.behindDoc = true;
+    }
+    if (anchorEl.attributes["locked"] === "1") {
+        img.lockAnchor = true;
+    }
+    if (anchorEl.attributes["layoutInCell"] === "0") {
+        img.layoutInCell = false;
+    }
+    if (anchorEl.attributes["allowOverlap"] === "0") {
+        img.allowOverlap = false;
+    }
+    const rh = anchorEl.attributes["relativeHeight"];
+    if (rh) {
+        const n = parseInt(rh, 10);
+        if (Number.isFinite(n)) {
+            img.relativeHeight = n;
+        }
+    }
+    // Dist* — guard each parseInt against NaN so a hostile attribute
+    // never round-trips back into the output XML as the literal "NaN"
+    // (Word rejects such files).
+    const distT = anchorEl.attributes["distT"];
+    if (distT) {
+        const n = parseInt(distT, 10);
+        if (Number.isFinite(n)) {
+            img.distT = n;
+        }
+    }
+    const distB = anchorEl.attributes["distB"];
+    if (distB) {
+        const n = parseInt(distB, 10);
+        if (Number.isFinite(n)) {
+            img.distB = n;
+        }
+    }
+    const distL = anchorEl.attributes["distL"];
+    if (distL) {
+        const n = parseInt(distL, 10);
+        if (Number.isFinite(n)) {
+            img.distL = n;
+        }
+    }
+    const distR = anchorEl.attributes["distR"];
+    if (distR) {
+        const n = parseInt(distR, 10);
+        if (Number.isFinite(n)) {
+            img.distR = n;
+        }
+    }
+    // Simple positioning
+    if (anchorEl.attributes["simplePos"] === "1") {
+        const sposEl = findChild(anchorEl, "wp:simplePos");
+        if (sposEl) {
+            const x = safeParseInt(sposEl.attributes["x"], 0);
+            const y = safeParseInt(sposEl.attributes["y"], 0);
+            img.simplePos = { x, y };
+        }
+    }
+    // Horizontal position
+    const hPosEl = findChild(anchorEl, "wp:positionH");
+    if (hPosEl) {
+        const h = {
+            relativeTo: hPosEl.attributes["relativeFrom"]
+        };
+        const offsetEl = findChild(hPosEl, "wp:posOffset");
+        if (offsetEl) {
+            const n = parseInt(textContent(offsetEl), 10);
+            if (Number.isFinite(n)) {
+                h.offset = n;
+            }
+        }
+        const alignEl = findChild(hPosEl, "wp:align");
+        if (alignEl) {
+            h.align = textContent(alignEl);
+        }
+        img.horizontalPosition = h;
+    }
+    // Vertical position
+    const vPosEl = findChild(anchorEl, "wp:positionV");
+    if (vPosEl) {
+        const v = {
+            relativeTo: vPosEl.attributes["relativeFrom"]
+        };
+        const offsetEl = findChild(vPosEl, "wp:posOffset");
+        if (offsetEl) {
+            const n = parseInt(textContent(offsetEl), 10);
+            if (Number.isFinite(n)) {
+                v.offset = n;
+            }
+        }
+        const alignEl = findChild(vPosEl, "wp:align");
+        if (alignEl) {
+            v.align = textContent(alignEl);
+        }
+        img.verticalPosition = v;
+    }
+    // Wrap
+    for (const wrapChild of anchorEl.children) {
+        if (wrapChild.type !== "element") {
+            continue;
+        }
+        const wn = wrapChild.name;
+        let wrap;
+        if (wn === "wp:wrapSquare") {
+            wrap = {
+                style: "square",
+                side: wrapChild.attributes["wrapText"]
+            };
+        }
+        else if (wn === "wp:wrapTight") {
+            wrap = {
+                style: "tight",
+                side: wrapChild.attributes["wrapText"]
+            };
+        }
+        else if (wn === "wp:wrapThrough") {
+            wrap = {
+                style: "through",
+                side: wrapChild.attributes["wrapText"]
+            };
+        }
+        else if (wn === "wp:wrapTopAndBottom") {
+            wrap = { style: "topAndBottom" };
+        }
+        else if (wn === "wp:wrapNone") {
+            wrap = { style: "none" };
+        }
+        if (wrap) {
+            // Parse wrap margins
+            const distT = anchorEl.attributes["distT"];
+            const distB = anchorEl.attributes["distB"];
+            const distL = anchorEl.attributes["distL"];
+            const distR = anchorEl.attributes["distR"];
+            if (distT || distB || distL || distR) {
+                const margins = {};
+                if (distT) {
+                    const n = parseInt(distT, 10);
+                    if (Number.isFinite(n)) {
+                        margins.top = n;
+                    }
+                }
+                if (distB) {
+                    const n = parseInt(distB, 10);
+                    if (Number.isFinite(n)) {
+                        margins.bottom = n;
+                    }
+                }
+                if (distL) {
+                    const n = parseInt(distL, 10);
+                    if (Number.isFinite(n)) {
+                        margins.left = n;
+                    }
+                }
+                if (distR) {
+                    const n = parseInt(distR, 10);
+                    if (Number.isFinite(n)) {
+                        margins.right = n;
+                    }
+                }
+                wrap.margins = margins;
+            }
+            img.wrap = wrap;
+            break;
+        }
+    }
+    // Rotation/flip from spPr
+    const spPrEl = picEl ? findChild(picEl, "pic:spPr") : undefined;
+    if (spPrEl) {
+        parseXfrm(spPrEl, img);
+        const outline = parseOutline(spPrEl);
+        if (outline) {
+            img.outline = outline;
+        }
+    }
+    // SVG blip in a:extLst
+    if (blipEl) {
+        const svgRId = parseSvgBlip(blipEl);
+        if (svgRId) {
+            img.svgRId = svgRId;
+        }
+    }
+    // Source rectangle (crop)
+    if (blipFillEl) {
+        const srcRect = parseSrcRect(blipFillEl);
+        if (srcRect) {
+            img.srcRect = srcRect;
+        }
+    }
+    return img;
+}
+export { parseDrawingContent, parseFloatingImage };