@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/cjs/modules/word/reader/math-parser.js

@@ -0,0 +1,424 @@
+"use strict";
+/**
+ * DOCX Reader - Math Parser
+ *
+ * Parses OMML (Office Math Markup Language) elements (m:* namespace) into
+ * MathContent / MathBlock model objects. Each m:* element is mapped to its
+ * corresponding model interface (MathFraction, MathRadical, MathDelimiter, etc).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMathContent = parseMathContent;
+exports.parseMathBlock = parseMathBlock;
+const dom_1 = require("../../xml/dom.js");
+const parse_utils_1 = require("./parse-utils");
+// =============================================================================
+// Math Parser
+// =============================================================================
+function parseMathContent(el) {
+    const result = [];
+    for (const child of el.children) {
+        if (child.type !== "element") {
+            continue;
+        }
+        const name = child.name.replace(/^m:/, "");
+        switch (name) {
+            case "r": {
+                // Math run
+                const tEl = (0, parse_utils_1.findChildLocal)(child, "t");
+                const mrPrEl = (0, parse_utils_1.findChildLocal)(child, "rPr");
+                const mr = { type: "mathRun", text: tEl ? (0, dom_1.textContent)(tEl) : "" };
+                if (mrPrEl) {
+                    const props = {};
+                    const sty = (0, parse_utils_1.findChildLocal)(mrPrEl, "sty");
+                    if (sty) {
+                        const v = sty.attributes["m:val"] ?? sty.attributes["val"];
+                        if (v === "p" || v === "b") {
+                            props.italic = false;
+                        }
+                        if (v === "b" || v === "bi") {
+                            props.bold = true;
+                        }
+                    }
+                    if (Object.keys(props).length > 0) {
+                        mr.properties = props;
+                    }
+                }
+                result.push(mr);
+                break;
+            }
+            case "f": {
+                const fPrEl = (0, parse_utils_1.findChildLocal)(child, "fPr");
+                const num = (0, parse_utils_1.findChildLocal)(child, "num");
+                const den = (0, parse_utils_1.findChildLocal)(child, "den");
+                const frac = {
+                    type: "mathFraction",
+                    numerator: num ? parseMathContent(num) : [],
+                    denominator: den ? parseMathContent(den) : []
+                };
+                if (fPrEl) {
+                    const typeEl = (0, parse_utils_1.findChildLocal)(fPrEl, "type");
+                    if (typeEl) {
+                        frac.fractionType = (typeEl.attributes["m:val"] ??
+                            typeEl.attributes["val"]);
+                    }
+                }
+                result.push(frac);
+                break;
+            }
+            case "sSup": {
+                const base = (0, parse_utils_1.findChildLocal)(child, "e");
+                const sup = (0, parse_utils_1.findChildLocal)(child, "sup");
+                result.push({
+                    type: "mathSuperScript",
+                    base: base ? parseMathContent(base) : [],
+                    superScript: sup ? parseMathContent(sup) : []
+                });
+                break;
+            }
+            case "sSub": {
+                const base = (0, parse_utils_1.findChildLocal)(child, "e");
+                const sub = (0, parse_utils_1.findChildLocal)(child, "sub");
+                result.push({
+                    type: "mathSubScript",
+                    base: base ? parseMathContent(base) : [],
+                    subScript: sub ? parseMathContent(sub) : []
+                });
+                break;
+            }
+            case "sSubSup": {
+                const base = (0, parse_utils_1.findChildLocal)(child, "e");
+                const sub = (0, parse_utils_1.findChildLocal)(child, "sub");
+                const sup = (0, parse_utils_1.findChildLocal)(child, "sup");
+                result.push({
+                    type: "mathSubSuperScript",
+                    base: base ? parseMathContent(base) : [],
+                    subScript: sub ? parseMathContent(sub) : [],
+                    superScript: sup ? parseMathContent(sup) : []
+                });
+                break;
+            }
+            case "sPre": {
+                const base = (0, parse_utils_1.findChildLocal)(child, "e");
+                const sub = (0, parse_utils_1.findChildLocal)(child, "sub");
+                const sup = (0, parse_utils_1.findChildLocal)(child, "sup");
+                result.push({
+                    type: "mathPreSubSuperScript",
+                    base: base ? parseMathContent(base) : [],
+                    preSubScript: sub ? parseMathContent(sub) : [],
+                    preSuperScript: sup ? parseMathContent(sup) : []
+                });
+                break;
+            }
+            case "phant": {
+                const eEl = (0, parse_utils_1.findChildLocal)(child, "e");
+                const phantPrEl = (0, parse_utils_1.findChildLocal)(child, "phantPr");
+                const ph = {
+                    type: "mathPhantom",
+                    content: eEl ? parseMathContent(eEl) : []
+                };
+                if (phantPrEl) {
+                    const boolAttr = (name) => {
+                        const el = (0, parse_utils_1.findChildLocal)(phantPrEl, name);
+                        if (!el) {
+                            return false;
+                        }
+                        const v = (0, parse_utils_1.attrLocal)(el, "val");
+                        return v !== "0" && v !== "false";
+                    };
+                    if (boolAttr("show")) {
+                        ph.show = true;
+                    }
+                    if (boolAttr("zeroWid")) {
+                        ph.zeroWidth = true;
+                    }
+                    if (boolAttr("zeroAsc")) {
+                        ph.zeroAscent = true;
+                    }
+                    if (boolAttr("zeroDesc")) {
+                        ph.zeroDescent = true;
+                    }
+                    if (boolAttr("transp")) {
+                        ph.transparent = true;
+                    }
+                }
+                result.push(ph);
+                break;
+            }
+            case "groupChr": {
+                const eEl = (0, parse_utils_1.findChildLocal)(child, "e");
+                const prEl = (0, parse_utils_1.findChildLocal)(child, "groupChrPr");
+                const g = {
+                    type: "mathGroupChar",
+                    base: eEl ? parseMathContent(eEl) : []
+                };
+                if (prEl) {
+                    const chrEl = (0, parse_utils_1.findChildLocal)(prEl, "chr");
+                    if (chrEl) {
+                        g.char = (0, parse_utils_1.attrLocal)(chrEl, "val");
+                    }
+                    const posEl = (0, parse_utils_1.findChildLocal)(prEl, "pos");
+                    if (posEl) {
+                        const v = (0, parse_utils_1.attrLocal)(posEl, "val");
+                        if (v === "top" || v === "bottom") {
+                            g.position = v;
+                        }
+                    }
+                    const vjcEl = (0, parse_utils_1.findChildLocal)(prEl, "vertJc");
+                    if (vjcEl) {
+                        const v = (0, parse_utils_1.attrLocal)(vjcEl, "val");
+                        if (v === "top" || v === "center" || v === "bottom") {
+                            g.verticalAlign = v;
+                        }
+                    }
+                }
+                result.push(g);
+                break;
+            }
+            case "borderBox": {
+                const eEl = (0, parse_utils_1.findChildLocal)(child, "e");
+                const prEl = (0, parse_utils_1.findChildLocal)(child, "borderBoxPr");
+                const b = {
+                    type: "mathBorderBox",
+                    content: eEl ? parseMathContent(eEl) : []
+                };
+                if (prEl) {
+                    const boolAttr = (name) => {
+                        const el = (0, parse_utils_1.findChildLocal)(prEl, name);
+                        if (!el) {
+                            return false;
+                        }
+                        const v = (0, parse_utils_1.attrLocal)(el, "val");
+                        return v !== "0" && v !== "false";
+                    };
+                    if (boolAttr("hideTop")) {
+                        b.hideTop = true;
+                    }
+                    if (boolAttr("hideBot")) {
+                        b.hideBottom = true;
+                    }
+                    if (boolAttr("hideLeft")) {
+                        b.hideLeft = true;
+                    }
+                    if (boolAttr("hideRight")) {
+                        b.hideRight = true;
+                    }
+                    if (boolAttr("strikeBLTR")) {
+                        b.strikeBlTr = true;
+                    }
+                    if (boolAttr("strikeTLBR")) {
+                        b.strikeTlBr = true;
+                    }
+                    if (boolAttr("strikeH")) {
+                        b.strikeH = true;
+                    }
+                    if (boolAttr("strikeV")) {
+                        b.strikeV = true;
+                    }
+                }
+                result.push(b);
+                break;
+            }
+            case "rad": {
+                const radPrEl = (0, parse_utils_1.findChildLocal)(child, "radPr");
+                const deg = (0, parse_utils_1.findChildLocal)(child, "deg");
+                const e = (0, parse_utils_1.findChildLocal)(child, "e");
+                const rad = {
+                    type: "mathRadical",
+                    content: e ? parseMathContent(e) : []
+                };
+                if (deg) {
+                    rad.degree = parseMathContent(deg);
+                }
+                if (radPrEl) {
+                    const hd = (0, parse_utils_1.findChildLocal)(radPrEl, "degHide");
+                    if (hd) {
+                        const v = hd.attributes["m:val"] ?? hd.attributes["val"];
+                        if (v === "1" || v === "on" || v === "true") {
+                            rad.hideDegree = true;
+                        }
+                    }
+                }
+                result.push(rad);
+                break;
+            }
+            case "d": {
+                const dPrEl = (0, parse_utils_1.findChildLocal)(child, "dPr");
+                const delim = {
+                    type: "mathDelimiter",
+                    content: []
+                };
+                if (dPrEl) {
+                    const bc = (0, parse_utils_1.findChildLocal)(dPrEl, "begChr");
+                    if (bc) {
+                        delim.beginChar = bc.attributes["m:val"] ?? bc.attributes["val"];
+                    }
+                    const ec = (0, parse_utils_1.findChildLocal)(dPrEl, "endChr");
+                    if (ec) {
+                        delim.endChar = ec.attributes["m:val"] ?? ec.attributes["val"];
+                    }
+                    const sc = (0, parse_utils_1.findChildLocal)(dPrEl, "sepChr");
+                    if (sc) {
+                        delim.separatorChar = sc.attributes["m:val"] ?? sc.attributes["val"];
+                    }
+                }
+                for (const eEl of (0, parse_utils_1.findChildrenLocal)(child, "e")) {
+                    delim.content.push(parseMathContent(eEl));
+                }
+                result.push(delim);
+                break;
+            }
+            case "nary": {
+                const nPrEl = (0, parse_utils_1.findChildLocal)(child, "naryPr");
+                const sub = (0, parse_utils_1.findChildLocal)(child, "sub");
+                const sup = (0, parse_utils_1.findChildLocal)(child, "sup");
+                const e = (0, parse_utils_1.findChildLocal)(child, "e");
+                const nary = {
+                    type: "mathNary",
+                    content: e ? parseMathContent(e) : []
+                };
+                if (sub) {
+                    nary.sub = parseMathContent(sub);
+                }
+                if (sup) {
+                    nary.sup = parseMathContent(sup);
+                }
+                if (nPrEl) {
+                    const chrEl = (0, parse_utils_1.findChildLocal)(nPrEl, "chr");
+                    if (chrEl) {
+                        nary.char = chrEl.attributes["m:val"] ?? chrEl.attributes["val"];
+                    }
+                    const limLoc = (0, parse_utils_1.findChildLocal)(nPrEl, "limLoc");
+                    if (limLoc) {
+                        nary.limitsLocation = (limLoc.attributes["m:val"] ??
+                            limLoc.attributes["val"]);
+                    }
+                    const sh = (0, parse_utils_1.findChildLocal)(nPrEl, "supHide");
+                    if (sh && (sh.attributes["m:val"] ?? sh.attributes["val"]) === "1") {
+                        nary.supHide = true;
+                    }
+                    const sbh = (0, parse_utils_1.findChildLocal)(nPrEl, "subHide");
+                    if (sbh && (sbh.attributes["m:val"] ?? sbh.attributes["val"]) === "1") {
+                        nary.subHide = true;
+                    }
+                }
+                result.push(nary);
+                break;
+            }
+            case "func": {
+                const fName = (0, parse_utils_1.findChildLocal)(child, "fName");
+                const e = (0, parse_utils_1.findChildLocal)(child, "e");
+                result.push({
+                    type: "mathFunction",
+                    name: fName ? parseMathContent(fName) : [],
+                    content: e ? parseMathContent(e) : []
+                });
+                break;
+            }
+            case "limLow": {
+                const base = (0, parse_utils_1.findChildLocal)(child, "e");
+                const lim = (0, parse_utils_1.findChildLocal)(child, "lim");
+                result.push({
+                    type: "mathLimit",
+                    limitType: "lower",
+                    base: base ? parseMathContent(base) : [],
+                    limit: lim ? parseMathContent(lim) : []
+                });
+                break;
+            }
+            case "limUpp": {
+                const base = (0, parse_utils_1.findChildLocal)(child, "e");
+                const lim = (0, parse_utils_1.findChildLocal)(child, "lim");
+                result.push({
+                    type: "mathLimit",
+                    limitType: "upper",
+                    base: base ? parseMathContent(base) : [],
+                    limit: lim ? parseMathContent(lim) : []
+                });
+                break;
+            }
+            case "m": {
+                // Matrix
+                const rows = [];
+                for (const mrEl of (0, parse_utils_1.findChildrenLocal)(child, "mr")) {
+                    const row = [];
+                    for (const eEl of (0, parse_utils_1.findChildrenLocal)(mrEl, "e")) {
+                        row.push(parseMathContent(eEl));
+                    }
+                    rows.push(row);
+                }
+                result.push({ type: "mathMatrix", rows });
+                break;
+            }
+            case "acc": {
+                const accPrEl = (0, parse_utils_1.findChildLocal)(child, "accPr");
+                const e = (0, parse_utils_1.findChildLocal)(child, "e");
+                const acc = {
+                    type: "mathAccent",
+                    content: e ? parseMathContent(e) : []
+                };
+                if (accPrEl) {
+                    const chr = (0, parse_utils_1.findChildLocal)(accPrEl, "chr");
+                    if (chr) {
+                        acc.char = chr.attributes["m:val"] ?? chr.attributes["val"];
+                    }
+                }
+                result.push(acc);
+                break;
+            }
+            case "bar": {
+                const barPrEl = (0, parse_utils_1.findChildLocal)(child, "barPr");
+                const e = (0, parse_utils_1.findChildLocal)(child, "e");
+                let position = "top";
+                if (barPrEl) {
+                    const pos = (0, parse_utils_1.findChildLocal)(barPrEl, "pos");
+                    if (pos) {
+                        const v = pos.attributes["m:val"] ?? pos.attributes["val"];
+                        if (v === "bot") {
+                            position = "bottom";
+                        }
+                    }
+                }
+                result.push({
+                    type: "mathBar",
+                    position,
+                    content: e ? parseMathContent(e) : []
+                });
+                break;
+            }
+            case "box": {
+                const e = (0, parse_utils_1.findChildLocal)(child, "e");
+                result.push({
+                    type: "mathBox",
+                    content: e ? parseMathContent(e) : []
+                });
+                break;
+            }
+            case "eqArr": {
+                const rows = [];
+                for (const eEl of (0, parse_utils_1.findChildrenLocal)(child, "e")) {
+                    rows.push(parseMathContent(eEl));
+                }
+                result.push({ type: "mathEquationArray", rows });
+                break;
+            }
+            // Recurse into oMath elements
+            case "oMath": {
+                result.push(...parseMathContent(child));
+                break;
+            }
+        }
+    }
+    return result;
+}
+function parseMathBlock(oMathParaEl) {
+    const content = [];
+    for (const child of oMathParaEl.children) {
+        if (child.type === "element") {
+            const n = child.name.replace(/^m:/, "");
+            if (n === "oMath") {
+                content.push(...parseMathContent(child));
+            }
+        }
+    }
+    return { type: "math", content };
+}

package/dist/cjs/modules/word/reader/metadata-parsers.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * DOCX Reader - Misc Metadata Parsers
+ *
+ * Parses small document metadata XML files that don't justify their own files:
+ * - webSettings.xml (WebSettings)
+ * - people.xml (PersonInfo[])
+ *
+ * Theme and settings parsing live in `theme-parser.ts` and `settings-parser.ts`.
+ * Re-exports them for backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSettingsXml = exports.parseThemeXml = void 0;
+exports.parseWebSettings = parseWebSettings;
+exports.parsePeople = parsePeople;
+const dom_1 = require("../../xml/dom.js");
+const parse_utils_1 = require("./parse-utils");
+// Backward-compatible re-exports.
+var theme_parser_1 = require("./theme-parser");
+Object.defineProperty(exports, "parseThemeXml", { enumerable: true, get: function () { return theme_parser_1.parseThemeXml; } });
+var settings_parser_1 = require("./settings-parser");
+Object.defineProperty(exports, "parseSettingsXml", { enumerable: true, get: function () { return settings_parser_1.parseSettingsXml; } });
+/** Parse word/webSettings.xml. */
+function parseWebSettings(xmlStr) {
+    const doc = (0, dom_1.parseXml)(xmlStr);
+    const root = doc.root;
+    const ws = {};
+    const ofbEl = (0, parse_utils_1.findChildNs)(root, "optimizeForBrowser");
+    if (ofbEl) {
+        const ofb = {};
+        const target = (0, parse_utils_1.attrVal)(ofbEl, "target");
+        if (target) {
+            ofb.target = target;
+        }
+        const mv = (0, parse_utils_1.attrInt)(ofbEl, "majorVersion");
+        if (mv !== undefined) {
+            ofb.majorVersion = mv;
+        }
+        ws.optimizeForBrowser = ofb;
+    }
+    if ((0, parse_utils_1.findChildNs)(root, "allowPNG")) {
+        ws.allowPng = true;
+    }
+    if ((0, parse_utils_1.findChildNs)(root, "relyOnVML")) {
+        ws.relyOnVml = true;
+    }
+    if ((0, parse_utils_1.findChildNs)(root, "doNotSaveAsSingleFile")) {
+        ws.doNotSaveAsSingleFile = true;
+    }
+    if ((0, parse_utils_1.findChildNs)(root, "doNotOrganizeInFolder")) {
+        ws.doNotOrganizeInFolder = true;
+    }
+    if ((0, parse_utils_1.findChildNs)(root, "useTargetMachineType")) {
+        ws.useTargetMachineType = true;
+    }
+    return ws;
+}
+/** Parse word/people.xml. */
+function parsePeople(xmlStr) {
+    const doc = (0, dom_1.parseXml)(xmlStr);
+    const root = doc.root;
+    const people = [];
+    for (const personEl of root.children) {
+        if (personEl.type !== "element") {
+            continue;
+        }
+        const author = personEl.attributes["w15:author"] ?? personEl.attributes["author"];
+        if (!author) {
+            continue;
+        }
+        const info = { author };
+        // presenceInfo
+        for (const child of personEl.children) {
+            if (child.type === "element" && child.name.endsWith("presenceInfo")) {
+                const pi = {};
+                const providerId = child.attributes["w15:providerId"] ?? child.attributes["providerId"];
+                if (providerId) {
+                    pi.providerId = providerId;
+                }
+                const userId = child.attributes["w15:userId"] ?? child.attributes["userId"];
+                if (userId) {
+                    pi.userId = userId;
+                }
+                if (Object.keys(pi).length > 0) {
+                    info.presenceInfo = pi;
+                }
+                break;
+            }
+        }
+        people.push(info);
+    }
+    return people;
+}

package/dist/cjs/modules/word/reader/numbering-parser.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * DOCX Reader - Numbering Parser
+ *
+ * Parses `word/numbering.xml`. Splits out from the legacy
+ * `styles-numbering-parsers.ts` to mirror the writer side
+ * (`numbering-writer.ts` is already separate from `styles-writer.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumberingXml = parseNumberingXml;
+const dom_1 = require("../../xml/dom.js");
+const units_1 = require("../units");
+const paragraph_section_parsers_1 = require("./paragraph-section-parsers");
+const parse_utils_1 = require("./parse-utils");
+const properties_parsers_1 = require("./properties-parsers");
+function parseNumberingXml(xmlStr) {
+    const doc = (0, dom_1.parseXml)(xmlStr);
+    const root = doc.root;
+    const abstractNums = [];
+    const instances = [];
+    const numPicBullets = [];
+    // Parse picture bullets
+    for (const pbEl of (0, parse_utils_1.findChildrenNs)(root, "numPicBullet")) {
+        const id = (0, parse_utils_1.attrInt)(pbEl, "numPicBulletId");
+        if (id === undefined) {
+            continue;
+        }
+        const pb = { id };
+        // Try to extract VML shape info
+        const pictEl = (0, parse_utils_1.findChildNs)(pbEl, "pict");
+        if (pictEl) {
+            // Preserve raw VML for complete fidelity
+            let rawVml = "";
+            for (const child of pictEl.children) {
+                if (child.type === "element") {
+                    rawVml += (0, parse_utils_1.serializeElement)(child);
+                }
+            }
+            if (rawVml) {
+                pb.rawVmlXml = rawVml;
+            }
+            // Extract rId from v:imagedata
+            const shapeEl = (0, dom_1.findChild)(pictEl, "v:shape");
+            if (shapeEl) {
+                const imgDataEl = (0, dom_1.findChild)(shapeEl, "v:imagedata");
+                if (imgDataEl) {
+                    const rId = imgDataEl.attributes["r:id"] ?? imgDataEl.attributes["r:pict"];
+                    if (rId) {
+                        pb.rId = rId;
+                    }
+                }
+                // Extract width/height from style
+                const style = shapeEl.attributes["style"];
+                if (style) {
+                    const wMatch = /width:([\d.]+)pt/i.exec(style);
+                    const hMatch = /height:([\d.]+)pt/i.exec(style);
+                    if (wMatch) {
+                        pb.width = (0, units_1.ptToEmu)(parseFloat(wMatch[1]));
+                    }
+                    if (hMatch) {
+                        pb.height = (0, units_1.ptToEmu)(parseFloat(hMatch[1]));
+                    }
+                }
+            }
+        }
+        numPicBullets.push(pb);
+    }
+    for (const absEl of (0, parse_utils_1.findChildrenNs)(root, "abstractNum")) {
+        const levels = [];
+        for (const lvlEl of (0, parse_utils_1.findChildrenNs)(absEl, "lvl")) {
+            levels.push(parseLevel(lvlEl));
+        }
+        const abs = {
+            abstractNumId: (0, parse_utils_1.attrInt)(absEl, "abstractNumId") ?? 0,
+            levels
+        };
+        const mltEl = (0, parse_utils_1.findChildNs)(absEl, "multiLevelType");
+        if (mltEl) {
+            abs.multiLevelType = (0, parse_utils_1.attrVal)(mltEl, "val");
+        }
+        const numStyleLinkEl = (0, parse_utils_1.findChildNs)(absEl, "numStyleLink");
+        if (numStyleLinkEl) {
+            abs.numStyleLink = (0, parse_utils_1.attrVal)(numStyleLinkEl, "val");
+        }
+        const styleLinkEl = (0, parse_utils_1.findChildNs)(absEl, "styleLink");
+        if (styleLinkEl) {
+            abs.styleLink = (0, parse_utils_1.attrVal)(styleLinkEl, "val");
+        }
+        abstractNums.push(abs);
+    }
+    for (const numEl of (0, parse_utils_1.findChildrenNs)(root, "num")) {
+        const absIdEl = (0, parse_utils_1.findChildNs)(numEl, "abstractNumId");
+        const overrides = [];
+        for (const ovEl of (0, parse_utils_1.findChildrenNs)(numEl, "lvlOverride")) {
+            const ov = { level: (0, parse_utils_1.attrInt)(ovEl, "ilvl") ?? 0 };
+            const startOvEl = (0, parse_utils_1.findChildNs)(ovEl, "startOverride");
+            if (startOvEl) {
+                ov.startOverride = (0, parse_utils_1.attrInt)(startOvEl, "val");
+            }
+            // Level def override: parse full level definition
+            const lvlEl = (0, parse_utils_1.findChildNs)(ovEl, "lvl");
+            if (lvlEl) {
+                ov.levelDef = parseLevel(lvlEl);
+                // Inherit level index from parent if not specified
+                if (ov.levelDef.level === undefined) {
+                    ov.levelDef.level = ov.level;
+                }
+            }
+            overrides.push(ov);
+        }
+        instances.push({
+            numId: (0, parse_utils_1.attrInt)(numEl, "numId") ?? 0,
+            abstractNumId: absIdEl ? ((0, parse_utils_1.attrInt)(absIdEl, "val") ?? 0) : 0,
+            overrides: overrides.length > 0 ? overrides : undefined
+        });
+    }
+    return { abstractNums, instances, numPicBullets };
+}
+/** Parse a w:lvl element into a NumberingLevel (shared by abstractNum and lvlOverride). */
+function parseLevel(lvlEl) {
+    const level = {
+        level: (0, parse_utils_1.attrInt)(lvlEl, "ilvl") ?? 0
+    };
+    const startEl = (0, parse_utils_1.findChildNs)(lvlEl, "start");
+    if (startEl) {
+        level.start = (0, parse_utils_1.attrInt)(startEl, "val");
+    }
+    const fmtEl = (0, parse_utils_1.findChildNs)(lvlEl, "numFmt");
+    if (fmtEl) {
+        level.format = (0, parse_utils_1.attrVal)(fmtEl, "val");
+    }
+    const textEl = (0, parse_utils_1.findChildNs)(lvlEl, "lvlText");
+    if (textEl) {
+        level.text = (0, parse_utils_1.attrVal)(textEl, "val") ?? "";
+    }
+    const pStyleEl = (0, parse_utils_1.findChildNs)(lvlEl, "pStyle");
+    if (pStyleEl) {
+        level.paragraphStyle = (0, parse_utils_1.attrVal)(pStyleEl, "val");
+    }
+    const jcEl = (0, parse_utils_1.findChildNs)(lvlEl, "lvlJc");
+    if (jcEl) {
+        level.justification = (0, parse_utils_1.attrVal)(jcEl, "val");
+    }
+    const pPrEl = (0, parse_utils_1.findChildNs)(lvlEl, "pPr");
+    if (pPrEl) {
+        level.paragraphProperties = (0, paragraph_section_parsers_1.parseParagraphProperties)(pPrEl);
+    }
+    const rPrEl = (0, parse_utils_1.findChildNs)(lvlEl, "rPr");
+    if (rPrEl) {
+        level.runProperties = (0, properties_parsers_1.parseRunProperties)(rPrEl);
+    }
+    const suffEl = (0, parse_utils_1.findChildNs)(lvlEl, "suff");
+    if (suffEl) {
+        level.suffix = (0, parse_utils_1.attrVal)(suffEl, "val");
+    }
+    if ((0, parse_utils_1.findChildNs)(lvlEl, "isLgl")) {
+        level.isLegalNumberingStyle = true;
+    }
+    const lvlRestartEl = (0, parse_utils_1.findChildNs)(lvlEl, "lvlRestart");
+    if (lvlRestartEl) {
+        level.restartAfterLevel = (0, parse_utils_1.attrInt)(lvlRestartEl, "val");
+    }
+    const picBulletEl = (0, parse_utils_1.findChildNs)(lvlEl, "lvlPicBulletId");
+    if (picBulletEl) {
+        level.picBulletId = (0, parse_utils_1.attrInt)(picBulletEl, "val");
+    }
+    return level;
+}