@beyondwork/docx-react-component 1.0.11 → 1.0.13

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

@@ -13,6 +13,8 @@ import {
   type InlineMediaPart,
 } from "./parse-inline-media.ts";
 import { toCanonicalNumberingInstanceId } from "./parse-numbering.ts";
+import { parseComplexContentXml } from "./parse-complex-content.ts";
+import { parseShapeXml, parseVmlXml } from "./parse-shapes.ts";
 
 export interface ParsedMainDocument {
   blocks: ParsedBlockNode[];
@@ -59,7 +61,15 @@ export type ParsedInlineNode =
   | ParsedSymbolNode
   | ParsedImageNode
   | ParsedHyperlinkNode
-  | ParsedOpaqueInlineNode;
+  | ParsedOpaqueInlineNode
+  | ParsedChartPreviewNode
+  | ParsedSmartArtPreviewNode
+  | ParsedShapeInlineNode
+  | ParsedWordArtInlineNode
+  | ParsedVmlShapeInlineNode
+  | ParsedBookmarkStartInlineNode
+  | ParsedBookmarkEndInlineNode
+  | ParsedFieldInlineNode;
 
 export interface ParsedTextNode {
   type: "text";
@@ -126,6 +136,60 @@ export interface ParsedOpaqueInlineNode {
   rawXml: string;
 }
 
+export interface ParsedChartPreviewNode {
+  type: "chart_preview";
+  previewMediaId?: string;
+  rawXml: string;
+}
+
+export interface ParsedSmartArtPreviewNode {
+  type: "smartart_preview";
+  previewMediaId?: string;
+  rawXml: string;
+}
+
+export interface ParsedShapeInlineNode {
+  type: "shape";
+  text?: string;
+  geometry?: string;
+  rawXml: string;
+}
+
+export interface ParsedWordArtInlineNode {
+  type: "wordart";
+  text: string;
+  geometry?: string;
+  rawXml: string;
+}
+
+export interface ParsedVmlShapeInlineNode {
+  type: "vml_shape";
+  text?: string;
+  shapeType?: string;
+  rawXml: string;
+}
+
+export interface ParsedBookmarkStartInlineNode {
+  type: "bookmark_start";
+  bookmarkId: string;
+  name: string;
+  rawXml: string;
+}
+
+export interface ParsedBookmarkEndInlineNode {
+  type: "bookmark_end";
+  bookmarkId: string;
+  rawXml: string;
+}
+
+export interface ParsedFieldInlineNode {
+  type: "field";
+  fieldType: "simple";
+  instruction: string;
+  contentXml: string;
+  rawXml: string;
+}
+
 export interface ParsedOpaqueBlockNode {
   type: "opaque_block";
   rawXml: string;
@@ -345,6 +409,7 @@ function parseBodyChild(
         break;
       case "bookmarkStart":
       case "bookmarkEnd":
+      case "fldSimple":
       case "permStart":
       case "permEnd":
       case "proofErr":
@@ -696,10 +761,10 @@ function readTableGridColumns(node: XmlElementNode): number[] {
  * are implemented in the table editing path.
  */
 function tableRequiresOpaquePreservation(rawXml: string): boolean {
-  // For now, only parse tables that contain exclusively simple content
-  // (plain text, basic formatting). Any complex OOXML stays opaque.
-  // This list will shrink as the table editing path gains feature coverage.
-  return /<w:(ins|del|rPrChange|pPrChange|tblPrChange|trPrChange|tcPrChange|sectPrChange|cellIns|cellDel|cellMerge|hyperlink|commentRangeStart|commentRangeEnd|commentReference|bookmarkStart|bookmarkEnd|rStyle|pict|fldChar|fldSimple|smartTag|gridAfter|gridBefore|hideMark|tblHeader|tblCellSpacing|bCs)\b/.test(rawXml);
+  // Tables with revision markup, complex content, or structural tags stay opaque.
+  // Safe tags (hyperlinks, bookmarks, comments, basic formatting) are now allowed
+  // since they are handled by the paragraph parser within table cells.
+  return /<w:(ins|del|rPrChange|pPrChange|tblPrChange|trPrChange|tcPrChange|sectPrChange|cellIns|cellDel|cellMerge|pict|fldChar|fldSimple|smartTag|gridAfter|gridBefore|tblCellSpacing)\b/.test(rawXml);
 }
 
 function readCellGridSpan(node: XmlElementNode): number | undefined {
@@ -1072,8 +1137,37 @@ function parseRun(
         }
         break;
       case "drawing": {
+        const drawingXml = sourceXml.slice(child.start, child.end);
+
+        // Try complex content (charts / SmartArt) first
+        try {
+          const complexContent = parseComplexContentXml(
+            drawingXml,
+            relationships,
+            mediaParts,
+            sourcePartPath,
+          );
+          if (complexContent) {
+            result.push(complexContent);
+            break;
+          }
+        } catch {
+          // Fall through to shape / image parsing
+        }
+
+        // Try shape / WordArt parsing
+        try {
+          const shapeResult = parseShapeXml(drawingXml);
+          if (shapeResult) {
+            result.push(shapeResult);
+            break;
+          }
+        } catch {
+          // Fall through to image parsing
+        }
+
         const parsedMedia = parseInlineMediaXml(
-          sourceXml.slice(child.start, child.end),
+          drawingXml,
           relationships,
           mediaParts,
           sourcePartPath,
@@ -1112,6 +1206,29 @@ function parseRun(
         );
         break;
       }
+      case "pict": {
+        const pictXml = sourceXml.slice(child.start, child.end);
+        try {
+          const vmlResult = parseVmlXml(pictXml);
+          if (vmlResult) {
+            // Use the full run XML as rawXml so the export serializer can emit
+            // the complete <w:r>...<w:pict>...</w:pict></w:r> wrapper
+            result.push({
+              ...vmlResult,
+              rawXml: sourceXml.slice(node.start, node.end),
+            });
+            break;
+          }
+        } catch {
+          // Fall through to opaque
+        }
+        encounteredUnsupportedChild = true;
+        result.push({
+          type: "opaque_inline",
+          rawXml: pictXml,
+        });
+        break;
+      }
       case "commentReference":
         break;
       case "lastRenderedPageBreak":
@@ -1454,6 +1571,52 @@ function readRunMarks(node: XmlElementNode, sourceXml: string): MarksParseResult
     marks.push(textFillMark);
   }
 
+  // Font family
+  const rFontsNode = properties.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "rFonts",
+  );
+  if (rFontsNode) {
+    const family = rFontsNode.attributes["w:ascii"] ?? rFontsNode.attributes["w:hAnsi"] ?? rFontsNode.attributes.ascii ?? rFontsNode.attributes.hAnsi;
+    if (family) {
+      marks.push({ type: "fontFamily", val: family });
+    }
+  }
+
+  // Font size (half-points)
+  const szNode = properties.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "sz",
+  );
+  if (szNode) {
+    const szVal = szNode.attributes["w:val"] ?? szNode.attributes.val;
+    if (szVal) {
+      const size = Number.parseInt(szVal, 10);
+      if (Number.isFinite(size) && size > 0) {
+        marks.push({ type: "fontSize", val: size });
+      }
+    }
+  }
+
+  // Text color
+  const colorNode = properties.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "color",
+  );
+  if (colorNode) {
+    const colorVal = colorNode.attributes["w:val"] ?? colorNode.attributes.val;
+    if (colorVal && colorVal !== "auto") {
+      marks.push({ type: "textColor", color: colorVal });
+    }
+  }
+
+  // Small caps
+  if (hasOnOffProperty(properties, "smallCaps")) {
+    marks.push({ type: "smallCaps" });
+  }
+
+  // All caps
+  if (hasOnOffProperty(properties, "caps")) {
+    marks.push({ type: "allCaps" });
+  }
+
   return {
     marks,
     supported: true,

package/src/io/opc/package-reader.ts

@@ -271,7 +271,7 @@ function parseRelationshipsXml(xml: string): OpcRelationship[] {
 }
 
 function findTagAttributes(xml: string, tagName: string): Record<string, string>[] {
-  const tagPattern = new RegExp(`<${tagName}\\b([^>]*)\\/?>`, "g");
+  const tagPattern = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?${tagName}\\b([^>]*)\\/?>`, "g");
   const results: Record<string, string>[] = [];
   let tagMatch: RegExpExecArray | null = tagPattern.exec(xml);
 
@@ -285,11 +285,11 @@ function findTagAttributes(xml: string, tagName: string): Record<string, string>
 
 function parseAttributes(rawAttributes: string): Record<string, string> {
   const attributes: Record<string, string> = {};
-  const attributePattern = /([A-Za-z_][\w:.-]*)="([^"]*)"/g;
+  const attributePattern = /([A-Za-z_][\w:.-]*)\s*=\s*(["'])([\s\S]*?)\2/g;
   let match: RegExpExecArray | null = attributePattern.exec(rawAttributes);
 
   while (match) {
-    attributes[match[1]] = decodeXmlEntities(match[2]);
+    attributes[match[1]] = decodeXmlEntities(match[3]);
     match = attributePattern.exec(rawAttributes);
   }
 

package/src/io/source-package-provenance.ts

@@ -0,0 +1,241 @@
+import type { PersistedSourcePackage } from "../model/snapshot.ts";
+import { DOCX_MIME_TYPE } from "./opc/docx-package.ts";
+
+const SHA256_INITIAL_STATE = [
+  0x6a09e667,
+  0xbb67ae85,
+  0x3c6ef372,
+  0xa54ff53a,
+  0x510e527f,
+  0x9b05688c,
+  0x1f83d9ab,
+  0x5be0cd19,
+] as const;
+
+const SHA256_CONSTANTS = [
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+] as const;
+
+export function createPersistedSourcePackage(
+  bytes: Uint8Array | ArrayBuffer,
+  sourceLabel?: string,
+): PersistedSourcePackage {
+  const normalizedBytes = toUint8Array(bytes);
+
+  return {
+    format: "docx",
+    storage: "embedded-base64",
+    mimeType: DOCX_MIME_TYPE,
+    sourceLabel:
+      typeof sourceLabel === "string" && sourceLabel.trim().length > 0
+        ? sourceLabel
+        : undefined,
+    sha256Hex: sha256Hex(normalizedBytes),
+    bytesBase64: encodeBytesBase64(normalizedBytes),
+  };
+}
+
+export function decodePersistedSourcePackageBytes(
+  sourcePackage: PersistedSourcePackage,
+): Uint8Array {
+  return decodeBytesBase64(sourcePackage.bytesBase64);
+}
+
+export function hasValidPersistedSourcePackageDigest(
+  sourcePackage: PersistedSourcePackage,
+  bytes: Uint8Array,
+): boolean {
+  return sha256Hex(bytes) === sourcePackage.sha256Hex;
+}
+
+export function encodeBytesBase64(bytes: Uint8Array): string {
+  const bufferConstructor = getBufferConstructor();
+  if (bufferConstructor) {
+    return bufferConstructor.from(bytes).toString("base64");
+  }
+
+  let binary = "";
+  for (let offset = 0; offset < bytes.byteLength; offset += 0x8000) {
+    const chunk = bytes.subarray(offset, offset + 0x8000);
+    for (let index = 0; index < chunk.length; index += 1) {
+      binary += String.fromCharCode(chunk[index] ?? 0);
+    }
+  }
+
+  if (typeof btoa !== "function") {
+    throw new Error("Base64 encoding is unavailable in this runtime.");
+  }
+
+  return btoa(binary);
+}
+
+export function decodeBytesBase64(value: string): Uint8Array {
+  const bufferConstructor = getBufferConstructor();
+  if (bufferConstructor) {
+    return new Uint8Array(bufferConstructor.from(value, "base64"));
+  }
+
+  if (typeof atob !== "function") {
+    throw new Error("Base64 decoding is unavailable in this runtime.");
+  }
+
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+export function sha256Hex(bytes: Uint8Array): string {
+  const padded = padSha256Message(bytes);
+  const state = Array.from(SHA256_INITIAL_STATE, (value) => value >>> 0);
+  const schedule = new Uint32Array(64);
+
+  for (let chunkOffset = 0; chunkOffset < padded.byteLength; chunkOffset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const wordOffset = chunkOffset + index * 4;
+      schedule[index] =
+        (((padded[wordOffset] ?? 0) << 24) |
+          ((padded[wordOffset + 1] ?? 0) << 16) |
+          ((padded[wordOffset + 2] ?? 0) << 8) |
+          (padded[wordOffset + 3] ?? 0)) >>>
+        0;
+    }
+
+    for (let index = 16; index < 64; index += 1) {
+      schedule[index] = add32(
+        lowerSigma1(schedule[index - 2] ?? 0),
+        schedule[index - 7] ?? 0,
+        lowerSigma0(schedule[index - 15] ?? 0),
+        schedule[index - 16] ?? 0,
+      );
+    }
+
+    let [a, b, c, d, e, f, g, h] = state;
+
+    for (let index = 0; index < 64; index += 1) {
+      const t1 = add32(
+        h,
+        upperSigma1(e),
+        choose(e, f, g),
+        SHA256_CONSTANTS[index] ?? 0,
+        schedule[index] ?? 0,
+      );
+      const t2 = add32(upperSigma0(a), majority(a, b, c));
+
+      h = g;
+      g = f;
+      f = e;
+      e = add32(d, t1);
+      d = c;
+      c = b;
+      b = a;
+      a = add32(t1, t2);
+    }
+
+    state[0] = add32(state[0] ?? 0, a);
+    state[1] = add32(state[1] ?? 0, b);
+    state[2] = add32(state[2] ?? 0, c);
+    state[3] = add32(state[3] ?? 0, d);
+    state[4] = add32(state[4] ?? 0, e);
+    state[5] = add32(state[5] ?? 0, f);
+    state[6] = add32(state[6] ?? 0, g);
+    state[7] = add32(state[7] ?? 0, h);
+  }
+
+  return state.map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+
+function padSha256Message(bytes: Uint8Array): Uint8Array {
+  const bitLength = bytes.byteLength * 8;
+  const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(bytes);
+  padded[bytes.byteLength] = 0x80;
+
+  const lengthOffset = paddedLength - 8;
+  for (let index = 0; index < 8; index += 1) {
+    const shift = (7 - index) * 8;
+    padded[lengthOffset + index] = Math.floor(bitLength / 2 ** shift) & 0xff;
+  }
+
+  return padded;
+}
+
+function rotateRight(value: number, shift: number): number {
+  return ((value >>> shift) | (value << (32 - shift))) >>> 0;
+}
+
+function add32(...values: number[]): number {
+  let total = 0;
+  for (const value of values) {
+    total = (total + value) >>> 0;
+  }
+  return total;
+}
+
+function choose(x: number, y: number, z: number): number {
+  return ((x & y) ^ (~x & z)) >>> 0;
+}
+
+function majority(x: number, y: number, z: number): number {
+  return ((x & y) ^ (x & z) ^ (y & z)) >>> 0;
+}
+
+function upperSigma0(value: number): number {
+  return (rotateRight(value, 2) ^ rotateRight(value, 13) ^ rotateRight(value, 22)) >>> 0;
+}
+
+function upperSigma1(value: number): number {
+  return (rotateRight(value, 6) ^ rotateRight(value, 11) ^ rotateRight(value, 25)) >>> 0;
+}
+
+function lowerSigma0(value: number): number {
+  return (rotateRight(value, 7) ^ rotateRight(value, 18) ^ (value >>> 3)) >>> 0;
+}
+
+function lowerSigma1(value: number): number {
+  return (rotateRight(value, 17) ^ rotateRight(value, 19) ^ (value >>> 10)) >>> 0;
+}
+
+function toUint8Array(bytes: Uint8Array | ArrayBuffer): Uint8Array {
+  return bytes instanceof Uint8Array ? new Uint8Array(bytes) : new Uint8Array(bytes);
+}
+
+function getBufferConstructor():
+  | {
+      from(
+        value: Uint8Array | string,
+        byteOffsetOrEncoding?: number | string,
+        length?: number,
+      ): Uint8Array & { toString(encoding: string): string };
+    }
+  | undefined {
+  const maybeBuffer = (globalThis as {
+    Buffer?: {
+      from(
+        value: Uint8Array | string,
+        byteOffsetOrEncoding?: number | string,
+        length?: number,
+      ): Uint8Array & { toString(encoding: string): string };
+    };
+  }).Buffer;
+
+  return maybeBuffer;
+}