@beyondwork/docx-react-component 1.0.19 → 1.0.21

package/src/io/docx-session.ts

@@ -7,6 +7,8 @@ import type {
   ExportDocxOptions,
   ExportResult,
   PersistedEditorSnapshot,
+  ProtectionRange,
+  ProtectionSnapshot,
 } from "../api/public-types.ts";
 import { editorSessionStateFromPersistedSnapshot } from "../api/session-state.ts";
 import type {
@@ -25,7 +27,12 @@ import {
 } from "../core/selection/mapping.ts";
 import { DOCX_MIME_TYPE } from "./opc/docx-package.ts";
 import { readOpcPackage, type OpcPackage } from "./opc/package-reader.ts";
-import { parseMainDocumentXml } from "./ooxml/parse-main-document.ts";
+import {
+  parseMainDocumentXml,
+  type ParsedBlockNode,
+  type ParsedInlineNode,
+  type ParsedPermStartInlineNode,
+} from "./ooxml/parse-main-document.ts";
 import { normalizeParsedTextDocument } from "./normalize/normalize-text.ts";
 import {
   CONTENT_TYPES_PATH,
@@ -47,6 +54,7 @@ import { parseCommentsFromOoxml } from "./ooxml/parse-comments.ts";
 import { parseNumberingXml } from "./ooxml/parse-numbering.ts";
 import {
   createCommentExportIdMap,
+  mapParagraphBoundaries,
   serializeCommentAnchorsIntoDocumentXml,
   serializeMergedCommentsXml,
 } from "./export/serialize-comments.ts";
@@ -181,6 +189,7 @@ export interface LoadedDocxEditorSession {
   initialSnapshot: PersistedEditorSnapshot;
   fatalError?: EditorError;
   readOnly: boolean;
+  protectionSnapshot: ProtectionSnapshot;
   exportDocx: (
     sessionState: EditorSessionState | PersistedEditorSnapshot,
     options?: ExportDocxOptions,
@@ -208,6 +217,7 @@ interface ImportedDocxState {
   sourcePeopleRelationshipId?: string;
   sourcePeopleRootTag?: string;
   sourcePeopleAuthors: readonly string[];
+  protectionSnapshot: ProtectionSnapshot;
   preservedCommentDefinitions: readonly ImportedCommentDefinition[];
   blockingCommentDiagnostics: readonly CommentImportDiagnostic[];
   initialCanonicalSignature: string;
@@ -326,6 +336,7 @@ export function loadDocxEditorSession(
       mediaParts,
       mainDocumentPath,
     );
+    const protectionRanges = extractProtectionRanges(parsedDocument.blocks);
     const normalizedDocument = normalizeParsedTextDocument(
       parsedDocument,
       mainDocumentPath,
@@ -398,13 +409,14 @@ export function loadDocxEditorSession(
     const parsedFooters: FooterDocument[] = [];
     const sourceHeaderPaths: Array<{ partPath: string; relationshipId: string }> = [];
     const sourceFooterPaths: Array<{ partPath: string; relationshipId: string }> = [];
-    const seenSubPartRelIds = new Set<string>();
+    const seenSubPartKeys = new Set<string>();
 
     for (const ref of headerFooterRefs) {
-      if (seenSubPartRelIds.has(ref.relationshipId)) {
+      const dedupeKey = `${ref.kind}:${ref.variant}:${ref.relationshipId}`;
+      if (seenSubPartKeys.has(dedupeKey)) {
         continue;
       }
-      seenSubPartRelIds.add(ref.relationshipId);
+      seenSubPartKeys.add(dedupeKey);
 
       const relationship = documentPart.relationships.find(
         (r) => r.id === ref.relationshipId && r.targetMode === "internal",
@@ -504,6 +516,12 @@ export function loadDocxEditorSession(
             decodeUtf8(sourcePackage.parts.get(settingsPartPath)?.bytes ?? new Uint8Array()),
           )
         : undefined;
+    const settingsXmlForProtection =
+      settingsPartPath && sourcePackage.parts.has(settingsPartPath)
+        ? decodeUtf8(sourcePackage.parts.get(settingsPartPath)?.bytes ?? new Uint8Array())
+        : "";
+    const documentProtection = extractDocumentProtection(settingsXmlForProtection);
+    const importedProtectionSnapshot = buildProtectionSnapshot(documentProtection, protectionRanges);
 
     // ---- Parse styles.xml for canonical style catalog ----
     const stylesPartPath = resolveDocumentRelatedPartPath(
@@ -598,6 +616,7 @@ export function loadDocxEditorSession(
       timestamp,
       document,
       compatibility: toPublicCompatibilityReport(compatibility),
+      protectionSnapshot: importedProtectionSnapshot,
       sourcePackage: createPersistedSourcePackage(sourceBytes, options.sourceLabel),
     });
     const snapshotIssues = validatePersistedEditorSnapshot(snapshot);
@@ -657,6 +676,7 @@ export function loadDocxEditorSession(
       )?.id,
       sourcePeopleRootTag: normalizedComments.sourcePeopleRootTag,
       sourcePeopleAuthors: normalizedComments.peopleAuthors,
+      protectionSnapshot: buildProtectionSnapshot(documentProtection, protectionRanges),
       preservedCommentDefinitions: normalizedComments.preservedDefinitions,
       blockingCommentDiagnostics: normalizedComments.diagnostics.filter((diagnostic) =>
         BLOCKING_COMMENT_DIAGNOSTIC_CODES.has(diagnostic.code),
@@ -678,6 +698,7 @@ export function loadDocxEditorSession(
       initialSessionState,
       initialSnapshot: snapshot,
       readOnly: false,
+      protectionSnapshot: importedProtectionSnapshot,
       exportDocx: async (nextSessionState, exportOptions) =>
         exportDocxEditorSession(importedState, nextSessionState, exportOptions),
     };
@@ -701,11 +722,12 @@ function exportDocxEditorSession(
   }
 
   const currentDocument = sessionState.canonicalDocument as CanonicalDocumentEnvelope;
-  if (
-    serializeCanonicalDocumentForExport(currentDocument) ===
-      state.initialCanonicalSignature &&
-    canReuseSourceBytesForCurrentDocument(state, currentDocument)
-  ) {
+  const signatureMatch = serializeCanonicalDocumentForExport(currentDocument) ===
+      state.initialCanonicalSignature;
+  const canReuse = canReuseSourceBytesForCurrentDocument(state, currentDocument);
+  const commentCount = Object.keys(currentDocument.review?.comments ?? {}).length;
+
+  if (signatureMatch && canReuse) {
     return {
       bytes: new Uint8Array(state.sourceBytes),
       mimeType: DOCX_MIME_TYPE,
@@ -715,9 +737,16 @@ function exportDocxEditorSession(
       },
     };
   }
-  if (state.blockingCommentDiagnostics.length > 0) {
+  const preservedCommentIds = new Set(
+    state.preservedCommentDefinitions.map((definition) => definition.commentId),
+  );
+  const blockingCommentCount = Math.max(
+    state.blockingCommentDiagnostics.length,
+    preservedCommentIds.size,
+  );
+  if (blockingCommentCount > 0) {
     throw new Error(
-      `DOCX export is blocked because ${state.blockingCommentDiagnostics.length} preserve-only comment anchors cannot be safely remapped after runtime edits.`,
+      `DOCX export is blocked because ${blockingCommentCount} preserve-only comment anchors cannot be safely remapped after runtime edits.`,
     );
   }
   const currentRevisions = toReviewRevisionRecords(currentDocument.review.revisions);
@@ -727,9 +756,6 @@ function exportDocxEditorSession(
   const commentThreads = Object.values(
     createCommentStoreFromRuntimeComments(currentDocument.review.comments).threads,
   );
-  const preservedCommentIds = new Set(
-    state.preservedCommentDefinitions.map((definition) => definition.commentId),
-  );
   const ownedCommentThreads = commentThreads.filter(
     (thread) => !preservedCommentIds.has(thread.commentId),
   );
@@ -783,6 +809,10 @@ function exportDocxEditorSession(
       exportCommentIds,
     },
   );
+  const protectedDocumentXml = serializeProtectionRangesIntoDocumentXml(
+    annotatedDocument.documentXml,
+    state.protectionSnapshot,
+  );
   const blockingSkippedCommentIds = annotatedDocument.skippedCommentIds.filter((commentId) => {
     const thread = ownedCommentThreads.find((candidate) => candidate.commentId === commentId);
     return !thread || thread.anchor.kind !== "detached";
@@ -889,7 +919,7 @@ function exportDocxEditorSession(
 
   exportSession.replaceOwnedPart({
     path: state.sourceDocumentPartPath,
-    bytes: new TextEncoder().encode(annotatedDocument.documentXml),
+    bytes: new TextEncoder().encode(protectedDocumentXml),
     contentType: MAIN_DOCUMENT_CONTENT_TYPE,
     relationships: nextRelationships,
   });
@@ -1246,6 +1276,7 @@ function createImportedSnapshot(input: {
   timestamp: string;
   document: CanonicalDocumentEnvelope;
   compatibility: PersistedEditorSnapshot["compatibility"];
+  protectionSnapshot: ProtectionSnapshot;
   sourcePackage?: PersistedEditorSnapshot["sourcePackage"];
 }): PersistedEditorSnapshot {
   return {
@@ -1260,6 +1291,7 @@ function createImportedSnapshot(input: {
     canonicalDocument: input.document,
     compatibility: input.compatibility,
     warningLog: input.compatibility.warnings,
+    protectionSnapshot: input.protectionSnapshot,
     sourcePackage: input.sourcePackage,
   };
 }
@@ -1351,6 +1383,7 @@ function createDiagnosticsSession(
     initialSnapshot,
     fatalError: diagnostics.fatalError,
     readOnly: true,
+    protectionSnapshot: EMPTY_PROTECTION_SNAPSHOT,
     exportDocx: async (_sessionState, exportOptions) => runtime.exportDocx(exportOptions),
   };
 }
@@ -1466,8 +1499,10 @@ function normalizeImportedCommentThreads(
         commentId: thread.commentId,
         code: "opaque_anchor_preserve_only",
         message:
-          "Comment anchor intersects preserve-only OOXML and remains preserve-only on export.",
+          "Comment anchor intersects preserve-only OOXML content. Thread is visible but detached; anchor cannot be safely remapped.",
         featureClass: "preserve-only",
+        detachedReason: "opaque-region" as const,
+        actionabilityNote: "The comment body is preserved. The anchor overlaps opaque content that the editor cannot safely modify.",
       });
       return {
         ...thread,
@@ -1485,8 +1520,10 @@ function normalizeImportedCommentThreads(
         commentId: thread.commentId,
         code: "preserve_only_revision_overlap",
         message:
-          "Comment anchor overlaps preserve-only review markup and remains preserve-only on export.",
+          "Comment anchor overlaps preserve-only review markup. Thread is visible but detached; anchor cannot be safely remapped during editing.",
         featureClass: "preserve-only",
+        detachedReason: "revision-overlap" as const,
+        actionabilityNote: "The comment body is preserved. The anchor overlaps preserve-only revision markup that the editor cannot safely modify.",
       });
       return {
         ...thread,
@@ -2347,6 +2384,108 @@ function xmlNode(tagName: string, value: string | undefined): string | undefined
   return `<${tagName}>${escapeXml(value)}</${tagName.split(" ", 1)[0]}>`;
 }
 
+function serializeProtectionRangesIntoDocumentXml(
+  documentXml: string,
+  protection: ProtectionSnapshot,
+  paragraphs = mapParagraphBoundaries(documentXml),
+): string {
+  if (protection.ranges.length === 0) {
+    return documentXml;
+  }
+
+  const insertions = new Map<number, string[]>();
+
+  for (const range of protection.ranges) {
+    if (typeof range.start !== "number" || typeof range.end !== "number") {
+      continue;
+    }
+    const rangeStart = range.start;
+    const rangeEnd = range.end;
+
+    const startParagraph = paragraphs.find(
+      (candidate) => rangeStart >= candidate.start && rangeStart <= candidate.end,
+    );
+    const endParagraph = paragraphs.find(
+      (candidate) => rangeEnd >= candidate.start && rangeEnd <= candidate.end,
+    );
+    if (!startParagraph || !endParagraph) {
+      continue;
+    }
+
+    const startIndex =
+      startParagraph.boundaries.get(rangeStart) ??
+      findNearestBoundaryIndex(startParagraph.boundaries, rangeStart, "backward");
+    const endIndex =
+      endParagraph.boundaries.get(rangeEnd) ??
+      findNearestBoundaryIndex(endParagraph.boundaries, rangeEnd, "forward");
+    if (startIndex === undefined || endIndex === undefined) {
+      continue;
+    }
+
+    const permStartXml = [
+      `<w:permStart`,
+      ` w:id="${escapeXmlAttribute(range.rangeId)}"`,
+      range.editorGroup ? ` w:edGrp="${escapeXmlAttribute(range.editorGroup)}"` : "",
+      range.editor ? ` w:ed="${escapeXmlAttribute(range.editor)}"` : "",
+      `/>`,
+    ].join("");
+    const permEndXml = `<w:permEnd w:id="${escapeXmlAttribute(range.rangeId)}"/>`;
+
+    pushProtectionInsertion(insertions, startIndex, permStartXml);
+    pushProtectionInsertion(insertions, endIndex, permEndXml);
+  }
+
+  if (insertions.size === 0) {
+    return documentXml;
+  }
+
+  const parts: string[] = [];
+  let cursor = 0;
+  for (const [index, snippets] of [...insertions.entries()].sort(([left], [right]) => left - right)) {
+    parts.push(documentXml.slice(cursor, index));
+    parts.push(...snippets);
+    cursor = index;
+  }
+  parts.push(documentXml.slice(cursor));
+  return parts.join("");
+}
+
+function pushProtectionInsertion(
+  insertions: Map<number, string[]>,
+  index: number,
+  xml: string,
+): void {
+  const existing = insertions.get(index);
+  if (existing) {
+    existing.push(xml);
+    return;
+  }
+  insertions.set(index, [xml]);
+}
+
+function findNearestBoundaryIndex(
+  boundaries: Map<number, number>,
+  position: number,
+  direction: "backward" | "forward",
+): number | undefined {
+  const ordered = [...boundaries.entries()].sort(([left], [right]) => left - right);
+  if (direction === "backward") {
+    for (let index = ordered.length - 1; index >= 0; index -= 1) {
+      const [boundaryPos, boundaryIndex] = ordered[index]!;
+      if (boundaryPos <= position) {
+        return boundaryIndex;
+      }
+    }
+    return undefined;
+  }
+  for (const [boundaryPos, boundaryIndex] of ordered) {
+    if (boundaryPos >= position) {
+      return boundaryIndex;
+    }
+  }
+  return undefined;
+}
+
 function escapeXml(value: string): string {
   return value
     .replace(/&/g, "&amp;")
@@ -2355,3 +2494,210 @@ function escapeXml(value: string): string {
     .replace(/\"/g, "&quot;")
     .replace(/'/g, "&apos;");
 }
+
+function escapeXmlAttribute(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+// ---------------------------------------------------------------------------
+// Protection range extraction
+// ---------------------------------------------------------------------------
+
+const EMPTY_PROTECTION_SNAPSHOT: ProtectionSnapshot = {
+  hasDocumentProtection: false,
+  enforcementActive: false,
+  ranges: [],
+  enforcedRangeCount: 0,
+  preservedRangeCount: 0,
+};
+
+interface DocumentProtectionMeta {
+  editType?: string;
+  enforcement: boolean;
+}
+
+function extractDocumentProtection(settingsXml: string): DocumentProtectionMeta {
+  if (!settingsXml) return { enforcement: false };
+  const match = settingsXml.match(/<w:documentProtection\b([^/>]*)\/?>/);
+  if (!match) return { enforcement: false };
+  const attrs = match[1];
+  const editTypeMatch = attrs.match(/w:edit="([^"]*)"/);
+  const enforcementMatch = attrs.match(/w:enforcement="([^"]*)"/);
+  const editType = editTypeMatch?.[1];
+  const enforcement = enforcementMatch?.[1] === "1" || enforcementMatch?.[1] === "true";
+  return { editType, enforcement };
+}
+
+function extractProtectionRanges(blocks: readonly ParsedBlockNode[]): ProtectionRange[] {
+  const ranges: ProtectionRange[] = [];
+  const openRanges = new Map<string, Omit<ProtectionRange, "end">>();
+  collectProtectionRangesFromBlocks(blocks, ranges, openRanges, 0);
+  return ranges;
+}
+
+function collectProtectionRangesFromBlocks(
+  blocks: readonly ParsedBlockNode[],
+  ranges: ProtectionRange[],
+  openRanges: Map<string, Omit<ProtectionRange, "end">>,
+  cursor: number,
+): number {
+  let nextCursor = cursor;
+  let previousParagraph = false;
+
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      if (previousParagraph) {
+        nextCursor += 1;
+      }
+      nextCursor = collectProtectionRangesFromInlines(
+        block.children,
+        ranges,
+        openRanges,
+        nextCursor,
+      );
+      previousParagraph = true;
+      continue;
+    }
+
+    if (block.type === "table") {
+      nextCursor += 1;
+      previousParagraph = false;
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          nextCursor = collectProtectionRangesFromBlocks(
+            cell.children,
+            ranges,
+            openRanges,
+            nextCursor,
+          );
+        }
+      }
+      continue;
+    }
+
+    if (block.type === "sdt" || block.type === "custom_xml") {
+      nextCursor = collectProtectionRangesFromBlocks(
+        block.children,
+        ranges,
+        openRanges,
+        nextCursor,
+      );
+      previousParagraph = false;
+      continue;
+    }
+
+    nextCursor += 1;
+    previousParagraph = false;
+  }
+
+  return nextCursor;
+}
+
+function collectProtectionRangesFromInlines(
+  nodes: readonly ParsedInlineNode[],
+  ranges: ProtectionRange[],
+  openRanges: Map<string, Omit<ProtectionRange, "end">>,
+  cursor: number,
+): number {
+  let nextCursor = cursor;
+
+  for (const node of nodes) {
+    if (node.type === "perm_start") {
+      openRanges.set(node.rangeId, {
+        rangeId: node.rangeId,
+        start: nextCursor,
+        ...(node.editorGroup ? { editorGroup: node.editorGroup } : {}),
+        ...(node.editor ? { editor: node.editor } : {}),
+        enforced: false,
+        enforcementReason:
+          "preserve-only: runtime does not yet enforce permission range boundaries",
+      });
+      continue;
+    }
+
+    if (node.type === "perm_end") {
+      const openRange = openRanges.get(node.rangeId);
+      if (openRange) {
+        ranges.push({
+          ...openRange,
+          end: nextCursor,
+        });
+        openRanges.delete(node.rangeId);
+      }
+      continue;
+    }
+
+    nextCursor += measureParsedInlineNode(node);
+  }
+
+  return nextCursor;
+}
+
+function measureParsedInlineNode(node: ParsedInlineNode): number {
+  switch (node.type) {
+    case "text":
+      return node.text.length;
+    case "tab":
+    case "hard_break":
+    case "column_break":
+    case "footnote_ref":
+    case "image":
+    case "bookmark_start":
+    case "bookmark_end":
+      return 1;
+    case "hyperlink":
+      return node.children.reduce((size, child) => size + measureParsedInlineNode(child), 0);
+    case "field": {
+      const content = parseMainDocumentXml(
+        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body><w:p>${node.contentXml}</w:p></w:body></w:document>`,
+      );
+      if (content.blocks[0]?.type === "paragraph") {
+        return content.blocks[0].children.reduce(
+          (size, child) => size + measureParsedInlineNode(child),
+          0,
+        );
+      }
+      return 1;
+    }
+    default:
+      return 1;
+  }
+}
+
+function buildProtectionSnapshot(
+  documentProtection: DocumentProtectionMeta,
+  ranges: ProtectionRange[],
+): ProtectionSnapshot {
+  const hasDocumentProtection =
+    documentProtection.editType !== undefined || documentProtection.enforcement;
+  const enforceRanges =
+    documentProtection.editType === "readOnly" || documentProtection.editType === "comments";
+  const normalizedRanges = ranges.map((range) => {
+    const canEnforce =
+      hasDocumentProtection &&
+      documentProtection.enforcement &&
+      enforceRanges &&
+      typeof range.start === "number" &&
+      typeof range.end === "number" &&
+      range.end >= range.start;
+    return {
+      ...range,
+      enforced: canEnforce,
+      enforcementReason: canEnforce
+        ? "runtime-enforced: permission range is mapped to canonical positions"
+        : "preserve-only: runtime does not yet enforce permission range boundaries",
+    };
+  });
+  return {
+    hasDocumentProtection,
+    editType: documentProtection.editType,
+    enforcementActive: documentProtection.enforcement,
+    ranges: normalizedRanges,
+    enforcedRangeCount: normalizedRanges.filter((r) => r.enforced).length,
+    preservedRangeCount: normalizedRanges.filter((r) => !r.enforced).length,
+  };
+}

package/src/io/export/serialize-comments.ts

@@ -577,56 +577,126 @@ function parseOoxmlNumericId(value: string): number | undefined {
   return Number.isFinite(numericId) ? numericId : undefined;
 }
 
-function mapParagraphBoundaries(documentXml: string): ParagraphBoundaryMap[] {
+export function mapParagraphBoundaries(documentXml: string): ParagraphBoundaryMap[] {
   const root = parseXml(documentXml);
   const documentElement = findChildElement(root, "document");
   const bodyElement = findChildElement(documentElement, "body");
   const paragraphs: ParagraphBoundaryMap[] = [];
-  let globalCursor = 0;
-  let paragraphIndex = -1;
-  let previousWasParagraph = false;
+  walkBlockNodesForParagraphBoundaries(
+    bodyElement.children,
+    documentXml,
+    paragraphs,
+    0,
+    -1,
+    true,
+  );
+
+  return paragraphs;
+}
+
+function walkBlockNodesForParagraphBoundaries(
+  nodes: readonly XmlNode[],
+  documentXml: string,
+  paragraphs: ParagraphBoundaryMap[],
+  globalCursor: number,
+  paragraphIndex: number,
+  useSurfaceParagraphSeparators: boolean,
+): {
+  globalCursor: number;
+  paragraphIndex: number;
+} {
+  let nextCursor = globalCursor;
+  let nextParagraphIndex = paragraphIndex;
+  let elementIndex = -1;
 
-  for (const child of bodyElement.children) {
-    if (child.type !== "element") {
+  for (const node of nodes) {
+    if (node.type !== "element") {
+      continue;
+    }
+    elementIndex += 1;
+
+    const name = localName(node.name);
+    if (name === "p") {
+      if (useSurfaceParagraphSeparators && elementIndex > 0) {
+        nextCursor += 1;
+      }
+      nextParagraphIndex += 1;
+      const boundaries = new Map<number, number>();
+      boundaries.set(nextCursor, node.start + openingTagLength(documentXml, node.start));
+
+      walkParagraphForBoundaries(
+        node,
+        documentXml,
+        boundaries,
+        () => nextCursor,
+        (next) => {
+          nextCursor = next;
+        },
+      );
+
+      if (!boundaries.has(nextCursor)) {
+        boundaries.set(nextCursor, node.end - 4);
+      }
+      paragraphs.push({
+        paragraphIndex: nextParagraphIndex,
+        start: Math.min(...boundaries.keys()),
+        end: Math.max(...boundaries.keys()),
+        boundaries,
+      });
       continue;
     }
 
-    if (localName(child.name) !== "p") {
-      globalCursor += 1;
-      previousWasParagraph = false;
+    if (name === "tbl") {
+      for (const child of node.children) {
+        if (child.type !== "element" || localName(child.name) !== "tr") {
+          continue;
+        }
+        for (const rowChild of child.children) {
+          if (rowChild.type !== "element" || localName(rowChild.name) !== "tc") {
+            continue;
+          }
+          const result = walkBlockNodesForParagraphBoundaries(
+            rowChild.children,
+            documentXml,
+            paragraphs,
+            nextCursor,
+            nextParagraphIndex,
+            false,
+          );
+          nextCursor = result.globalCursor;
+          nextParagraphIndex = result.paragraphIndex;
+        }
+      }
       continue;
     }
 
-    if (previousWasParagraph) {
-      globalCursor += 1;
+    if (name === "sdt") {
+      const sdtContent = findChildElement(node, "sdtContent");
+      const result = walkBlockNodesForParagraphBoundaries(
+        sdtContent.children,
+        documentXml,
+        paragraphs,
+        nextCursor,
+        nextParagraphIndex,
+        false,
+      );
+      nextCursor = result.globalCursor;
+      nextParagraphIndex = result.paragraphIndex;
+      continue;
     }
-    paragraphIndex += 1;
-    const boundaries = new Map<number, number>();
-    boundaries.set(globalCursor, child.start + openingTagLength(documentXml, child.start));
-
-    walkParagraphForBoundaries(
-      child,
-      documentXml,
-      boundaries,
-      () => globalCursor,
-      (next) => {
-        globalCursor = next;
-      },
-    );
 
-    if (!boundaries.has(globalCursor)) {
-      boundaries.set(globalCursor, child.end - 4);
+    if (name === "customXml") {
+      nextCursor += 1;
+      continue;
     }
-    paragraphs.push({
-      paragraphIndex,
-      start: Math.min(...boundaries.keys()),
-      end: Math.max(...boundaries.keys()),
-      boundaries,
-    });
-    previousWasParagraph = true;
+
+    nextCursor += 0;
   }
 
-  return paragraphs;
+  return {
+    globalCursor: nextCursor,
+    paragraphIndex: nextParagraphIndex,
+  };
 }
 
 function walkParagraphForBoundaries(