@beyondwork/docx-react-component 1.0.58 → 1.0.59

package/src/io/ooxml/parse-main-document.ts

@@ -37,8 +37,10 @@ import {
 import { toCanonicalNumberingInstanceId } from "./parse-numbering.ts";
 import { parseComplexContentXml, type ChartPartLookup } from "./parse-complex-content.ts";
 import { parseShapeXml, parseVmlXml } from "./parse-shapes.ts";
+import { parseObject } from "./parse-object.ts";
 import { parseDrawingFrame } from "./parse-drawing.ts";
 import { classifyFieldInstruction } from "./parse-fields.ts";
+import { parseFFDataFromFldChar } from "./parse-ffdata.ts";
 import { resolveHighlightColor } from "./highlight-colors.ts";
 import {
   readCellBorders as readSharedCellBorders,
@@ -76,6 +78,8 @@ import {
   capturePropertyGrabBag,
   type PropertyGrabBagDescriptor,
 } from "./property-grab-bag.ts";
+import { parseXmlWithOffsets as parseXml } from "./xml-parser.ts";
+import { localName } from "./xml-attr-helpers.ts";
 
 /**
  * Modelled direct children of `<w:sectPr>` that `parseSectionPropertiesFromElement`
@@ -277,6 +281,7 @@ export type ParsedInlineNode =
   | ParsedShapeInlineNode
   | ParsedWordArtInlineNode
   | ParsedVmlShapeInlineNode
+  | ParsedOleEmbedInlineNode
   | ParsedBookmarkStartInlineNode
   | ParsedBookmarkEndInlineNode
   | ParsedFootnoteRefInlineNode
@@ -393,6 +398,20 @@ export interface ParsedVmlShapeInlineNode {
   rawXml: string;
 }
 
+export interface ParsedOleEmbedInlineNode {
+  type: "ole_embed";
+  id: string;
+  progId?: string;
+  embedType: "oleObject";
+  relationshipId: string;
+  metadata: {
+    originalFilename?: string;
+    classId?: string;
+    shapeId?: string;
+  };
+  rawXml: string;
+}
+
 export interface ParsedBookmarkStartInlineNode {
   type: "bookmark_start";
   bookmarkId: string;
@@ -419,6 +438,7 @@ export interface ParsedFieldInlineNode {
   contentXml?: string;
   children?: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
   rawXml: string;
+  legacyFormField?: import("../../model/canonical-document.ts").LegacyFormFieldNode;
 }
 
 export interface ParsedPermStartInlineNode {
@@ -580,14 +600,21 @@ const HYPERLINK_RELATIONSHIP_TYPE =
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
 
 /**
- * Request-scoped chart-part lookup. Set by `parseMainDocumentXml` for
- * the duration of a single top-level parse; read by `parseRun` where
- * the `<w:drawing>` → `parseComplexContentXml` call site lives. Using a
- * module variable instead of threading the callback through ~8
- * intermediate function signatures keeps the call sites readable; the
- * try/finally in `parseMainDocumentXml` ensures the variable never
- * leaks across concurrent parses (Node.js is single-threaded; no
- * re-entrancy since the parser is fully synchronous).
+ * Request-scoped chart-part lookup. Set by `parseMainDocumentXml` (and
+ * `parseSdtXml` for isolated SDT parsing) for the duration of a single
+ * top-level parse; read by `parseRun` where the `<w:drawing>` →
+ * `parseComplexContentXml` call site lives. Using a module variable instead
+ * of threading the callback through ~8 intermediate function signatures keeps
+ * the call sites readable; the try/finally in each entry point ensures the
+ * variable never leaks across calls.
+ *
+ * **Re-entrancy invariant:** Node.js is single-threaded and the parser is
+ * fully synchronous, so no two top-level entry points can interleave.
+ * `parseSdtXml` must NEVER be called from within a `blockParser` callback
+ * that is itself executing inside a `parseMainDocumentXml` session — doing
+ * so would clobber the outer lookup and clear it on the inner finally, leaving
+ * the outer session with `undefined`. In the current codebase this path does
+ * not exist; `parseSdtXml` is only callable externally via `parsePictureSdt`.
  */
 let activeChartPartLookup: ChartPartLookup | undefined;
 
@@ -606,13 +633,49 @@ export function parseMainDocumentXml(
   }
 }
 
+/**
+ * CO4.5 — Parse a raw `<w:sdt>` XML fragment in isolation, with full drawing-
+ * frame support. Used by `parse-picture-sdt.ts` and tests.
+ *
+ * Falls back to `{ type: "opaque_block", rawXml }` on any parse failure
+ * (malformed XML, no `<w:sdt>` root, etc.) so callers never need to
+ * try/catch. The `activeChartPartLookup` module variable is guarded via
+ * try/catch/finally so it is always cleared even on error — see the
+ * re-entrancy invariant comment on the variable declaration above.
+ */
+export function parseSdtXml(
+  rawXml: string,
+  relationships: readonly OpcRelationship[] = [],
+  mediaParts: ReadonlyMap<string, InlineMediaPart> = new Map(),
+  sourcePartPath = "/word/document.xml",
+  chartPartLookup?: ChartPartLookup,
+): ParsedBlockNode {
+  activeChartPartLookup = chartPartLookup;
+  try {
+    const root = parseXml(rawXml) as XmlElementNode;
+    const sdtEl = root.children.find(
+      (c): c is XmlElementNode =>
+        c.type === "element" && localName(c.name) === "sdt",
+    );
+    if (!sdtEl) {
+      return { type: "opaque_block", rawXml };
+    }
+    const relationshipMap = new Map(relationships.map((r) => [r.id, r]));
+    return parseSdtElement(sdtEl, rawXml, relationshipMap, relationships, mediaParts, sourcePartPath);
+  } catch {
+    return { type: "opaque_block", rawXml };
+  } finally {
+    activeChartPartLookup = undefined;
+  }
+}
+
 function parseMainDocumentXmlInner(
   xml: string,
   relationships: readonly OpcRelationship[],
   mediaParts: ReadonlyMap<string, InlineMediaPart>,
   sourcePartPath: string,
 ): ParsedMainDocument {
-  const root = parseXml(xml);
+  const root = parseXml(xml) as XmlElementNode;
   const documentElement = findChildElement(root, "document");
   const bodyElement = findChildElement(documentElement, "body");
   const relationshipMap = new Map(relationships.map((relationship) => [relationship.id, relationship]));
@@ -727,32 +790,68 @@ function rewriteScopeMarkerBookmarks(blocks: ParsedBlockNode[]): void {
  * Input XML must be a root element whose children are body-child elements
  * (w:p, w:tbl, w:sdt, etc.) — matches the structure of `w:txbxContent`.
  */
+/**
+ * Phase 4.3 G3 — maximum recursion depth for nested
+ * `w:drawing → w:txbxContent → w:drawing → …` chains. OOXML nesting past 3
+ * is already pathological; 8 is a generous ceiling that guards against stack
+ * overflow on malicious / corrupt inputs.
+ */
+const TXBX_BLOCK_STREAM_MAX_DEPTH = 8;
+
+/**
+ * Module-local counter set by `parseBlockStreamFromXml` during its sync scope.
+ * Consumed by the blockParser closure in `case "drawing"` to forward the
+ * current depth into the recursive call. Parsing is synchronous, so a simple
+ * scalar is safe (no concurrent calls on the same stack).
+ */
+let activeTxbxBlockStreamDepth = 0;
+
 export function parseBlockStreamFromXml(
   xml: string,
   ctx: {
     relationships: readonly OpcRelationship[];
     mediaParts: ReadonlyMap<string, InlineMediaPart>;
     sourcePartPath: string;
+    /** Recursion depth — incremented each time blockParser is invoked from
+     * inside parseDrawingFrame's txbxContent handling. Default 0. */
+    depth?: number;
   },
 ): ParsedBlockNode[] {
-  const root = parseXml(xml);
+  const depth = ctx.depth ?? 0;
+  if (depth > TXBX_BLOCK_STREAM_MAX_DEPTH) {
+    // Depth limit reached — return empty to halt infinite recursion. The
+    // outer ShapeContent.txbxContentXml still preserves the raw XML for
+    // round-trip, so no data is lost, only deep-nested structural parse.
+    return [];
+  }
+  const root = parseXml(xml) as XmlElementNode;
   const relationshipMap = new Map(
     ctx.relationships.map((r) => [r.id, r] as const),
   );
   const wrapper =
     root.children.find((c): c is XmlElementNode => c.type === "element") ?? root;
-  return wrapper.children
-    .filter((n): n is XmlElementNode => n.type === "element")
-    .map((n) =>
-      parseBodyChild(
-        n,
-        xml,
-        relationshipMap,
-        ctx.relationships,
-        ctx.mediaParts,
-        ctx.sourcePartPath,
-      ),
-    );
+
+  // Set module-local depth for the duration of the sync walk so the drawing
+  // case's blockParser closure sees our depth and can bump it further.
+  const priorDepth = activeTxbxBlockStreamDepth;
+  activeTxbxBlockStreamDepth = depth;
+  try {
+    return wrapper.children
+      .filter((n): n is XmlElementNode => n.type === "element")
+      .map((n) =>
+        parseBodyChild(
+          n,
+          xml,
+          relationshipMap,
+          ctx.relationships,
+          ctx.mediaParts,
+          ctx.sourcePartPath,
+          depth,
+        ),
+      );
+  } finally {
+    activeTxbxBlockStreamDepth = priorDepth;
+  }
 }
 
 function parseBodyChild(
@@ -762,6 +861,10 @@ function parseBodyChild(
   relationships: readonly OpcRelationship[],
   mediaParts: ReadonlyMap<string, InlineMediaPart>,
   sourcePartPath: string,
+  /** Phase 4.3 G3 — unused marker (depth tracked via module-local
+   * activeTxbxBlockStreamDepth); kept for interface compatibility with
+   * parseBlockStreamFromXml's mapping callback. */
+  _depth = 0,
 ): ParsedBlockNode {
   const nodeType = localName(node.name);
 
@@ -845,6 +948,7 @@ function parseBodyChild(
     instruction: string;
     children: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
     mode: "instruction" | "result";
+    legacyFormField?: import("../../model/canonical-document.ts").LegacyFormFieldNode;
   } | null = null;
 
   for (const child of node.children) {
@@ -1071,6 +1175,7 @@ function appendParagraphRunNodes(
     instruction: string;
     children: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
     mode: "instruction" | "result";
+    legacyFormField?: import("../../model/canonical-document.ts").LegacyFormFieldNode;
   } | null,
   sourceXml: string,
   relationships: readonly OpcRelationship[],
@@ -1080,6 +1185,7 @@ function appendParagraphRunNodes(
   instruction: string;
   children: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
   mode: "instruction" | "result";
+  legacyFormField?: import("../../model/canonical-document.ts").LegacyFormFieldNode;
 } | null {
   const hasFieldMarkers = node.children.some(
     (child) =>
@@ -1115,7 +1221,13 @@ function appendParagraphRunNodes(
     if (name === "fldChar") {
       const fldType = child.attributes["w:fldCharType"] ?? child.attributes.fldCharType;
       if (fldType === "begin") {
-        activeComplexField = { instruction: "", children: [], mode: "instruction" };
+        const legacyFormField = parseFFDataFromFldChar(child, sourceXml);
+        activeComplexField = {
+          instruction: "",
+          children: [],
+          mode: "instruction",
+          ...(legacyFormField ? { legacyFormField } : {}),
+        };
       } else if (fldType === "separate" && activeComplexField) {
         activeComplexField.mode = "result";
       } else if (fldType === "end" && activeComplexField) {
@@ -1156,6 +1268,7 @@ function flushActiveComplexField(
     instruction: string;
     children: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
     mode: "instruction" | "result";
+    legacyFormField?: import("../../model/canonical-document.ts").LegacyFormFieldNode;
   } | null,
 ): void {
   if (!activeComplexField || activeComplexField.instruction.trim().length === 0) {
@@ -1168,6 +1281,7 @@ function flushActiveComplexField(
     instruction: activeComplexField.instruction,
     children: activeComplexField.children,
     rawXml: "",
+    ...(activeComplexField.legacyFormField ? { legacyFormField: activeComplexField.legacyFormField } : {}),
   });
   reset();
 }
@@ -2220,7 +2334,15 @@ function parseRun(
             // `{ type: string; ... }` contract — each ParsedBlockNode variant
             // has a discriminant `type` field (paragraph | table | sdt | ...).
             blockParser: (xml) =>
-              parseBlockStreamFromXml(xml, { relationships, mediaParts, sourcePartPath }) as unknown as ReadonlyArray<{ type: string; [key: string]: unknown }>,
+              parseBlockStreamFromXml(xml, {
+                relationships,
+                mediaParts,
+                sourcePartPath,
+                // Phase 4.3 G3 — forward module-local recursion counter so
+                // pathological nested chains (drawing → txbx → drawing → txbx
+                // → …) terminate at TXBX_BLOCK_STREAM_MAX_DEPTH.
+                depth: activeTxbxBlockStreamDepth + 1,
+              }) as unknown as ReadonlyArray<{ type: string; [key: string]: unknown }>,
           });
           if (frame) {
             result.push(frame);
@@ -2323,6 +2445,30 @@ function parseRun(
         });
         break;
       }
+      case "object": {
+        // Lane 7c Slice 7c.1 — attempt OLE-object extraction. Falls
+        // through to the generic opaque-fragment path when the element
+        // does not contain a resolvable <o:OLEObject> relationship
+        // (legacy VML <w:object>, unknown ProgIDs without a relationship
+        // target, etc.), preserving the existing opaque-fragment
+        // semantics.
+        const objectXml = sourceXml.slice(child.start, child.end);
+        try {
+          const oleNode = parseObject(child, objectXml, relationships);
+          if (oleNode) {
+            result.push(oleNode);
+            break;
+          }
+        } catch {
+          // Fall through to opaque on any unexpected parse-time error.
+        }
+        encounteredUnsupportedChild = true;
+        result.push({
+          type: "opaque_inline",
+          rawXml: objectXml,
+        });
+        break;
+      }
       case "commentReference":
         break;
       case "footnoteReference": {
@@ -2934,10 +3080,6 @@ function findChildElement(node: XmlElementNode, childLocalName: string): XmlElem
   return child;
 }
 
-function localName(name: string): string {
-  const separatorIndex = name.indexOf(":");
-  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
-}
 
 function readOptionalAttribute(node: XmlElementNode, name: string): string | undefined {
   return node.attributes[`w:${name}`]
@@ -2945,194 +3087,6 @@ function readOptionalAttribute(node: XmlElementNode, name: string): string | und
     ?? node.attributes[name];
 }
 
-function parseXml(xml: string): XmlElementNode {
-  const root: XmlElementNode = {
-    type: "element",
-    name: "__root__",
-    attributes: {},
-    children: [],
-    start: 0,
-    end: xml.length,
-  };
-  const stack: XmlElementNode[] = [root];
-  let cursor = 0;
-
-  while (cursor < xml.length) {
-    if (xml.startsWith("<!--", cursor)) {
-      const end = xml.indexOf("-->", cursor);
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-
-    if (xml.startsWith("<?", cursor)) {
-      const end = xml.indexOf("?>", cursor);
-      cursor = end >= 0 ? end + 2 : xml.length;
-      continue;
-    }
-
-    if (xml.startsWith("<![CDATA[", cursor)) {
-      const end = xml.indexOf("]]>", cursor);
-      const textEnd = end >= 0 ? end : xml.length;
-      stack[stack.length - 1]?.children.push({
-        type: "text",
-        text: xml.slice(cursor + 9, textEnd),
-        start: cursor,
-        end: end >= 0 ? end + 3 : xml.length,
-      });
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-
-    const currentChar = xml[cursor];
-    if (currentChar !== "<") {
-      const nextTag = xml.indexOf("<", cursor);
-      const end = nextTag >= 0 ? nextTag : xml.length;
-      const text = decodeXmlEntities(xml.slice(cursor, end));
-      if (text.length > 0) {
-        stack[stack.length - 1]?.children.push({
-          type: "text",
-          text,
-          start: cursor,
-          end,
-        });
-      }
-      cursor = end;
-      continue;
-    }
-
-    if (xml[cursor + 1] === "/") {
-      const end = xml.indexOf(">", cursor);
-      if (end < 0) {
-        throw new Error("Malformed XML: missing closing >.");
-      }
-
-      const name = xml.slice(cursor + 2, end).trim();
-      const current = stack.pop();
-      if (!current || localName(current.name) !== localName(name)) {
-        throw new Error(`Malformed XML: unexpected closing tag </${name}>.`);
-      }
-      current.end = end + 1;
-      cursor = end + 1;
-      continue;
-    }
-
-    const tagEnd = findTagEnd(xml, cursor);
-    const tagBody = xml.slice(cursor + 1, tagEnd);
-    const selfClosing = /\/\s*$/.test(tagBody);
-    const { name, attributes } = parseTag(tagBody.replace(/\/\s*$/, "").trim());
-    const element: XmlElementNode = {
-      type: "element",
-      name,
-      attributes,
-      children: [],
-      start: cursor,
-      end: tagEnd + 1,
-    };
-    stack[stack.length - 1]?.children.push(element);
-
-    if (!selfClosing) {
-      stack.push(element);
-    }
-
-    cursor = tagEnd + 1;
-  }
-
-  if (stack.length !== 1) {
-    throw new Error("Malformed XML: unclosed element in main document XML.");
-  }
-
-  return root;
-}
-
-function parseTag(tagBody: string): { name: string; attributes: Record<string, string> } {
-  let cursor = 0;
-  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
-    cursor += 1;
-  }
-
-  const nameStart = cursor;
-  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) {
-    cursor += 1;
-  }
-  const name = tagBody.slice(nameStart, cursor);
-  const attributes: Record<string, string> = {};
-
-  while (cursor < tagBody.length) {
-    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
-      cursor += 1;
-    }
-    if (cursor >= tagBody.length) {
-      break;
-    }
-
-    const keyStart = cursor;
-    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) {
-      cursor += 1;
-    }
-    const key = tagBody.slice(keyStart, cursor);
-
-    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
-      cursor += 1;
-    }
-
-    if (tagBody[cursor] !== "=") {
-      attributes[key] = "";
-      continue;
-    }
-    cursor += 1;
-
-    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
-      cursor += 1;
-    }
-
-    const quote = tagBody[cursor];
-    if (quote !== `"` && quote !== `'`) {
-      throw new Error(`Malformed XML attribute ${key}.`);
-    }
-    cursor += 1;
-
-    const valueStart = cursor;
-    while (cursor < tagBody.length && tagBody[cursor] !== quote) {
-      cursor += 1;
-    }
-    const rawValue = tagBody.slice(valueStart, cursor);
-    attributes[key] = decodeXmlEntities(rawValue);
-    cursor += 1;
-  }
-
-  return { name, attributes };
-}
-
-function findTagEnd(xml: string, start: number): number {
-  let cursor = start + 1;
-  let quote: string | null = null;
-
-  while (cursor < xml.length) {
-    const current = xml[cursor];
-    if (quote) {
-      if (current === quote) {
-        quote = null;
-      }
-      cursor += 1;
-      continue;
-    }
-
-    if (current === `"` || current === `'`) {
-      quote = current;
-      cursor += 1;
-      continue;
-    }
-
-    if (current === ">") {
-      return cursor;
-    }
-
-    cursor += 1;
-  }
-
-  throw new Error("Malformed XML: missing >.");
-}
-
 function decodeXmlEntities(value: string): string {
   return value.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (match, entity) => {
     switch (entity) {
@@ -3442,14 +3396,23 @@ function readFootnoteLikeProperties(
         val === "lowerRoman" ||
         val === "upperLetter" ||
         val === "lowerLetter" ||
+        val === "ordinal" ||
+        val === "cardinalText" ||
+        val === "ordinalText" ||
+        val === "hex" ||
         val === "chicago" ||
+        val === "bullet" ||
+        val === "ideographDigital" ||
+        val === "japaneseCounting" ||
+        val === "arabicAbjad" ||
+        val === "arabicAlpha" ||
         val === "none"
       ) {
         result.numFmt = val;
       }
     } else if (name === "numStart") {
       const n = safeParseInt(val);
-      if (n !== undefined) result.numStart = n;
+      if (n !== undefined) result.numStart = Math.max(1, n);
     } else if (name === "numRestart") {
       if (val === "continuous" || val === "eachSect" || val === "eachPage") {
         result.numRestart = val;