@beyondwork/docx-react-component 1.0.38 → 1.0.39

package/src/io/ooxml/parse-numbering.ts

@@ -8,6 +8,7 @@ import type {
   ParagraphIndentation,
   TabStop,
 } from "../../model/canonical-document.ts";
+import { readRunProperties } from "./parse-run-formatting.ts";
 
 export interface ParsedParagraphNumberingReference {
   paragraphIndex: number;
@@ -48,9 +49,32 @@ export function parseNumberingXml(xml: string): NumberingCatalog {
         }
 
         const abstractNumberingId = toCanonicalAbstractNumberingId(rawId);
+        const nsidEl = findChildElementOptional(child, "nsid");
+        const nsid = nsidEl ? (nsidEl.attributes["w:val"] ?? nsidEl.attributes.val) : undefined;
+        const mltEl = findChildElementOptional(child, "multiLevelType");
+        const mltRaw = mltEl ? (mltEl.attributes["w:val"] ?? mltEl.attributes.val) : undefined;
+        const multiLevelType =
+          mltRaw === "singleLevel" || mltRaw === "multilevel" || mltRaw === "hybridMultilevel"
+            ? mltRaw
+            : undefined;
+        const tmplEl = findChildElementOptional(child, "tmpl");
+        const tplc = tmplEl ? (tmplEl.attributes["w:val"] ?? tmplEl.attributes.val) : undefined;
+        const styleLinkEl = findChildElementOptional(child, "styleLink");
+        const styleLink = styleLinkEl
+          ? (styleLinkEl.attributes["w:val"] ?? styleLinkEl.attributes.val)
+          : undefined;
+        const numStyleLinkEl = findChildElementOptional(child, "numStyleLink");
+        const numStyleLink = numStyleLinkEl
+          ? (numStyleLinkEl.attributes["w:val"] ?? numStyleLinkEl.attributes.val)
+          : undefined;
         abstractDefinitions[abstractNumberingId] = {
           abstractNumberingId,
           levels: readLevels(child),
+          ...(nsid ? { nsid } : {}),
+          ...(multiLevelType ? { multiLevelType } : {}),
+          ...(tplc ? { tplc } : {}),
+          ...(styleLink ? { styleLink } : {}),
+          ...(numStyleLink ? { numStyleLink } : {}),
         };
         break;
       }
@@ -219,6 +243,11 @@ function readLevelDefinition(
         ? "tab"
         : undefined;
   const paragraphGeometry = readLevelParagraphGeometry(levelNode);
+  const lvlRestartNode = findChildElementOptional(levelNode, "lvlRestart");
+  const rawRestart = lvlRestartNode?.attributes["w:val"] ?? lvlRestartNode?.attributes.val;
+  const restartAfterLevel = rawRestart !== undefined ? parseInteger(rawRestart) : undefined;
+  const rPrNode = findChildElementOptional(levelNode, "rPr");
+  const runProperties = readRunProperties(rPrNode);
 
   return {
     level,
@@ -229,6 +258,8 @@ function readLevelDefinition(
     ...(isLegalNumbering ? { isLegalNumbering: true } : {}),
     ...(suffix ? { suffix } : {}),
     ...(paragraphGeometry ? { paragraphGeometry } : {}),
+    ...(runProperties ? { runProperties } : {}),
+    ...(restartAfterLevel !== undefined ? { restartAfterLevel } : {}),
   };
 }
 
@@ -263,6 +294,11 @@ function readLevelOverrideDefinition(
         ? "tab"
         : undefined;
   const paragraphGeometry = readLevelParagraphGeometry(levelNode);
+  const lvlRestartNode = findChildElementOptional(levelNode, "lvlRestart");
+  const rawRestart = lvlRestartNode?.attributes["w:val"] ?? lvlRestartNode?.attributes.val;
+  const restartAfterLevel = rawRestart !== undefined ? parseInteger(rawRestart) : undefined;
+  const rPrNode = findChildElementOptional(levelNode, "rPr");
+  const runProperties = readRunProperties(rPrNode);
 
   const hasExplicitFields =
     startAt !== undefined ||
@@ -271,7 +307,9 @@ function readLevelOverrideDefinition(
     paragraphStyleId !== undefined ||
     isLegalNumbering !== undefined ||
     suffix !== undefined ||
-    paragraphGeometry !== undefined;
+    paragraphGeometry !== undefined ||
+    runProperties !== undefined ||
+    restartAfterLevel !== undefined;
 
   if (!hasExplicitFields) {
     return undefined;
@@ -286,6 +324,8 @@ function readLevelOverrideDefinition(
     ...(isLegalNumbering !== undefined ? { isLegalNumbering } : {}),
     ...(suffix ? { suffix } : {}),
     ...(paragraphGeometry ? { paragraphGeometry } : {}),
+    ...(runProperties ? { runProperties } : {}),
+    ...(restartAfterLevel !== undefined ? { restartAfterLevel } : {}),
   };
 }
 

package/src/io/ooxml/parse-paragraph-formatting.ts

@@ -0,0 +1,188 @@
+/**
+ * Read `<w:pPr>` (paragraph properties) into a `CanonicalParagraphFormatting` value.
+ *
+ * Returns `undefined` when the input is `undefined` or when the pPr is empty (no recognized
+ * child produces a field). Delegates the paragraph-mark `<w:rPr>` to `readRunProperties`
+ * so every rPr in the project is parsed through one code path.
+ */
+
+import type {
+  CanonicalParagraphFormatting,
+  ParagraphBorders,
+  ParagraphIndentation,
+  ParagraphShading,
+  ParagraphSpacing,
+  TabStop,
+} from "../../model/canonical-document.ts";
+import { readRunProperties } from "./parse-run-formatting.ts";
+import { findChildOptional, localName, readIntAttr, readIntVal, readOnOff } from "./xml-attr-helpers.ts";
+import type { XmlElementNode } from "./xml-element.ts";
+
+function readSpacing(node: XmlElementNode): ParagraphSpacing | undefined {
+  const out: ParagraphSpacing = {};
+  const before = readIntAttr(node, "w:before");
+  const after = readIntAttr(node, "w:after");
+  const line = readIntAttr(node, "w:line");
+  const rule = node.attributes["w:lineRule"] ?? node.attributes.lineRule;
+  if (before !== undefined) out.before = before;
+  if (after !== undefined) out.after = after;
+  if (line !== undefined) out.line = line;
+  if (rule) {
+    const n = rule.toLowerCase();
+    if (n === "auto" || n === "exact") out.lineRule = n;
+    else if (n === "atleast") out.lineRule = "atLeast";
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function readIndent(node: XmlElementNode): ParagraphIndentation | undefined {
+  const out: ParagraphIndentation = {};
+  const left = readIntAttr(node, "w:left") ?? readIntAttr(node, "w:start");
+  const right = readIntAttr(node, "w:right") ?? readIntAttr(node, "w:end");
+  const firstLine = readIntAttr(node, "w:firstLine");
+  const hanging = readIntAttr(node, "w:hanging");
+  if (left !== undefined) out.left = left;
+  if (right !== undefined) out.right = right;
+  if (firstLine !== undefined) out.firstLine = firstLine;
+  if (hanging !== undefined) out.hanging = hanging;
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function readTabStops(node: XmlElementNode): TabStop[] | undefined {
+  const tabs: TabStop[] = [];
+  for (const c of node.children) {
+    if (c.type !== "element" || localName(c.name) !== "tab") continue;
+    const pos = Number.parseInt(c.attributes["w:pos"] ?? c.attributes.pos ?? "", 10);
+    if (!Number.isFinite(pos)) continue;
+    const val = (c.attributes["w:val"] ?? c.attributes.val ?? "left").toLowerCase();
+    const leader = (c.attributes["w:leader"] ?? c.attributes.leader ?? "none").toLowerCase();
+    const align: TabStop["align"] =
+      val === "center" || val === "right" || val === "decimal" || val === "bar" || val === "num" || val === "clear"
+        ? (val as TabStop["align"])
+        : "left";
+    const mappedLeader: TabStop["leader"] | undefined =
+      leader === "dot" || leader === "hyphen" || leader === "underscore" || leader === "heavy"
+        ? (leader as TabStop["leader"])
+        : leader === "middledot"
+          ? "middleDot"
+          : undefined;
+    tabs.push({
+      position: pos,
+      align,
+      ...(mappedLeader && mappedLeader !== "none" ? { leader: mappedLeader } : {}),
+    });
+  }
+  return tabs.length > 0 ? tabs : undefined;
+}
+
+function readBorders(node: XmlElementNode): ParagraphBorders | undefined {
+  const out: ParagraphBorders = {};
+  const sides = ["top", "bottom", "left", "right", "between", "bar"] as const;
+  for (const side of sides) {
+    const child = findChildOptional(node, side);
+    if (!child) continue;
+    const val = child.attributes["w:val"] ?? child.attributes.val;
+    const sz = readIntAttr(child, "w:sz");
+    const space = readIntAttr(child, "w:space");
+    const color = child.attributes["w:color"] ?? child.attributes.color;
+    out[side] = {
+      ...(val ? { value: val } : {}),
+      ...(sz !== undefined ? { size: sz } : {}),
+      ...(space !== undefined ? { space } : {}),
+      ...(color ? { color } : {}),
+    };
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function readShading(node: XmlElementNode): ParagraphShading | undefined {
+  const val = node.attributes["w:val"] ?? node.attributes.val;
+  const fill = node.attributes["w:fill"] ?? node.attributes.fill;
+  const color = node.attributes["w:color"] ?? node.attributes.color;
+  if (!val && !fill && !color) return undefined;
+  return {
+    ...(val ? { val } : {}),
+    ...(fill ? { fill } : {}),
+    ...(color ? { color } : {}),
+  };
+}
+
+export function readParagraphProperties(
+  node: XmlElementNode | undefined,
+): CanonicalParagraphFormatting | undefined {
+  if (!node) return undefined;
+
+  const out: CanonicalParagraphFormatting = {};
+
+  const spacingNode = findChildOptional(node, "spacing");
+  if (spacingNode) {
+    const spacing = readSpacing(spacingNode);
+    if (spacing) out.spacing = spacing;
+  }
+
+  const indNode = findChildOptional(node, "ind");
+  if (indNode) {
+    const ind = readIndent(indNode);
+    if (ind) out.indentation = ind;
+  }
+
+  const jcNode = findChildOptional(node, "jc");
+  if (jcNode) {
+    const raw = jcNode.attributes["w:val"] ?? jcNode.attributes.val;
+    if (
+      raw === "left" ||
+      raw === "center" ||
+      raw === "right" ||
+      raw === "both" ||
+      raw === "distribute" ||
+      raw === "start" ||
+      raw === "end"
+    ) {
+      out.alignment = raw;
+    }
+  }
+
+  const bordersNode = findChildOptional(node, "pBdr");
+  if (bordersNode) {
+    const borders = readBorders(bordersNode);
+    if (borders) out.borders = borders;
+  }
+
+  const shdNode = findChildOptional(node, "shd");
+  if (shdNode) {
+    const shading = readShading(shdNode);
+    if (shading) out.shading = shading;
+  }
+
+  const tabsNode = findChildOptional(node, "tabs");
+  if (tabsNode) {
+    const tabs = readTabStops(tabsNode);
+    if (tabs) out.tabStops = tabs;
+  }
+
+  const keepNext = readOnOff(findChildOptional(node, "keepNext"));
+  if (keepNext !== undefined) out.keepNext = keepNext;
+  const keepLines = readOnOff(findChildOptional(node, "keepLines"));
+  if (keepLines !== undefined) out.keepLines = keepLines;
+  const widow = readOnOff(findChildOptional(node, "widowControl"));
+  if (widow !== undefined) out.widowControl = widow;
+  const pbb = readOnOff(findChildOptional(node, "pageBreakBefore"));
+  if (pbb !== undefined) out.pageBreakBefore = pbb;
+  const ctx = readOnOff(findChildOptional(node, "contextualSpacing"));
+  if (ctx !== undefined) out.contextualSpacing = ctx;
+  const bidi = readOnOff(findChildOptional(node, "bidi"));
+  if (bidi !== undefined) out.bidi = bidi;
+  const suppressLn = readOnOff(findChildOptional(node, "suppressLineNumbers"));
+  if (suppressLn !== undefined) out.suppressLineNumbers = suppressLn;
+  const suppressAh = readOnOff(findChildOptional(node, "suppressAutoHyphens"));
+  if (suppressAh !== undefined) out.suppressAutoHyphens = suppressAh;
+
+  const outline = readIntVal(findChildOptional(node, "outlineLvl"));
+  if (outline !== undefined) out.outlineLevel = outline;
+
+  const rPrNode = findChildOptional(node, "rPr");
+  const markRpr = readRunProperties(rPrNode);
+  if (markRpr) out.paragraphMarkRunProperties = markRpr;
+
+  return Object.keys(out).length > 0 ? out : undefined;
+}

package/src/io/ooxml/parse-run-formatting.ts

@@ -0,0 +1,129 @@
+import type { CanonicalRunFormatting } from "../../model/canonical-document.ts";
+import { findChildOptional, readIntVal, readOnOff, readStringAttr } from "./xml-attr-helpers.ts";
+import type { XmlElementNode } from "./xml-element.ts";
+
+/**
+ * Read `<w:rPr>` (run properties) into a `CanonicalRunFormatting` value.
+ *
+ * Returns `undefined` when the input is `undefined` or when the rPr is empty
+ * (i.e., no recognized child produces a field). `colorHex` may carry the
+ * sentinel `"auto"`; `fontFamily` is the alias of the first-available
+ * `fontFamily{Ascii,HAnsi,EastAsia,Cs}`.
+ *
+ * Caller-side: route every `<w:rPr>` from styles.xml, numbering.xml, and
+ * the paragraph mark in document.xml through this helper so the cascade
+ * sees the same shape.
+ */
+export function readRunProperties(
+  node: XmlElementNode | undefined,
+): CanonicalRunFormatting | undefined {
+  if (!node) return undefined;
+
+  const rPr: CanonicalRunFormatting = {};
+
+  const bold = readOnOff(findChildOptional(node, "b"));
+  if (bold !== undefined) rPr.bold = bold;
+
+  const italic = readOnOff(findChildOptional(node, "i"));
+  if (italic !== undefined) rPr.italic = italic;
+
+  const strike = readOnOff(findChildOptional(node, "strike"));
+  if (strike !== undefined) rPr.strikethrough = strike;
+
+  const dstrike = readOnOff(findChildOptional(node, "dstrike"));
+  if (dstrike !== undefined) rPr.doubleStrikethrough = dstrike;
+
+  const vanish = readOnOff(findChildOptional(node, "vanish"));
+  if (vanish !== undefined) rPr.vanish = vanish;
+
+  const allCaps = readOnOff(findChildOptional(node, "caps"));
+  if (allCaps !== undefined) rPr.allCaps = allCaps;
+
+  const smallCaps = readOnOff(findChildOptional(node, "smallCaps"));
+  if (smallCaps !== undefined) rPr.smallCaps = smallCaps;
+
+  const u = findChildOptional(node, "u");
+  if (u) {
+    const val =
+      u.attributes["w:val"] ?? u.attributes["val"] ?? "single";
+    if (val === "none") {
+      rPr.underline = "none";
+    } else if (
+      val === "single" ||
+      val === "double" ||
+      val === "thick" ||
+      val === "dotted" ||
+      val === "dash" ||
+      val === "wave"
+    ) {
+      rPr.underline = val;
+    } else {
+      // Unknown underline type — coerce to "single"
+      rPr.underline = "single";
+    }
+  }
+
+  const vertAlign = findChildOptional(node, "vertAlign");
+  if (vertAlign) {
+    const val =
+      vertAlign.attributes["w:val"] ?? vertAlign.attributes["val"];
+    if (
+      val === "superscript" ||
+      val === "subscript" ||
+      val === "baseline"
+    ) {
+      rPr.verticalAlign = val;
+    }
+  }
+
+  const rFonts = findChildOptional(node, "rFonts");
+  if (rFonts) {
+    const ascii = rFonts.attributes["w:ascii"] ?? rFonts.attributes.ascii;
+    const hAnsi = rFonts.attributes["w:hAnsi"] ?? rFonts.attributes.hAnsi;
+    const eastAsia = rFonts.attributes["w:eastAsia"] ?? rFonts.attributes.eastAsia;
+    const cs = rFonts.attributes["w:cs"] ?? rFonts.attributes.cs;
+    if (ascii) rPr.fontFamilyAscii = ascii;
+    if (hAnsi) rPr.fontFamilyHAnsi = hAnsi;
+    if (eastAsia) rPr.fontFamilyEastAsia = eastAsia;
+    if (cs) rPr.fontFamilyCs = cs;
+    const primary = ascii ?? hAnsi ?? eastAsia ?? cs;
+    if (primary) rPr.fontFamily = primary;
+  }
+
+  const sz = readIntVal(findChildOptional(node, "sz"));
+  if (sz !== undefined) rPr.fontSizeHalfPoints = sz;
+
+  const szCs = readIntVal(findChildOptional(node, "szCs"));
+  if (szCs !== undefined) rPr.fontSizeCsHalfPoints = szCs;
+
+  const color = findChildOptional(node, "color");
+  if (color) {
+    const val = color.attributes["w:val"] ?? color.attributes["val"];
+    const theme =
+      color.attributes["w:themeColor"] ?? color.attributes["themeColor"];
+    if (val) rPr.colorHex = val;
+    if (theme) rPr.colorThemeSlot = theme;
+  }
+
+  const highlight = findChildOptional(node, "highlight");
+  if (highlight) {
+    const val =
+      highlight.attributes["w:val"] ?? highlight.attributes["val"];
+    if (val) rPr.highlight = val;
+  }
+
+  const spacing = readIntVal(findChildOptional(node, "spacing"));
+  if (spacing !== undefined) rPr.characterSpacingTwips = spacing;
+
+  const rStyleNode = findChildOptional(node, "rStyle");
+  const rStyle = rStyleNode ? readStringAttr(rStyleNode, "w:val") : undefined;
+  if (rStyle) rPr.characterStyleId = rStyle;
+
+  const lang = findChildOptional(node, "lang");
+  if (lang) {
+    const val = lang.attributes["w:val"] ?? lang.attributes["val"];
+    if (val) rPr.languageCode = val;
+  }
+
+  return Object.keys(rPr).length > 0 ? rPr : undefined;
+}

package/src/io/ooxml/parse-styles.ts

@@ -10,6 +10,7 @@
 import type {
   CellShading,
   CharacterStyleDefinition,
+  DocumentDefaults,
   LatentStyleDefinition,
   ParagraphStyleDefinition,
   StylesCatalog,
@@ -37,6 +38,8 @@ import {
   readTableWidth,
 } from "./parse-tables.ts";
 import { toCanonicalNumberingInstanceId } from "./parse-numbering.ts";
+import { readRunProperties } from "./parse-run-formatting.ts";
+import { readParagraphProperties } from "./parse-paragraph-formatting.ts";
 
 // ---------------------------------------------------------------------------
 // Inline XML node types (same pattern as parse-numbering.ts)
@@ -116,11 +119,28 @@ export function parseStylesXml(xml: string): ParseStylesResult {
   const characters: Record<string, CharacterStyleDefinition> = {};
   const tables: Record<string, TableStyleDefinition> = {};
   const latentStyles: Record<string, LatentStyleDefinition> = {};
+  let docDefaults: DocumentDefaults | undefined;
 
   for (const child of stylesElement.children) {
     if (child.type !== "element") continue;
     const local = localName(child.name);
 
+    if (local === "docDefaults") {
+      const pPrDefault = findChildElementOptional(child, "pPrDefault");
+      const rPrDefault = findChildElementOptional(child, "rPrDefault");
+      const pPrNode = pPrDefault ? findChildElementOptional(pPrDefault, "pPr") : undefined;
+      const rPrNode = rPrDefault ? findChildElementOptional(rPrDefault, "rPr") : undefined;
+      const paragraph = readParagraphProperties(pPrNode);
+      const run = readRunProperties(rPrNode);
+      if (paragraph || run) {
+        docDefaults = {
+          ...(paragraph ? { paragraph } : {}),
+          ...(run ? { run } : {}),
+        };
+      }
+      continue;
+    }
+
     if (local === "style") {
       const styleType = child.attributes["w:type"] ?? child.attributes.type;
       const styleId = child.attributes["w:styleId"] ?? child.attributes.styleId;
@@ -135,6 +155,10 @@ export function parseStylesXml(xml: string): ParseStylesResult {
           const nextStyle = readLinkedStyleId(child, "next");
           const outlineLevel = readParagraphStyleOutlineLevel(child);
           const numbering = readParagraphStyleNumbering(child);
+          const pPrNode = findChildElementOptional(child, "pPr");
+          const rPrNode = findChildElementOptional(child, "rPr");
+          const paragraphProperties = readParagraphProperties(pPrNode);
+          const runProperties = readRunProperties(rPrNode);
           paragraphs[styleId] = {
             styleId,
             displayName,
@@ -144,16 +168,21 @@ export function parseStylesXml(xml: string): ParseStylesResult {
             ...(nextStyle ? { nextStyle } : {}),
             ...(outlineLevel !== undefined ? { outlineLevel } : {}),
             ...(numbering ? { numbering } : {}),
+            ...(paragraphProperties ? { paragraphProperties } : {}),
+            ...(runProperties ? { runProperties } : {}),
           };
           break;
         }
         case "character": {
+          const rPrNode = findChildElementOptional(child, "rPr");
+          const runProperties = readRunProperties(rPrNode);
           characters[styleId] = {
             styleId,
             displayName,
             kind: "character",
             isDefault,
             ...(basedOn ? { basedOn } : {}),
+            ...(runProperties ? { runProperties } : {}),
           };
           break;
         }
@@ -194,6 +223,8 @@ export function parseStylesXml(xml: string): ParseStylesResult {
       characters,
       tables,
       ...(hasLatent ? { latentStyles } : {}),
+      fromPackage: true,
+      ...(docDefaults ? { docDefaults } : {}),
     },
     fromPackage: true,
     diagnostics,

package/src/io/ooxml/xml-attr-helpers.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared XML helpers for OOXML parsers.
+ *
+ * These functions factor out the common pattern of reading namespaced-prefixed
+ * attributes (e.g., `w:val`) with fallback to the unprefixed form, handling
+ * the OOXML `ST_OnOff` toggle semantics (missing child = undefined, present
+ * with no val = true, `val="0"|"false"|"off"` = false), and reading integers.
+ *
+ * Used by parse-run-formatting.ts, parse-paragraph-formatting.ts, and (later)
+ * parse-styles.ts, parse-numbering.ts.
+ */
+
+import type { XmlElementNode } from "./xml-element.ts";
+
+export function localName(name: string): string {
+  const sep = name.indexOf(":");
+  return sep >= 0 ? name.slice(sep + 1) : name;
+}
+
+export function findChildOptional(
+  node: XmlElementNode,
+  local: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (c): c is XmlElementNode => c.type === "element" && localName(c.name) === local,
+  );
+}
+
+/** ST_OnOff: missing child → undefined; present bare or w:val="1|true|on" → true; w:val="0|false|off" → false. */
+export function readOnOff(node: XmlElementNode | undefined): boolean | undefined {
+  if (!node) return undefined;
+  const raw = node.attributes["w:val"] ?? node.attributes.val;
+  if (raw === undefined) return true;
+  const n = raw.toLowerCase();
+  if (n === "0" || n === "false" || n === "off") return false;
+  if (n === "1" || n === "true" || n === "on") return true;
+  return true;
+}
+
+/** Read the child's `w:val` attribute as an int. Returns undefined if missing or not a finite integer. */
+export function readIntVal(node: XmlElementNode | undefined): number | undefined {
+  if (!node) return undefined;
+  const raw = node.attributes["w:val"] ?? node.attributes.val;
+  if (raw === undefined) return undefined;
+  const v = Number.parseInt(raw, 10);
+  return Number.isFinite(v) ? v : undefined;
+}
+
+/** Read an arbitrary attribute from a node as an int, with namespace fallback. */
+export function readIntAttr(node: XmlElementNode, attr: string): number | undefined {
+  const raw = node.attributes[attr] ?? node.attributes[attr.replace(/^w:/, "")];
+  if (raw === undefined) return undefined;
+  const v = Number.parseInt(raw, 10);
+  return Number.isFinite(v) ? v : undefined;
+}
+
+/** Read an arbitrary attribute from a node as a string, with namespace fallback. */
+export function readStringAttr(node: XmlElementNode, attr: string): string | undefined {
+  return node.attributes[attr] ?? node.attributes[attr.replace(/^w:/, "")];
+}

package/src/io/ooxml/xml-element.ts

@@ -0,0 +1,19 @@
+export interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: Array<XmlElementNode | XmlTextNode>;
+  /** Optional source offset (start) — parsers that track offsets may populate. */
+  start?: number;
+  /** Optional source offset (end) — parsers that track offsets may populate. */
+  end?: number;
+}
+
+export interface XmlTextNode {
+  type: "text";
+  text: string;
+  start?: number;
+  end?: number;
+}
+
+export type XmlNode = XmlElementNode | XmlTextNode;