@beyondwork/docx-react-component 1.0.28 → 1.0.29

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

@@ -1,947 +0,0 @@
-import type { CommentEntry, CommentThread } from "../../review/store/comment-store.ts";
-import type { RevisionParagraphBoundary } from "../ooxml/revision-boundaries.ts";
-import type { ImportedCommentDefinition } from "../ooxml/parse-comments.ts";
-
-interface XmlElementNode {
-  type: "element";
-  name: string;
-  attributes: Record<string, string>;
-  children: XmlNode[];
-  start: number;
-  end: number;
-}
-
-interface XmlTextNode {
-  type: "text";
-  text: string;
-  start: number;
-  end: number;
-}
-
-type XmlNode = XmlElementNode | XmlTextNode;
-
-interface ParagraphBoundaryMap {
-  paragraphIndex: number;
-  start: number;
-  end: number;
-  boundaries: Map<number, number>;
-}
-
-interface SerializableCommentEntry {
-  thread: CommentThread;
-  entry: CommentEntry;
-  exportCommentId: string;
-  paraId: string;
-  durableId?: string;
-  isRoot: boolean;
-}
-
-export interface SerializedCommentsResult {
-  commentsXml: string;
-  serializedCommentIds: string[];
-  commentsExtendedXml?: string;
-  commentsIdsXml?: string;
-  peopleXml?: string;
-}
-
-export interface SerializeMergedCommentsXmlOptions {
-  preservedDefinitions?: readonly ImportedCommentDefinition[];
-  sourceRootTag?: string;
-  sourceExtendedRootTag?: string;
-  sourceIdsRootTag?: string;
-  sourcePeopleRootTag?: string;
-  peopleAuthors?: readonly string[];
-  exportCommentIds?: ReadonlyMap<string, string>;
-}
-
-export interface SerializeCommentAnchorsOptions {
-  exportCommentIds?: ReadonlyMap<string, string>;
-}
-
-export interface SerializedCommentDocumentResult {
-  documentXml: string;
-  serializedCommentIds: string[];
-  skippedCommentIds: string[];
-}
-
-const DEFAULT_COMMENTS_ROOT_TAG =
-  `<w:comments xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="w14">`;
-const DEFAULT_COMMENTS_EXTENDED_ROOT_TAG =
-  `<w15:commentsEx xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml">`;
-const DEFAULT_COMMENTS_IDS_ROOT_TAG =
-  `<w16cid:commentsIds xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid">`;
-const DEFAULT_PEOPLE_ROOT_TAG =
-  `<w15:people xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml">`;
-
-export function serializeCommentsXml(
-  threads: readonly CommentThread[],
-  options: {
-    exportCommentIds?: ReadonlyMap<string, string>;
-  } = {},
-): SerializedCommentsResult {
-  return serializeMergedCommentsXml(threads, {
-    exportCommentIds: options.exportCommentIds,
-  });
-}
-
-export function serializeMergedCommentsXml(
-  threads: readonly CommentThread[],
-  options: SerializeMergedCommentsXmlOptions = {},
-): SerializedCommentsResult {
-  const serializableThreads = threads.filter((thread) => thread.entries.length > 0);
-  const preservedDefinitions = (options.preservedDefinitions ?? [])
-    .slice()
-    .sort((left, right) => left.order - right.order);
-  const runtimeThreadById = new Map(
-    serializableThreads.map((thread) => [thread.commentId, thread]),
-  );
-  const exportCommentIds =
-    options.exportCommentIds ??
-    createCommentExportIdMap(serializableThreads, preservedDefinitions);
-  const serializableEntries = createSerializableEntries(
-    serializableThreads,
-    preservedDefinitions,
-    exportCommentIds,
-  );
-  const serializedEntryByOoxmlId = new Map(
-    serializableEntries.map((entry) => [entry.exportCommentId, entry]),
-  );
-  const emittedThreadIds = new Set<string>();
-  const mergedComments: string[] = [];
-
-  for (const definition of preservedDefinitions) {
-    const ownedThread = runtimeThreadById.get(definition.commentId);
-    if (ownedThread) {
-      if (emittedThreadIds.has(ownedThread.commentId)) {
-        continue;
-      }
-      mergedComments.push(
-        ...serializeThreadEntries(
-          serializableEntries.filter((entry) => entry.thread.commentId === ownedThread.commentId),
-        ),
-      );
-      emittedThreadIds.add(ownedThread.commentId);
-      continue;
-    }
-
-    if (serializedEntryByOoxmlId.has(definition.commentId)) {
-      continue;
-    }
-
-    mergedComments.push(definition.rawXml);
-  }
-
-  for (const thread of serializableThreads) {
-    if (emittedThreadIds.has(thread.commentId)) {
-      continue;
-    }
-
-    mergedComments.push(
-      ...serializeThreadEntries(
-        serializableEntries.filter((entry) => entry.thread.commentId === thread.commentId),
-      ),
-    );
-    emittedThreadIds.add(thread.commentId);
-  }
-
-  const mergedExtendedEntries = [
-    ...serializePreservedCommentExtensions(
-      preservedDefinitions.filter((definition) => !serializedEntryByOoxmlId.has(definition.commentId)),
-    ),
-    ...serializableEntries
-      .map((entry) => serializeCommentExtension(entry))
-      .filter((xml): xml is string => Boolean(xml)),
-  ];
-  const mergedDurableIds = [
-    ...serializePreservedCommentIds(
-      preservedDefinitions.filter((definition) => !serializedEntryByOoxmlId.has(definition.commentId)),
-    ),
-    ...serializableEntries
-      .map((entry) => serializeCommentDurableId(entry))
-      .filter((xml): xml is string => Boolean(xml)),
-  ];
-  const peopleAuthors = new Set([
-    ...(options.peopleAuthors ?? []),
-    ...preservedDefinitions
-      .map((definition) => definition.authorId)
-      .filter((authorId): authorId is string => typeof authorId === "string" && authorId.length > 0),
-    ...serializableEntries
-      .map((entry) => entry.entry.authorId)
-      .filter((authorId): authorId is string => typeof authorId === "string" && authorId.length > 0),
-  ]);
-
-  return {
-    commentsXml: [
-      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
-      normalizeCommentsRootTag(options.sourceRootTag ?? DEFAULT_COMMENTS_ROOT_TAG),
-      ...mergedComments,
-      `</w:comments>`,
-    ].join("\n"),
-    serializedCommentIds: serializableThreads.map((thread) => thread.commentId),
-    commentsExtendedXml:
-      mergedExtendedEntries.length > 0
-        ? [
-            `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
-            options.sourceExtendedRootTag ?? DEFAULT_COMMENTS_EXTENDED_ROOT_TAG,
-            ...mergedExtendedEntries,
-            `</w15:commentsEx>`,
-          ].join("\n")
-        : undefined,
-    commentsIdsXml:
-      mergedDurableIds.length > 0
-        ? [
-            `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
-            options.sourceIdsRootTag ?? DEFAULT_COMMENTS_IDS_ROOT_TAG,
-            ...mergedDurableIds,
-            `</w16cid:commentsIds>`,
-          ].join("\n")
-        : undefined,
-    peopleXml:
-      peopleAuthors.size > 0
-        ? [
-            `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
-            options.sourcePeopleRootTag ?? DEFAULT_PEOPLE_ROOT_TAG,
-            ...[...peopleAuthors]
-              .sort((left, right) => left.localeCompare(right))
-              .map(
-                (authorId) =>
-                  `<w15:person w15:author="${escapeAttribute(authorId)}" />`,
-              ),
-            `</w15:people>`,
-          ].join("\n")
-        : undefined,
-  };
-}
-
-function normalizeCommentsRootTag(rootTag: string): string {
-  let normalized = rootTag;
-  if (!/\bxmlns:w14=/u.test(normalized)) {
-    normalized = normalized.replace(
-      />$/u,
-      ` xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml">`,
-    );
-  }
-  if (!/\bxmlns:mc=/u.test(normalized)) {
-    normalized = normalized.replace(
-      />$/u,
-      ` xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006">`,
-    );
-  }
-  if (!/\bmc:Ignorable=/u.test(normalized)) {
-    normalized = normalized.replace(/>$/u, ` mc:Ignorable="w14">`);
-  } else if (!/\bmc:Ignorable="[^"]*\bw14\b/u.test(normalized)) {
-    normalized = normalized.replace(
-      /\bmc:Ignorable="([^"]*)"/u,
-      (_match, value: string) =>
-        `mc:Ignorable="${`${value} w14`.trim().replace(/\s+/gu, " ")}"`,
-    );
-  }
-  return normalized;
-}
-
-export function serializeCommentAnchorsIntoDocumentXml(
-  documentXml: string,
-  threads: readonly CommentThread[],
-  paragraphs: readonly Pick<
-    RevisionParagraphBoundary,
-    "paragraphIndex" | "start" | "end" | "boundaries"
-  >[] = mapParagraphBoundaries(documentXml),
-  options: SerializeCommentAnchorsOptions = {},
-): SerializedCommentDocumentResult {
-  const insertions = new Map<number, string[]>();
-  const serializedCommentIds: string[] = [];
-  const skippedCommentIds: string[] = [];
-  const exportCommentIds =
-    options.exportCommentIds ?? createCommentExportIdMap(threads);
-
-  for (const thread of threads) {
-    const { anchor } = thread;
-    if (anchor.kind !== "range") {
-      skippedCommentIds.push(thread.commentId);
-      continue;
-    }
-
-    const paragraph = paragraphs.find(
-      (candidate) =>
-        anchor.range.from >= candidate.start &&
-        anchor.range.to <= candidate.end,
-    );
-
-    if (!paragraph) {
-      skippedCommentIds.push(thread.commentId);
-      continue;
-    }
-
-    const startIndex = paragraph.boundaries.get(anchor.range.from);
-    const endIndex = paragraph.boundaries.get(anchor.range.to);
-
-    if (startIndex === undefined || endIndex === undefined) {
-      skippedCommentIds.push(thread.commentId);
-      continue;
-    }
-
-    const exportCommentId = exportCommentIds.get(thread.commentId) ?? thread.commentId;
-    pushInsertion(
-      insertions,
-      startIndex,
-      `<w:commentRangeStart w:id="${escapeAttribute(exportCommentId)}"/>`,
-    );
-    pushInsertion(
-      insertions,
-      endIndex,
-      `<w:commentRangeEnd w:id="${escapeAttribute(exportCommentId)}"/>`,
-    );
-    pushInsertion(
-      insertions,
-      endIndex,
-      `<w:r><w:commentReference w:id="${escapeAttribute(exportCommentId)}"/></w:r>`,
-    );
-    serializedCommentIds.push(thread.commentId);
-  }
-
-  const sortedInsertions = [...insertions.entries()].sort((left, right) => left[0] - right[0]);
-  let cursor = 0;
-  let output = "";
-
-  for (const [index, snippets] of sortedInsertions) {
-    output += documentXml.slice(cursor, index);
-    output += snippets.join("");
-    cursor = index;
-  }
-
-  output += documentXml.slice(cursor);
-
-  return {
-    documentXml: output,
-    serializedCommentIds,
-    skippedCommentIds,
-  };
-}
-
-export function createCommentExportIdMap(
-  threads: readonly CommentThread[],
-  preservedDefinitions: readonly ImportedCommentDefinition[] = [],
-): ReadonlyMap<string, string> {
-  const exportIds = new Map<string, string>();
-  const reservedNumericIds = new Set<number>();
-
-  for (const definition of preservedDefinitions) {
-    const numericId = parseOoxmlNumericId(definition.commentId);
-    if (numericId !== undefined) {
-      reservedNumericIds.add(numericId);
-    }
-  }
-
-  for (const thread of threads) {
-    const rootEntry = getRootEntry(thread);
-    const preferredValue =
-      thread.metadata?.rootOoxmlCommentId ??
-      rootEntry?.metadata?.ooxmlCommentId ??
-      thread.commentId;
-    const numericId = parseOoxmlNumericId(preferredValue);
-    if (numericId !== undefined && !reservedNumericIds.has(numericId)) {
-      exportIds.set(thread.commentId, String(numericId));
-      reservedNumericIds.add(numericId);
-    }
-  }
-
-  let nextGeneratedId =
-    reservedNumericIds.size > 0 ? Math.max(...reservedNumericIds) + 1 : 1;
-
-  for (const thread of threads) {
-    if (exportIds.has(thread.commentId)) {
-      continue;
-    }
-
-    while (reservedNumericIds.has(nextGeneratedId)) {
-      nextGeneratedId += 1;
-    }
-
-    exportIds.set(thread.commentId, String(nextGeneratedId));
-    reservedNumericIds.add(nextGeneratedId);
-    nextGeneratedId += 1;
-  }
-
-  return exportIds;
-}
-
-function createSerializableEntries(
-  threads: readonly CommentThread[],
-  preservedDefinitions: readonly ImportedCommentDefinition[],
-  exportCommentIds: ReadonlyMap<string, string>,
-): SerializableCommentEntry[] {
-  const entries: SerializableCommentEntry[] = [];
-  const reservedNumericIds = new Set<number>();
-
-  for (const definition of preservedDefinitions) {
-    const numericId = parseOoxmlNumericId(definition.commentId);
-    if (numericId !== undefined) {
-      reservedNumericIds.add(numericId);
-    }
-  }
-
-  for (const thread of threads) {
-    const rootEntry = getRootEntry(thread);
-    if (!rootEntry) {
-      continue;
-    }
-
-    const rootExportCommentId = exportCommentIds.get(thread.commentId) ?? thread.commentId;
-    const rootNumericId = parseOoxmlNumericId(rootExportCommentId);
-    if (rootNumericId !== undefined) {
-      reservedNumericIds.add(rootNumericId);
-    }
-
-    const rootParaId =
-      rootEntry.metadata?.paraId ??
-      thread.metadata?.rootParaId ??
-      generateParaId(thread.commentId, 0);
-    const rootDurableId =
-      rootEntry.metadata?.durableId ??
-      createDurableId(rootEntry, rootExportCommentId, 0);
-
-    entries.push({
-      thread,
-      entry: rootEntry,
-      exportCommentId: rootExportCommentId,
-      paraId: rootParaId,
-      durableId: rootDurableId,
-      isRoot: true,
-    });
-
-    for (let index = 1; index < thread.entries.length; index += 1) {
-      const entry = thread.entries[index];
-      if (!entry) {
-        continue;
-      }
-
-      const preferredCommentId = entry.metadata?.ooxmlCommentId;
-      let exportCommentId: string | undefined;
-      const preferredNumericId = preferredCommentId
-        ? parseOoxmlNumericId(preferredCommentId)
-        : undefined;
-      if (
-        preferredNumericId !== undefined &&
-        !reservedNumericIds.has(preferredNumericId)
-      ) {
-        exportCommentId = String(preferredNumericId);
-        reservedNumericIds.add(preferredNumericId);
-      } else {
-        let nextGeneratedId =
-          reservedNumericIds.size > 0 ? Math.max(...reservedNumericIds) + 1 : 1;
-        while (reservedNumericIds.has(nextGeneratedId)) {
-          nextGeneratedId += 1;
-        }
-        exportCommentId = String(nextGeneratedId);
-        reservedNumericIds.add(nextGeneratedId);
-      }
-
-      entries.push({
-        thread,
-        entry,
-        exportCommentId,
-        paraId: entry.metadata?.paraId ?? generateParaId(thread.commentId, index),
-        durableId:
-          entry.metadata?.durableId ??
-          createDurableId(entry, exportCommentId, index),
-        isRoot: false,
-      });
-    }
-  }
-
-  return entries;
-}
-
-function serializeThreadEntries(entries: readonly SerializableCommentEntry[]): string[] {
-  return entries.map((entry) => serializeCommentEntry(entry));
-}
-
-function serializeCommentEntry(entry: SerializableCommentEntry): string {
-  const author = escapeAttribute(entry.entry.authorId);
-  const createdAt = escapeAttribute(entry.entry.createdAt);
-  const initials = entry.entry.metadata?.initials;
-  const paragraphXml = serializeCommentParagraphs(entry.entry.body, entry.paraId);
-
-  return `<w:comment w:id="${escapeAttribute(entry.exportCommentId)}"${initials ? ` w:initials="${escapeAttribute(initials)}"` : ""} w:author="${author}" w:date="${createdAt}">${paragraphXml}</w:comment>`;
-}
-
-function serializeCommentParagraphs(body: string, paraId: string): string {
-  const paragraphs = body.length > 0 ? body.split("\n") : [""];
-  const textId = deriveTextIdFromParaId(paraId);
-  return paragraphs
-    .map((paragraph, index) => {
-      const attributes =
-        index === 0
-          ? ` w14:paraId="${escapeAttribute(paraId)}" w14:textId="${escapeAttribute(textId)}"`
-          : "";
-      return `<w:p${attributes}><w:r>${serializeText(paragraph)}</w:r></w:p>`;
-    })
-    .join("");
-}
-
-function serializePreservedCommentExtensions(
-  definitions: readonly ImportedCommentDefinition[],
-): string[] {
-  return definitions
-    .map((definition) =>
-      definition.paraId
-        ? serializePreservedCommentExtension(definition)
-        : undefined,
-    )
-    .filter((xml): xml is string => Boolean(xml));
-}
-
-function serializePreservedCommentExtension(
-  definition: ImportedCommentDefinition,
-): string {
-  const doneValue = definition.isDone ? "true" : "false";
-  return `<w15:commentEx w15:paraId="${escapeAttribute(definition.paraId!)}"${definition.parentParaId ? ` w15:paraIdParent="${escapeAttribute(definition.parentParaId)}"` : ""} w15:done="${doneValue}" />`;
-}
-
-function serializeCommentExtension(
-  entry: SerializableCommentEntry,
-): string | undefined {
-  return `<w15:commentEx w15:paraId="${escapeAttribute(entry.paraId)}"${entry.isRoot ? "" : ` w15:paraIdParent="${escapeAttribute(findRootParaId(entry.thread, entry.paraId))}"`} w15:done="${entry.isRoot && entry.thread.status === "resolved" ? "true" : "false"}" />`;
-}
-
-function serializePreservedCommentIds(
-  definitions: readonly ImportedCommentDefinition[],
-): string[] {
-  return definitions
-    .map((definition) =>
-      definition.paraId && definition.durableId
-        ? `<w16cid:commentId w16cid:paraId="${escapeAttribute(definition.paraId)}" w16cid:durableId="${escapeAttribute(definition.durableId)}" />`
-        : undefined,
-    )
-    .filter((xml): xml is string => Boolean(xml));
-}
-
-function serializeCommentDurableId(
-  entry: SerializableCommentEntry,
-): string | undefined {
-  if (!entry.durableId) {
-    return undefined;
-  }
-
-  return `<w16cid:commentId w16cid:paraId="${escapeAttribute(entry.paraId)}" w16cid:durableId="${escapeAttribute(entry.durableId)}" />`;
-}
-
-function getRootEntry(thread: CommentThread): CommentEntry | undefined {
-  return thread.entries[0];
-}
-
-function findRootParaId(thread: CommentThread, fallback: string): string {
-  return (
-    thread.entries[0]?.metadata?.paraId ??
-    thread.metadata?.rootParaId ??
-    fallback
-  );
-}
-
-function generateParaId(seed: string, index: number): string {
-  const normalized = `${seed}:${index}`;
-  let hash = 0;
-
-  for (let cursor = 0; cursor < normalized.length; cursor += 1) {
-    hash = (hash * 31 + normalized.charCodeAt(cursor)) >>> 0;
-  }
-
-  return hash.toString(16).toUpperCase().padStart(8, "0").slice(-8);
-}
-
-function createDurableId(
-  entry: CommentEntry,
-  exportCommentId: string,
-  index: number,
-): string {
-  const seed = `${entry.entryId}:${exportCommentId}:${index}`;
-  let hash = 0n;
-
-  for (let cursor = 0; cursor < seed.length; cursor += 1) {
-    hash = (hash * 131n + BigInt(seed.charCodeAt(cursor))) & 0xffffffffffffffffn;
-  }
-
-  return hash.toString(16).toUpperCase().padStart(16, "0").slice(-16);
-}
-
-function deriveTextIdFromParaId(paraId: string): string {
-  return paraId.slice(-8).padStart(8, "0");
-}
-
-function parseOoxmlNumericId(value: string): number | undefined {
-  if (!/^-?\d+$/u.test(value)) {
-    return undefined;
-  }
-
-  const numericId = Number.parseInt(value, 10);
-  return Number.isFinite(numericId) ? numericId : undefined;
-}
-
-export function mapParagraphBoundaries(documentXml: string): ParagraphBoundaryMap[] {
-  const root = parseXml(documentXml);
-  const documentElement = findChildElement(root, "document");
-  const bodyElement = findChildElement(documentElement, "body");
-  const paragraphs: ParagraphBoundaryMap[] = [];
-  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 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 (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 (name === "sdt") {
-      const sdtContent = findChildElement(node, "sdtContent");
-      const result = walkBlockNodesForParagraphBoundaries(
-        sdtContent.children,
-        documentXml,
-        paragraphs,
-        nextCursor,
-        nextParagraphIndex,
-        false,
-      );
-      nextCursor = result.globalCursor;
-      nextParagraphIndex = result.paragraphIndex;
-      continue;
-    }
-
-    if (name === "customXml") {
-      nextCursor += 1;
-      continue;
-    }
-
-    nextCursor += 0;
-  }
-
-  return {
-    globalCursor: nextCursor,
-    paragraphIndex: nextParagraphIndex,
-  };
-}
-
-function walkParagraphForBoundaries(
-  paragraph: XmlElementNode,
-  sourceXml: string,
-  boundaries: Map<number, number>,
-  getCursor: () => number,
-  setCursor: (next: number) => void,
-): void {
-  for (const child of paragraph.children) {
-    walkInlineNodeForBoundaries(child, sourceXml, boundaries, getCursor, setCursor);
-  }
-}
-
-function walkInlineNodeForBoundaries(
-  node: XmlNode,
-  sourceXml: string,
-  boundaries: Map<number, number>,
-  getCursor: () => number,
-  setCursor: (next: number) => void,
-): void {
-  if (node.type !== "element") {
-    return;
-  }
-
-  switch (localName(node.name)) {
-    case "r": {
-      if (!boundaries.has(getCursor())) {
-        boundaries.set(getCursor(), node.start);
-      }
-
-      for (const child of node.children) {
-        walkInlineNodeForBoundaries(child, sourceXml, boundaries, getCursor, setCursor);
-      }
-
-      boundaries.set(getCursor(), node.end);
-      return;
-    }
-    case "t": {
-      const text = node.children
-        .filter((child): child is XmlTextNode => child.type === "text")
-        .map((child) => child.text)
-        .join("");
-      setCursor(getCursor() + Array.from(text).length);
-      return;
-    }
-    case "tab":
-    case "br": {
-      const startCursor = getCursor();
-      boundaries.set(startCursor, node.start);
-      const nextCursor = startCursor + 1;
-      boundaries.set(nextCursor, node.end);
-      setCursor(nextCursor);
-      return;
-    }
-    default:
-      for (const child of node.children) {
-        walkInlineNodeForBoundaries(child, sourceXml, boundaries, getCursor, setCursor);
-      }
-  }
-}
-
-function pushInsertion(
-  insertions: Map<number, string[]>,
-  index: number,
-  xml: string,
-): void {
-  const bucket = insertions.get(index);
-  if (bucket) {
-    bucket.push(xml);
-    return;
-  }
-
-  insertions.set(index, [xml]);
-}
-
-function serializeText(text: string): string {
-  const preserve = requiresPreservedSpace(text) ? ` xml:space="preserve"` : "";
-  return `<w:t${preserve}>${escapeXml(text)}</w:t>`;
-}
-
-function requiresPreservedSpace(text: string): boolean {
-  return /^\s/u.test(text) || /\s$/u.test(text) || /\s{2,}/u.test(text);
-}
-
-function escapeXml(value: string): string {
-  return value
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-function escapeAttribute(value: string): string {
-  return escapeXml(value).replace(/"/g, "&quot;");
-}
-
-function openingTagLength(xml: string, start: number): number {
-  const end = xml.indexOf(">", start);
-  if (end < 0) {
-    throw new Error("Malformed XML: missing tag close.");
-  }
-
-  return end - start + 1;
-}
-
-function parseXml(xml: string): XmlElementNode {
-  const root: XmlElementNode = {
-    type: "element",
-    name: "#document",
-    attributes: {},
-    children: [],
-    start: 0,
-    end: xml.length,
-  };
-  const stack: XmlElementNode[] = [root];
-  const tokenPattern =
-    /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!DOCTYPE[\s\S]*?>|<!\[CDATA\[[\s\S]*?\]\]>|<[^>]+>|[^<]+/gu;
-
-  for (const match of xml.matchAll(tokenPattern)) {
-    const token = match[0] ?? "";
-    const start = match.index ?? 0;
-    const end = start + token.length;
-
-    if (token.startsWith("<?") || token.startsWith("<!DOCTYPE") || token.startsWith("<!--")) {
-      continue;
-    }
-
-    if (token.startsWith("<![CDATA[")) {
-      const text = token.slice(9, -3);
-      stack[stack.length - 1]?.children.push({
-        type: "text",
-        text,
-        start,
-        end,
-      });
-      continue;
-    }
-
-    if (token.startsWith("</")) {
-      const node = stack.pop();
-      if (!node) {
-        throw new Error("Malformed XML: unexpected closing tag.");
-      }
-      node.end = end;
-      continue;
-    }
-
-    if (token.startsWith("<")) {
-      const selfClosing = /\/>$/.test(token);
-      const tagBody = token.slice(1, token.length - (selfClosing ? 2 : 1)).trim();
-      const { name, attributes } = parseTag(tagBody);
-      const node: XmlElementNode = {
-        type: "element",
-        name,
-        attributes,
-        children: [],
-        start,
-        end,
-      };
-      stack[stack.length - 1]?.children.push(node);
-      if (!selfClosing) {
-        stack.push(node);
-      }
-      continue;
-    }
-
-    const text = decodeXmlText(token);
-    if (text.length > 0) {
-      stack[stack.length - 1]?.children.push({
-        type: "text",
-        text,
-        start,
-        end,
-      });
-    }
-  }
-
-  if (stack.length !== 1) {
-    throw new Error("Malformed XML: unclosed tag.");
-  }
-
-  return root;
-}
-
-function parseTag(tagBody: string): { name: string; attributes: Record<string, string> } {
-  const whitespaceIndex = tagBody.search(/\s/u);
-  const name = whitespaceIndex === -1 ? tagBody : tagBody.slice(0, whitespaceIndex);
-  const rawAttributes = whitespaceIndex === -1 ? "" : tagBody.slice(whitespaceIndex + 1);
-  const attributes: Record<string, string> = {};
-  const pattern = /([A-Za-z_][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/gu;
-
-  for (const match of rawAttributes.matchAll(pattern)) {
-    const key = match[1];
-    const value = match[3] ?? match[4] ?? "";
-    if (key) {
-      attributes[key] = decodeXmlText(value);
-    }
-  }
-
-  return { name, attributes };
-}
-
-function findChildElement(node: XmlElementNode, name: string): XmlElementNode {
-  const match = node.children.find(
-    (child): child is XmlElementNode =>
-      child.type === "element" && localName(child.name) === name,
-  );
-
-  if (!match) {
-    throw new Error(`Expected XML element ${name}.`);
-  }
-
-  return match;
-}
-
-function localName(name: string): string {
-  const index = name.indexOf(":");
-  return index === -1 ? name : name.slice(index + 1);
-}
-
-function decodeXmlText(text: string): string {
-  return text.replace(
-    /&(?:#x([0-9A-Fa-f]+)|#([0-9]+)|([A-Za-z]+));/gu,
-    (_, hex, dec, named) => {
-      if (hex) {
-        return String.fromCodePoint(Number.parseInt(hex, 16));
-      }
-      if (dec) {
-        return String.fromCodePoint(Number.parseInt(dec, 10));
-      }
-
-      switch (named) {
-        case "amp":
-          return "&";
-        case "lt":
-          return "<";
-        case "gt":
-          return ">";
-        case "quot":
-          return "\"";
-        case "apos":
-          return "'";
-        default:
-          return `&${named};`;
-      }
-    },
-  );
-}