@cj-tech-master/excelts 9.5.4 → 9.5.5

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

@@ -0,0 +1,111 @@
+/**
+ * DOCX Reader - SDT Helper Parsers
+ *
+ * Standalone parsers for SDT-related elements that don't depend on
+ * the main reader context (parseParagraph etc.):
+ * - `parseCheckBox` — w14:checkbox SDT specialization
+ * - `parseTocInstruction` — TOC field instruction string parser
+ */
+import { findChild } from "../../xml/dom.js";
+import {} from "../core/internal-utils.js";
+/**
+ * Parse a w14:checkbox SDT element.
+ *
+ * Handles `w14:checked`, `w14:checkedState`, `w14:uncheckedState`.
+ */
+export function parseCheckBox(checkBoxEl) {
+    const cb = { type: "checkBox" };
+    const checkedEl = findChild(checkBoxEl, "w14:checked");
+    if (checkedEl) {
+        const v = checkedEl.attributes["w14:val"] ?? checkedEl.attributes["val"];
+        cb.checked = v === "1" || v === "true";
+    }
+    const checkedStateEl = findChild(checkBoxEl, "w14:checkedState");
+    if (checkedStateEl) {
+        cb.checkedState = {
+            value: checkedStateEl.attributes["w14:val"] ?? checkedStateEl.attributes["val"] ?? "",
+            font: checkedStateEl.attributes["w14:font"] ?? checkedStateEl.attributes["font"]
+        };
+    }
+    const uncheckedStateEl = findChild(checkBoxEl, "w14:uncheckedState");
+    if (uncheckedStateEl) {
+        cb.uncheckedState = {
+            value: uncheckedStateEl.attributes["w14:val"] ?? uncheckedStateEl.attributes["val"] ?? "",
+            font: uncheckedStateEl.attributes["w14:font"] ?? uncheckedStateEl.attributes["font"]
+        };
+    }
+    return cb;
+}
+/**
+ * Parse a TOC field instruction string and populate the given TableOfContents object.
+ *
+ * Recognizes common TOC switches:
+ * - `\o "1-3"` — heading style range
+ * - `\h` — hyperlinks
+ * - `\c "label"` — caption label (table of figures)
+ * - `\s "id"` — sequence field identifier
+ * - `\p "."`/`"-"`/`"_"` — leader character
+ * - `\t "Style,Level;..."` — custom styles with levels
+ */
+export function parseTocInstruction(instr, toc) {
+    const trimmed = instr.trim();
+    if (!/^TOC\b/i.test(trimmed)) {
+        return;
+    }
+    // Match switches: \<letter> followed by either "quoted" or non-quoted non-switch token.
+    // The next-switch boundary must be respected: an unquoted value cannot start with \.
+    const switchRe = /\\(\w)(?:\s+"([^"]*)"|\s+([^\\\s][^\s]*))?/g;
+    let match;
+    while ((match = switchRe.exec(trimmed)) !== null) {
+        const switchName = match[1].toLowerCase();
+        const value = match[2] ?? match[3];
+        switch (switchName) {
+            case "o": // Heading level range e.g. "1-3"
+                if (value) {
+                    toc.headingStyleRange = value;
+                }
+                break;
+            case "h": // Hyperlinks
+                toc.hyperlink = true;
+                break;
+            case "c": // Caption label (table of figures)
+                if (value) {
+                    toc.captionLabel = value;
+                }
+                break;
+            case "s": // Sequence field identifier
+                if (value) {
+                    toc.sequenceFieldIdentifier = value;
+                }
+                break;
+            case "p": // Page-number leader or style separator
+                if (value === "." || value === "-" || value === "_") {
+                    toc.leader = "dot";
+                    if (value === "-") {
+                        toc.leader = "hyphen";
+                    }
+                    else if (value === "_") {
+                        toc.leader = "underscore";
+                    }
+                }
+                break;
+            case "t": {
+                // Styles with levels: "StyleName1,Level1;StyleName2,Level2;..."
+                if (!value) {
+                    break;
+                }
+                const items = [];
+                for (const part of value.split(";")) {
+                    const [styleName, levelStr] = part.split(",");
+                    if (styleName && levelStr) {
+                        items.push({ styleName: styleName.trim(), level: parseInt(levelStr, 10) });
+                    }
+                }
+                if (items.length > 0) {
+                    toc.stylesWithLevels = items;
+                }
+                break;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,263 @@
+/**
+ * DOCX Reader - Settings Parser
+ *
+ * Parses `word/settings.xml` (DocumentSettings).
+ * Extracted from the original `metadata-parsers.ts`.
+ */
+import { parseXml } from "../../xml/dom.js";
+import {} from "../core/internal-utils.js";
+import { attrInt, attrVal, findChildNs, findChildrenNs, parseNoteProperties, serializeElement, sidToHashAlgorithm } from "./parse-utils.js";
+export function parseSettingsXml(xmlStr) {
+    const doc = parseXml(xmlStr);
+    const root = doc.root;
+    const settings = {};
+    const zoomEl = findChildNs(root, "zoom");
+    if (zoomEl) {
+        settings.zoom = attrInt(zoomEl, "percent");
+    }
+    const tabEl = findChildNs(root, "defaultTabStop");
+    if (tabEl) {
+        settings.defaultTabStop = attrInt(tabEl, "val");
+    }
+    const csControlEl = findChildNs(root, "characterSpacingControl");
+    if (csControlEl) {
+        const v = attrVal(csControlEl, "val");
+        if (v === "doNotCompress" ||
+            v === "compressPunctuation" ||
+            v === "compressPunctuationAndJapaneseKana") {
+            settings.characterSpacingControl = v;
+        }
+    }
+    // Extended settings
+    if (findChildNs(root, "doNotTrackMoves")) {
+        settings.doNotTrackMoves = true;
+    }
+    if (findChildNs(root, "doNotTrackFormatting")) {
+        settings.doNotTrackFormatting = true;
+    }
+    if (findChildNs(root, "doNotDemoteNonCombiningChars")) {
+        settings.doNotDemoteAsianTextFirstLine = true;
+    }
+    const ssFontsEl = findChildNs(root, "saveSubsetFonts");
+    if (ssFontsEl) {
+        const v = attrVal(ssFontsEl, "val");
+        settings.saveSubsetFonts = v !== "0" && v !== "false";
+    }
+    if (findChildNs(root, "noPunctuationKerning")) {
+        settings.noPunctuationKerning = true;
+    }
+    if (findChildNs(root, "bordersDoNotSurroundHeader")) {
+        settings.bordersDoNotSurroundHeader = true;
+    }
+    if (findChildNs(root, "bordersDoNotSurroundFooter")) {
+        settings.bordersDoNotSurroundFooter = true;
+    }
+    const clickStyleEl = findChildNs(root, "clickAndTypeStyle");
+    if (clickStyleEl) {
+        settings.clickAndTypeStyle = attrVal(clickStyleEl, "val");
+    }
+    const spfEl = findChildNs(root, "stylePaneFormatFilter");
+    if (spfEl) {
+        settings.stylePaneFormatFilter = attrVal(spfEl, "val");
+    }
+    const spsEl = findChildNs(root, "stylePaneSortMethod");
+    if (spsEl) {
+        settings.stylePaneSortMethod = attrVal(spsEl, "val");
+    }
+    const tflEl = findChildNs(root, "themeFontLang");
+    if (tflEl) {
+        const tfl = {};
+        const v = attrVal(tflEl, "val");
+        if (v) {
+            tfl.val = v;
+        }
+        const ea = attrVal(tflEl, "eastAsia");
+        if (ea) {
+            tfl.eastAsia = ea;
+        }
+        const bd = attrVal(tflEl, "bidi");
+        if (bd) {
+            tfl.bidi = bd;
+        }
+        if (Object.keys(tfl).length > 0) {
+            settings.themeFontLang = tfl;
+        }
+    }
+    const dsEl = findChildNs(root, "decimalSymbol");
+    if (dsEl) {
+        settings.decimalSymbol = attrVal(dsEl, "val");
+    }
+    const lsEl = findChildNs(root, "listSeparator");
+    if (lsEl) {
+        settings.listSeparator = attrVal(lsEl, "val");
+    }
+    // RSID list
+    const rsidsEl = findChildNs(root, "rsids");
+    if (rsidsEl) {
+        const rsids = {};
+        const rootEl = findChildNs(rsidsEl, "rsidRoot");
+        if (rootEl) {
+            rsids.rsidRoot = attrVal(rootEl, "val");
+        }
+        const rsidList = [];
+        for (const rsidEl of findChildrenNs(rsidsEl, "rsid")) {
+            const v = attrVal(rsidEl, "val");
+            if (v) {
+                rsidList.push(v);
+            }
+        }
+        if (rsidList.length > 0) {
+            rsids.rsid = rsidList;
+        }
+        if (Object.keys(rsids).length > 0) {
+            settings.rsids = rsids;
+        }
+    }
+    if (findChildNs(root, "evenAndOddHeaders")) {
+        settings.evenAndOddHeaders = true;
+    }
+    if (findChildNs(root, "trackRevisions")) {
+        settings.trackRevisions = true;
+    }
+    if (findChildNs(root, "mirrorMargins")) {
+        settings.mirrorMargins = true;
+    }
+    if (findChildNs(root, "gutterAtTop")) {
+        settings.gutterAtTop = true;
+    }
+    if (findChildNs(root, "displayBackgroundShape")) {
+        settings.displayBackgroundShape = true;
+    }
+    if (findChildNs(root, "updateFields")) {
+        settings.updateFieldsOnOpen = true;
+    }
+    // Hyphenation
+    const autoHyphEl = findChildNs(root, "autoHyphenation");
+    if (autoHyphEl) {
+        settings.autoHyphenation = true;
+        const hyph = { autoHyphenation: true };
+        const hzEl = findChildNs(root, "hyphenationZone");
+        if (hzEl) {
+            hyph.hyphenationZone = attrInt(hzEl, "val");
+        }
+        const chlEl = findChildNs(root, "consecutiveHyphenLimit");
+        if (chlEl) {
+            hyph.consecutiveHyphenLimit = attrInt(chlEl, "val");
+        }
+        if (findChildNs(root, "doNotHyphenateCaps")) {
+            hyph.doNotHyphenateCaps = true;
+        }
+        settings.hyphenation = hyph;
+    }
+    // Document protection
+    const protEl = findChildNs(root, "documentProtection");
+    if (protEl) {
+        settings.documentProtection = {
+            type: (attrVal(protEl, "edit") ?? "none"),
+            edit: attrVal(protEl, "edit") ?? undefined,
+            enforcement: attrVal(protEl, "enforcement") === "1",
+            formatting: attrVal(protEl, "formatting") === "1" ? true : undefined,
+            hashAlgorithm: sidToHashAlgorithm(attrVal(protEl, "cryptAlgorithmSid")),
+            hashValue: attrVal(protEl, "hash") ?? undefined,
+            saltValue: attrVal(protEl, "salt") ?? undefined,
+            spinCount: attrVal(protEl, "cryptSpinCount")
+                ? parseInt(attrVal(protEl, "cryptSpinCount"), 10)
+                : undefined
+        };
+    }
+    const compatEl = findChildNs(root, "compat");
+    if (compatEl) {
+        const compatSettings = [];
+        const compatFlags = [];
+        for (const csEl of compatEl.children) {
+            if (csEl.type !== "element") {
+                continue;
+            }
+            const localName = csEl.name.replace(/^w:/, "");
+            if (localName === "compatSetting") {
+                const name = attrVal(csEl, "name");
+                const uri = attrVal(csEl, "uri");
+                const val = attrVal(csEl, "val");
+                if (name === "compatibilityMode" && val !== undefined) {
+                    settings.compatibilityMode = parseInt(val, 10);
+                }
+                else if (name !== undefined && uri !== undefined && val !== undefined) {
+                    compatSettings.push({ name, uri, val });
+                }
+            }
+            else {
+                // Legacy compat flags (w:useFELayout, w:balanceSingleByteDoubleByteWidth, etc.)
+                compatFlags.push({ name: localName, val: attrVal(csEl, "val") });
+            }
+        }
+        if (compatSettings.length > 0) {
+            settings.compatSettings = compatSettings;
+        }
+        if (compatFlags.length > 0) {
+            settings.compatFlags = compatFlags;
+        }
+    }
+    // Mail merge settings (preserve as raw XML)
+    const mailMergeEl = findChildNs(root, "mailMerge");
+    if (mailMergeEl) {
+        settings.mailMergeRawXml = serializeElement(mailMergeEl);
+    }
+    // Write protection
+    const writeProtectionEl = findChildNs(root, "writeProtection");
+    if (writeProtectionEl) {
+        const wp = {};
+        const wpMut = wp;
+        const recommended = attrVal(writeProtectionEl, "recommended");
+        if (recommended === "1" || recommended === "true") {
+            wpMut.recommended = true;
+        }
+        const algName = attrVal(writeProtectionEl, "algorithmName");
+        if (algName) {
+            wpMut.algorithmName = algName;
+        }
+        const hashValue = attrVal(writeProtectionEl, "hashValue");
+        if (hashValue) {
+            wpMut.hashValue = hashValue;
+        }
+        const saltValue = attrVal(writeProtectionEl, "saltValue");
+        if (saltValue) {
+            wpMut.saltValue = saltValue;
+        }
+        const spinCount = attrInt(writeProtectionEl, "spinCount");
+        if (spinCount !== undefined) {
+            wpMut.spinCount = spinCount;
+        }
+        settings.writeProtection = wp;
+    }
+    // Document variables
+    const docVarsEl = findChildNs(root, "docVars");
+    if (docVarsEl) {
+        const vars = new Map();
+        for (const dvEl of findChildrenNs(docVarsEl, "docVar")) {
+            const name = attrVal(dvEl, "name");
+            const val = attrVal(dvEl, "val");
+            if (name !== undefined && val !== undefined) {
+                vars.set(name, val);
+            }
+        }
+        if (vars.size > 0) {
+            settings.docVars = vars;
+        }
+    }
+    // Footnote/endnote properties at document level
+    const fnPrEl = findChildNs(root, "footnotePr");
+    if (fnPrEl) {
+        const fnProps = parseNoteProperties(fnPrEl);
+        if (fnProps) {
+            settings.footnoteProperties = fnProps;
+        }
+    }
+    const enPrEl = findChildNs(root, "endnotePr");
+    if (enPrEl) {
+        const enProps = parseNoteProperties(enPrEl);
+        if (enProps) {
+            settings.endnoteProperties = enProps;
+        }
+    }
+    return settings;
+}

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

@@ -0,0 +1,147 @@
+/**
+ * DOCX Reader - Styles Parser
+ *
+ * Parses `word/styles.xml` (`DocDefaults` + `StyleDef[]`). Splits out from
+ * the legacy `styles-numbering-parsers.ts` to mirror the writer side
+ * (`styles-writer.ts` and `numbering-writer.ts` are already separate).
+ */
+import { parseXml } from "../../xml/dom.js";
+import {} from "../core/internal-utils.js";
+import { parseParagraphProperties } from "./paragraph-section-parsers.js";
+import { attrInt, attrVal, findChildNs, findChildrenNs } from "./parse-utils.js";
+import { parseRunProperties, parseShading } from "./properties-parsers.js";
+import { parseTableBorders, parseTableProperties } from "./table-properties-parsers.js";
+export function parseStyles(xmlStr) {
+    const doc = parseXml(xmlStr);
+    const root = doc.root;
+    let docDefaults;
+    const styles = [];
+    const ddEl = findChildNs(root, "docDefaults");
+    if (ddEl) {
+        const dd = {};
+        const rPrDefaultEl = findChildNs(ddEl, "rPrDefault");
+        if (rPrDefaultEl) {
+            const rPrEl = findChildNs(rPrDefaultEl, "rPr");
+            if (rPrEl) {
+                dd.runProperties = parseRunProperties(rPrEl);
+            }
+        }
+        const pPrDefaultEl = findChildNs(ddEl, "pPrDefault");
+        if (pPrDefaultEl) {
+            const pPrEl = findChildNs(pPrDefaultEl, "pPr");
+            if (pPrEl) {
+                dd.paragraphProperties = parseParagraphProperties(pPrEl);
+            }
+        }
+        docDefaults = dd;
+    }
+    for (const styleEl of findChildrenNs(root, "style")) {
+        const s = {};
+        s.type = attrVal(styleEl, "type");
+        s.styleId = attrVal(styleEl, "styleId") ?? "";
+        s.isDefault = attrVal(styleEl, "default") === "1";
+        if (attrVal(styleEl, "customStyle") === "1") {
+            s.customStyle = true;
+        }
+        const nameEl = findChildNs(styleEl, "name");
+        s.name = nameEl ? (attrVal(nameEl, "val") ?? "") : "";
+        const basedOnEl = findChildNs(styleEl, "basedOn");
+        if (basedOnEl) {
+            s.basedOn = attrVal(basedOnEl, "val");
+        }
+        const nextEl = findChildNs(styleEl, "next");
+        if (nextEl) {
+            s.next = attrVal(nextEl, "val");
+        }
+        const linkEl = findChildNs(styleEl, "link");
+        if (linkEl) {
+            s.link = attrVal(linkEl, "val");
+        }
+        const uiPrEl = findChildNs(styleEl, "uiPriority");
+        if (uiPrEl) {
+            s.uiPriority = attrInt(uiPrEl, "val");
+        }
+        if (findChildNs(styleEl, "qFormat")) {
+            s.qFormat = true;
+        }
+        if (findChildNs(styleEl, "semiHidden")) {
+            s.semiHidden = true;
+        }
+        if (findChildNs(styleEl, "unhideWhenUsed")) {
+            s.unhideWhenUsed = true;
+        }
+        if (findChildNs(styleEl, "hidden")) {
+            s.hidden = true;
+        }
+        if (findChildNs(styleEl, "locked")) {
+            s.locked = true;
+        }
+        if (findChildNs(styleEl, "autoRedefine")) {
+            s.autoRedefine = true;
+        }
+        const pPrEl = findChildNs(styleEl, "pPr");
+        if (pPrEl) {
+            s.paragraphProperties = parseParagraphProperties(pPrEl);
+        }
+        const rPrEl = findChildNs(styleEl, "rPr");
+        if (rPrEl) {
+            s.runProperties = parseRunProperties(rPrEl);
+        }
+        // Table properties for table styles
+        const tblPrEl = findChildNs(styleEl, "tblPr");
+        if (tblPrEl) {
+            s.tableProperties = parseTableProperties(tblPrEl);
+        }
+        // Table style conditional formats
+        const tblStylePrs = findChildrenNs(styleEl, "tblStylePr");
+        if (tblStylePrs.length > 0) {
+            const conditions = [];
+            for (const tsp of tblStylePrs) {
+                const cond = {
+                    type: attrVal(tsp, "type")
+                };
+                const cpPr = findChildNs(tsp, "pPr");
+                if (cpPr) {
+                    cond.paragraphProperties = parseParagraphProperties(cpPr);
+                }
+                const crPr = findChildNs(tsp, "rPr");
+                if (crPr) {
+                    cond.runProperties = parseRunProperties(crPr);
+                }
+                const ctblPr = findChildNs(tsp, "tblPr");
+                if (ctblPr) {
+                    cond.tableProperties = parseTableProperties(ctblPr);
+                }
+                const ctrPr = findChildNs(tsp, "trPr");
+                if (ctrPr) {
+                    const rp = {};
+                    const hEl = findChildNs(ctrPr, "trHeight");
+                    if (hEl) {
+                        rp.height = {
+                            value: attrInt(hEl, "val") ?? 0,
+                            rule: attrVal(hEl, "hRule")
+                        };
+                    }
+                    cond.rowProperties = rp;
+                }
+                const ctcPr = findChildNs(tsp, "tcPr");
+                if (ctcPr) {
+                    const cp = {};
+                    const bEl = findChildNs(ctcPr, "tcBorders");
+                    if (bEl) {
+                        cp.borders = parseTableBorders(bEl);
+                    }
+                    const shd = findChildNs(ctcPr, "shd");
+                    if (shd) {
+                        cp.shading = parseShading(shd);
+                    }
+                    cond.cellProperties = cp;
+                }
+                conditions.push(cond);
+            }
+            s.tableStyleConditions = conditions;
+        }
+        styles.push(s);
+    }
+    return { docDefaults, styles };
+}