@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/browser/modules/word/reader/parse-utils.d.ts

@@ -0,0 +1,91 @@
+/**
+ * DOCX Reader - Shared XML/parsing utilities
+ *
+ * Low-level helpers used across the various reader sub-modules.
+ * Extracted from docx-reader.ts to keep that file focused on
+ * orchestration of the higher-level parsers.
+ */
+import type { XmlElement } from "../../xml/types.js";
+import type { ParsedRelationship } from "./reader-context.js";
+/** Get an attribute value, trying both `w:name` and bare `name`. */
+export declare function attrVal(el: XmlElement, name: string): string | undefined;
+/** Get an attribute as an integer (returns undefined if missing or non-numeric). */
+export declare function attrInt(el: XmlElement, name: string): number | undefined;
+/**
+ * Like `parseInt(value ?? fallback, 10)` but never returns NaN: any
+ * non-numeric value falls back to `fallback`. Use this when forwarding
+ * raw attribute strings into numeric model fields — round-tripping a
+ * `NaN` back into XML produces literal `"NaN"` and corrupts the
+ * resulting DOCX.
+ */
+export declare function safeParseInt(value: string | undefined, fallback: number): number;
+/** Get the local name from a possibly-prefixed tag (`"w:p"` → `"p"`). */
+export declare function localName(name: string): string;
+/** Find a child element by local name (matches both `w:name` and bare `name`). */
+export declare function findChildNs(el: XmlElement, localName: string): XmlElement | undefined;
+/** Find all child elements with a given local name. */
+export declare function findChildrenNs(el: XmlElement, localName: string): XmlElement[];
+/**
+ * Namespace-agnostic child finder: matches on the **local name** regardless
+ * of the prefix. Useful for namespaces other than `w:` (e.g. `m:`, `c:`,
+ * `cx:`) where the prefix may be inconsistent across producers.
+ */
+export declare function findChildLocal(el: XmlElement, name: string): XmlElement | undefined;
+/** Namespace-agnostic version of {@link findChildrenNs}. */
+export declare function findChildrenLocal(el: XmlElement, name: string): XmlElement[];
+/**
+ * Get an attribute value by **local name**, regardless of prefix.
+ * Useful when the same attribute may appear as `w:val`, `m:val`, etc.
+ */
+export declare function attrLocal(el: XmlElement, name: string): string | undefined;
+/**
+ * Check for a boolean toggle element.
+ *
+ * In OOXML, many properties are represented as toggle elements where:
+ * - Element present = true
+ * - Element with `w:val="0"` or `"false"` = explicit false
+ * - Element absent = undefined (use parent's default)
+ */
+export declare function boolToggle(parent: XmlElement, name: string): boolean | undefined;
+/** Serialize an XmlElement back to an XML string (used for opaque preservation). */
+export declare function serializeElement(el: XmlElement): string;
+/** Extract all `r:xxx` attribute values (relationship IDs) from an element tree. */
+export declare function collectRIds(el: XmlElement, out: Set<string>): void;
+export { getPartRelsPath, getFileName, getFileExt } from "../core/opc-paths.js";
+/**
+ * Resolve an OPC relationship target against its source part.
+ *
+ * - Leading `/` → package root absolute
+ * - `../` / `./` → resolved relative to the source part's directory
+ * - Plain paths → resolved relative to the source part's directory
+ *
+ * Returns an empty string when the resolved path would escape the package
+ * root (i.e. more `..` segments than there are directories above the
+ * source). The previous behaviour silently treated extra `..` as a no-op,
+ * which let a malicious or malformed `Target` value point at an entirely
+ * different part than the directory traversal would suggest.
+ */
+export declare function resolvePartPath(sourcePart: string, target: string): string;
+/**
+ * Find the first relationship of a given type and resolve its target path.
+ * Returns undefined if no matching relationship exists.
+ */
+export declare function resolveRelTarget(rels: ParsedRelationship[], relType: string, sourcePart: string): string | undefined;
+/** Convert OOXML cryptAlgorithmSid to human-readable algorithm name. */
+export declare function sidToHashAlgorithm(sid: string | undefined): string | undefined;
+/**
+ * Common shape returned by {@link parseNoteProperties}.
+ *
+ * `numFmt` is widened to `string` (rather than `NoteNumberFormat`) so the
+ * helper can populate either `FootnoteProperties` or `EndnoteProperties`,
+ * which only differ in `position`'s narrow union. Callers cast at the
+ * assignment site.
+ */
+export interface ParsedNoteProperties {
+    numFmt?: string;
+    numStart?: number;
+    numRestart?: string;
+    position?: string;
+}
+/** Parse footnote/endnote properties element. */
+export declare function parseNoteProperties(el: XmlElement): ParsedNoteProperties | undefined;

package/dist/browser/modules/word/reader/parse-utils.js

@@ -0,0 +1,249 @@
+/**
+ * DOCX Reader - Shared XML/parsing utilities
+ *
+ * Low-level helpers used across the various reader sub-modules.
+ * Extracted from docx-reader.ts to keep that file focused on
+ * orchestration of the higher-level parsers.
+ */
+import { findChild, findChildren } from "../../xml/dom.js";
+import { xmlEncode, xmlEncodeAttr } from "../../xml/encode.js";
+// =============================================================================
+// Attribute Readers
+// =============================================================================
+/** Get an attribute value, trying both `w:name` and bare `name`. */
+export function attrVal(el, name) {
+    return el.attributes[`w:${name}`] ?? el.attributes[name];
+}
+/** Get an attribute as an integer (returns undefined if missing or non-numeric). */
+export function attrInt(el, name) {
+    const v = attrVal(el, name);
+    if (v === undefined) {
+        return undefined;
+    }
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * Like `parseInt(value ?? fallback, 10)` but never returns NaN: any
+ * non-numeric value falls back to `fallback`. Use this when forwarding
+ * raw attribute strings into numeric model fields — round-tripping a
+ * `NaN` back into XML produces literal `"NaN"` and corrupts the
+ * resulting DOCX.
+ */
+export function safeParseInt(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    const n = parseInt(value, 10);
+    return Number.isFinite(n) ? n : fallback;
+}
+// =============================================================================
+// Child Element Readers
+// =============================================================================
+/** Get the local name from a possibly-prefixed tag (`"w:p"` → `"p"`). */
+export function localName(name) {
+    const idx = name.indexOf(":");
+    return idx >= 0 ? name.slice(idx + 1) : name;
+}
+/** Find a child element by local name (matches both `w:name` and bare `name`). */
+export function findChildNs(el, localName) {
+    return findChild(el, `w:${localName}`) ?? findChild(el, localName);
+}
+/** Find all child elements with a given local name. */
+export function findChildrenNs(el, localName) {
+    const a = findChildren(el, `w:${localName}`);
+    return a.length > 0 ? a : findChildren(el, localName);
+}
+/**
+ * Namespace-agnostic child finder: matches on the **local name** regardless
+ * of the prefix. Useful for namespaces other than `w:` (e.g. `m:`, `c:`,
+ * `cx:`) where the prefix may be inconsistent across producers.
+ */
+export function findChildLocal(el, name) {
+    for (const child of el.children) {
+        if (child.type === "element" && localName(child.name) === name) {
+            return child;
+        }
+    }
+    return undefined;
+}
+/** Namespace-agnostic version of {@link findChildrenNs}. */
+export function findChildrenLocal(el, name) {
+    const out = [];
+    for (const child of el.children) {
+        if (child.type === "element" && localName(child.name) === name) {
+            out.push(child);
+        }
+    }
+    return out;
+}
+/**
+ * Get an attribute value by **local name**, regardless of prefix.
+ * Useful when the same attribute may appear as `w:val`, `m:val`, etc.
+ */
+export function attrLocal(el, name) {
+    for (const [k, v] of Object.entries(el.attributes)) {
+        if (localName(k) === name) {
+            return v;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check for a boolean toggle element.
+ *
+ * In OOXML, many properties are represented as toggle elements where:
+ * - Element present = true
+ * - Element with `w:val="0"` or `"false"` = explicit false
+ * - Element absent = undefined (use parent's default)
+ */
+export function boolToggle(parent, name) {
+    const el = findChildNs(parent, name);
+    if (!el) {
+        return undefined;
+    }
+    const v = attrVal(el, "val");
+    if (v === "0" || v === "false") {
+        return false;
+    }
+    return true;
+}
+// =============================================================================
+// XML Serialization
+// =============================================================================
+/** Serialize an XmlElement back to an XML string (used for opaque preservation). */
+export function serializeElement(el) {
+    let s = `<${el.name}`;
+    for (const [k, v] of Object.entries(el.attributes)) {
+        s += ` ${k}="${xmlEncodeAttr(v)}"`;
+    }
+    if (el.children.length === 0) {
+        return s + "/>";
+    }
+    s += ">";
+    for (const child of el.children) {
+        if (child.type === "element") {
+            s += serializeElement(child);
+        }
+        else if (child.type === "text") {
+            s += xmlEncode(child.value);
+        }
+    }
+    s += `</${el.name}>`;
+    return s;
+}
+/** Extract all `r:xxx` attribute values (relationship IDs) from an element tree. */
+export function collectRIds(el, out) {
+    for (const [k, v] of Object.entries(el.attributes)) {
+        if (k.startsWith("r:") || k === "r:id" || k === "r:embed" || k === "r:link") {
+            out.add(v);
+        }
+    }
+    for (const child of el.children) {
+        if (child.type === "element") {
+            collectRIds(child, out);
+        }
+    }
+}
+// =============================================================================
+// Path / Relationship Helpers
+// =============================================================================
+export { getPartRelsPath, getFileName, getFileExt } from "../core/opc-paths.js";
+/**
+ * Resolve an OPC relationship target against its source part.
+ *
+ * - Leading `/` → package root absolute
+ * - `../` / `./` → resolved relative to the source part's directory
+ * - Plain paths → resolved relative to the source part's directory
+ *
+ * Returns an empty string when the resolved path would escape the package
+ * root (i.e. more `..` segments than there are directories above the
+ * source). The previous behaviour silently treated extra `..` as a no-op,
+ * which let a malicious or malformed `Target` value point at an entirely
+ * different part than the directory traversal would suggest.
+ */
+export function resolvePartPath(sourcePart, target) {
+    if (!target) {
+        return "";
+    }
+    if (target.startsWith("/")) {
+        return target.slice(1);
+    }
+    const lastSlash = sourcePart.lastIndexOf("/");
+    const baseDir = lastSlash >= 0 ? sourcePart.substring(0, lastSlash).split("/") : [];
+    const segs = target.split("/");
+    for (const seg of segs) {
+        if (seg === "..") {
+            if (baseDir.length === 0) {
+                // The target asks to step above the package root. Treat as
+                // unresolvable instead of silently swallowing the segment.
+                return "";
+            }
+            baseDir.pop();
+        }
+        else if (seg !== "." && seg !== "") {
+            baseDir.push(seg);
+        }
+    }
+    return baseDir.join("/");
+}
+/**
+ * Find the first relationship of a given type and resolve its target path.
+ * Returns undefined if no matching relationship exists.
+ */
+export function resolveRelTarget(rels, relType, sourcePart) {
+    for (const rel of rels) {
+        if (rel.type === relType) {
+            return resolvePartPath(sourcePart, rel.target);
+        }
+    }
+    return undefined;
+}
+// =============================================================================
+// Crypto Helpers
+// =============================================================================
+/** Convert OOXML cryptAlgorithmSid to human-readable algorithm name. */
+export function sidToHashAlgorithm(sid) {
+    if (!sid) {
+        return undefined;
+    }
+    switch (sid) {
+        case "1":
+            return "MD2";
+        case "2":
+            return "MD4";
+        case "3":
+            return "MD5";
+        case "4":
+            return "SHA-1";
+        case "12":
+            return "SHA-256";
+        case "13":
+            return "SHA-384";
+        case "14":
+            return "SHA-512";
+        default:
+            return `SID-${sid}`;
+    }
+}
+/** Parse footnote/endnote properties element. */
+export function parseNoteProperties(el) {
+    const props = {};
+    const numFmtEl = findChildNs(el, "numFmt");
+    if (numFmtEl) {
+        props.numFmt = attrVal(numFmtEl, "val");
+    }
+    const numStartEl = findChildNs(el, "numStart");
+    if (numStartEl) {
+        props.numStart = attrInt(numStartEl, "val");
+    }
+    const numRestartEl = findChildNs(el, "numRestart");
+    if (numRestartEl) {
+        props.numRestart = attrVal(numRestartEl, "val");
+    }
+    const posEl = findChildNs(el, "pos");
+    if (posEl) {
+        props.position = attrVal(posEl, "val");
+    }
+    return Object.keys(props).length > 0 ? props : undefined;
+}

package/dist/browser/modules/word/reader/properties-parsers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * DOCX Reader - Properties Parsers
+ *
+ * Pure parsers for OOXML property structures that don't depend on the
+ * main reader context. These are the building blocks used by the higher-level
+ * paragraph/run/table/section parsers.
+ *
+ * Includes:
+ * - `parseRunProperties` (w:rPr)
+ * - `parseShading` (w:shd)
+ * - `parseBorder` (any border element)
+ * - `parseTableWidth` (w:tblW, w:tcW, etc.)
+ * - `parseRevisionInfo` (w:ins/w:del/w:rPrChange/etc. revision metadata)
+ */
+import type { XmlElement } from "../../xml/types.js";
+import type { Border, RevisionInfo, RunProperties, Shading, TableWidth } from "../types.js";
+export declare function parseRunProperties(rPrEl: XmlElement): RunProperties;
+export declare function parseShading(el: XmlElement): Shading;
+export declare function parseBorder(el: XmlElement): Border;
+export declare function parseTableWidth(el: XmlElement): TableWidth;
+export declare function parseRevisionInfo(el: XmlElement): RevisionInfo | undefined;

package/dist/browser/modules/word/reader/properties-parsers.js

@@ -0,0 +1,332 @@
+/**
+ * DOCX Reader - Properties Parsers
+ *
+ * Pure parsers for OOXML property structures that don't depend on the
+ * main reader context. These are the building blocks used by the higher-level
+ * paragraph/run/table/section parsers.
+ *
+ * Includes:
+ * - `parseRunProperties` (w:rPr)
+ * - `parseShading` (w:shd)
+ * - `parseBorder` (any border element)
+ * - `parseTableWidth` (w:tblW, w:tcW, etc.)
+ * - `parseRevisionInfo` (w:ins/w:del/w:rPrChange/etc. revision metadata)
+ */
+import {} from "../core/internal-utils.js";
+import { attrInt, attrVal, boolToggle, findChildNs, safeParseInt } from "./parse-utils.js";
+// =============================================================================
+// Run Properties
+// =============================================================================
+export function parseRunProperties(rPrEl) {
+    const rPr = {};
+    const rStyleEl = findChildNs(rPrEl, "rStyle");
+    if (rStyleEl) {
+        rPr.style = attrVal(rStyleEl, "val");
+    }
+    const fontsEl = findChildNs(rPrEl, "rFonts");
+    if (fontsEl) {
+        const f = {};
+        const ascii = attrVal(fontsEl, "ascii");
+        const hAnsi = attrVal(fontsEl, "hAnsi");
+        const eastAsia = attrVal(fontsEl, "eastAsia");
+        const cs = attrVal(fontsEl, "cs");
+        const hint = attrVal(fontsEl, "hint");
+        if (ascii) {
+            f.ascii = ascii;
+        }
+        if (hAnsi) {
+            f.hAnsi = hAnsi;
+        }
+        if (eastAsia) {
+            f.eastAsia = eastAsia;
+        }
+        if (cs) {
+            f.cs = cs;
+        }
+        if (hint) {
+            f.hint = hint;
+        }
+        const asciiTheme = attrVal(fontsEl, "asciiTheme");
+        if (asciiTheme) {
+            f.asciiTheme = asciiTheme;
+        }
+        const hAnsiTheme = attrVal(fontsEl, "hAnsiTheme");
+        if (hAnsiTheme) {
+            f.hAnsiTheme = hAnsiTheme;
+        }
+        const eastAsiaTheme = attrVal(fontsEl, "eastAsiaTheme");
+        if (eastAsiaTheme) {
+            f.eastAsiaTheme = eastAsiaTheme;
+        }
+        const cstheme = attrVal(fontsEl, "cstheme");
+        if (cstheme) {
+            f.cstheme = cstheme;
+        }
+        rPr.font = f;
+    }
+    // Boolean toggles: true-only (element presence = true; absence = undefined)
+    // Format: [elementName, propertyKey]
+    const RUN_ONCE_TOGGLES = [
+        ["strike", "strike"],
+        ["dstrike", "doubleStrike"],
+        ["caps", "caps"],
+        ["smallCaps", "smallCaps"],
+        ["vanish", "vanish"],
+        ["emboss", "emboss"],
+        ["imprint", "imprint"],
+        ["noProof", "noProof"],
+        ["specVanish", "specVanish"],
+        ["outline", "outline"],
+        ["shadow", "shadow"],
+        ["cs", "complexScript"],
+        ["oMath", "math"],
+        ["webHidden", "webHidden"]
+    ];
+    for (const [tag, key] of RUN_ONCE_TOGGLES) {
+        if (findChildNs(rPrEl, tag) && boolToggle(rPrEl, tag) !== false) {
+            rPr[key] = true;
+        }
+    }
+    // Boolean toggles: tri-state (can be explicitly true or false)
+    const RUN_TRISTATE_TOGGLES = [
+        ["b", "bold"],
+        ["bCs", "boldCs"],
+        ["i", "italic"],
+        ["iCs", "italicCs"],
+        ["snapToGrid", "snapToGrid"],
+        ["rtl", "rightToLeft"]
+    ];
+    for (const [tag, key] of RUN_TRISTATE_TOGGLES) {
+        const v = boolToggle(rPrEl, tag);
+        if (v !== undefined) {
+            rPr[key] = v;
+        }
+    }
+    // fitText
+    const fitTextEl = findChildNs(rPrEl, "fitText");
+    if (fitTextEl) {
+        const val = attrInt(fitTextEl, "val");
+        if (val !== undefined) {
+            const id = attrInt(fitTextEl, "id");
+            rPr.fitText = id !== undefined ? { val, id } : { val };
+        }
+    }
+    const colorEl = findChildNs(rPrEl, "color");
+    if (colorEl) {
+        const val = attrVal(colorEl, "val");
+        const themeColor = attrVal(colorEl, "themeColor");
+        if (themeColor) {
+            const spec = { val, themeColor };
+            const themeTint = attrVal(colorEl, "themeTint");
+            const themeShade = attrVal(colorEl, "themeShade");
+            if (themeTint) {
+                spec.themeTint = themeTint;
+            }
+            if (themeShade) {
+                spec.themeShade = themeShade;
+            }
+            rPr.color = spec;
+        }
+        else {
+            rPr.color = val;
+        }
+    }
+    const szEl = findChildNs(rPrEl, "sz");
+    if (szEl) {
+        rPr.size = attrInt(szEl, "val");
+    }
+    const szCsEl = findChildNs(rPrEl, "szCs");
+    if (szCsEl) {
+        rPr.sizeCs = attrInt(szCsEl, "val");
+    }
+    const uEl = findChildNs(rPrEl, "u");
+    if (uEl) {
+        const uStyle = (attrVal(uEl, "val") ?? "single");
+        const uColor = attrVal(uEl, "color");
+        if (uColor) {
+            rPr.underline = { style: uStyle, color: uColor };
+        }
+        else {
+            rPr.underline = uStyle;
+        }
+    }
+    const highlightEl = findChildNs(rPrEl, "highlight");
+    if (highlightEl) {
+        rPr.highlight = attrVal(highlightEl, "val");
+    }
+    const vertAlignEl = findChildNs(rPrEl, "vertAlign");
+    if (vertAlignEl) {
+        rPr.vertAlign = attrVal(vertAlignEl, "val");
+    }
+    const spacingEl = findChildNs(rPrEl, "spacing");
+    if (spacingEl) {
+        rPr.spacing = attrInt(spacingEl, "val");
+    }
+    const shdEl = findChildNs(rPrEl, "shd");
+    if (shdEl) {
+        rPr.shading = parseShading(shdEl);
+    }
+    const langEl = findChildNs(rPrEl, "lang");
+    if (langEl) {
+        rPr.language = {
+            val: attrVal(langEl, "val"),
+            eastAsia: attrVal(langEl, "eastAsia"),
+            bidi: attrVal(langEl, "bidi")
+        };
+    }
+    // New valued properties
+    const kernEl = findChildNs(rPrEl, "kern");
+    if (kernEl) {
+        rPr.kern = attrInt(kernEl, "val");
+    }
+    const positionEl = findChildNs(rPrEl, "position");
+    if (positionEl) {
+        rPr.position = attrInt(positionEl, "val");
+    }
+    const wEl = findChildNs(rPrEl, "w");
+    if (wEl) {
+        rPr.scale = attrInt(wEl, "val");
+    }
+    const effectEl = findChildNs(rPrEl, "effect");
+    if (effectEl) {
+        rPr.effect = attrVal(effectEl, "val");
+    }
+    const emEl = findChildNs(rPrEl, "em");
+    if (emEl) {
+        rPr.emphasisMark = attrVal(emEl, "val");
+    }
+    const eaLayoutEl = findChildNs(rPrEl, "eastAsianLayout");
+    if (eaLayoutEl) {
+        const ea = parseEastAsianLayout(eaLayoutEl);
+        if (ea) {
+            rPr.eastAsianLayout = ea;
+        }
+    }
+    const bdrEl = findChildNs(rPrEl, "bdr");
+    if (bdrEl) {
+        rPr.border = parseBorder(bdrEl);
+    }
+    // rPrChange (track changes for run properties)
+    const rPrChangeEl = findChildNs(rPrEl, "rPrChange");
+    if (rPrChangeEl) {
+        const rev = parseRevisionInfo(rPrChangeEl);
+        if (rev) {
+            const prevRPrEl = findChildNs(rPrChangeEl, "rPr");
+            const change = {
+                revision: rev,
+                previousProperties: prevRPrEl ? parseRunProperties(prevRPrEl) : undefined
+            };
+            rPr.propertyChange = change;
+        }
+    }
+    return rPr;
+}
+// =============================================================================
+// East Asian Layout
+// =============================================================================
+const VALID_COMBINE_BRACKETS = new Set([
+    "none",
+    "round",
+    "square",
+    "angle",
+    "curly"
+]);
+/**
+ * Interpret an OOXML on/off attribute (ECMA-376 §17.17.4): a value of
+ * `"1"`, `"true"`, `"on"` or the empty string is true; `"0"`, `"false"`,
+ * `"off"` is false; missing yields undefined.
+ */
+function attrOnOff(el, name) {
+    const v = attrVal(el, name);
+    if (v == null) {
+        return undefined;
+    }
+    if (v === "0" || v === "false" || v === "off") {
+        return false;
+    }
+    return true;
+}
+function parseEastAsianLayout(el) {
+    const spec = {};
+    const id = attrInt(el, "id");
+    if (id != null) {
+        spec.id = id;
+    }
+    if (attrOnOff(el, "combine") === true) {
+        spec.combine = true;
+    }
+    const brackets = attrVal(el, "combineBrackets");
+    if (brackets && VALID_COMBINE_BRACKETS.has(brackets)) {
+        spec.combineBrackets = brackets;
+    }
+    if (attrOnOff(el, "vert") === true) {
+        spec.vert = true;
+    }
+    if (attrOnOff(el, "vertCompress") === true) {
+        spec.vertCompress = true;
+    }
+    return Object.keys(spec).length > 0 ? spec : undefined;
+}
+// =============================================================================
+// Shading / Border / Width
+// =============================================================================
+export function parseShading(el) {
+    return {
+        pattern: attrVal(el, "val"),
+        color: attrVal(el, "color"),
+        fill: attrVal(el, "fill") ?? "auto"
+    };
+}
+export function parseBorder(el) {
+    const b = {
+        style: (attrVal(el, "val") ?? "single"),
+        size: attrInt(el, "sz"),
+        space: attrInt(el, "space"),
+        color: attrVal(el, "color")
+    };
+    const tc = attrVal(el, "themeColor");
+    if (tc) {
+        b.themeColor = tc;
+    }
+    const shadow = attrVal(el, "shadow");
+    if (shadow === "1" || shadow === "true") {
+        b.shadow = true;
+    }
+    const frame = attrVal(el, "frame");
+    if (frame === "1" || frame === "true") {
+        b.frame = true;
+    }
+    const art = attrVal(el, "art");
+    if (art) {
+        b.art = art;
+    }
+    return b;
+}
+export function parseTableWidth(el) {
+    return {
+        // Reject non-numeric values (a hostile DOCX could write
+        // `<w:tblW w:w="abc"/>`); falling back to 0 keeps the model field
+        // a finite number and prevents `NaN` from being serialised back to
+        // the output XML, which Word rejects.
+        value: safeParseInt(el.attributes["w:w"] ?? el.attributes["w"], 0),
+        type: (el.attributes["w:type"] ?? el.attributes["type"] ?? "dxa")
+    };
+}
+// =============================================================================
+// Revision Info
+// =============================================================================
+export function parseRevisionInfo(el) {
+    const author = attrVal(el, "author");
+    const id = attrInt(el, "id");
+    // ECMA-376 marks `w:author` and `w:id` as optional on revision elements.
+    // Earlier we returned `undefined` if either was missing — that quietly
+    // dropped the entire `<w:ins>`/`<w:del>` body in callers that gate on
+    // this result. Fall back to a sentinel author/id so the surrounding runs
+    // are still preserved (the user-visible text is what matters; the
+    // metadata is purely informational).
+    return {
+        author: author ?? "",
+        id: id ?? 0,
+        date: attrVal(el, "date")
+    };
+}