@beyondwork/docx-react-component 1.0.58 → 1.0.59

package/src/core/commands/table-structure-commands.ts

@@ -509,17 +509,38 @@ function deleteRow(
   }
 
   const deleteIndex = selection.anchorCell.rowIndex;
-  const grid = buildLogicalGrid(table);
+  const nextTable = removeTableRowPure(table, deleteIndex);
+  const focusRowIndex = Math.max(0, Math.min(deleteIndex, nextTable.rows.length - 1));
+
+  return commitTableChange(
+    document,
+    root,
+    selection.tableBlockIndex,
+    nextTable,
+    fallbackSelection,
+    focusRowIndex,
+    selection.anchorCell.columnIndex,
+  );
+}
 
-  // For every logical column, check if this row is the origin of a vMerge
-  // chain that extends beyond this row. If so, we must promote the first
-  // following continue cell to "restart" and copy over the origin's
-  // content/properties so the chain survives the deletion.
-  //
-  // For columns where this row is a mid-chain continue, the chain's owner
-  // origin stays in place — we just need to drop 1 from its effective
-  // rowSpan (which happens automatically when the row is removed from
-  // the canonical tree).
+/**
+ * Pure model-level row removal for a table node.
+ *
+ * Removes `table.rows[rowIndex]` while preserving the vMerge chain invariant:
+ * if the deleted row is the origin of a chain that extends beyond it, the
+ * first following continue cell is promoted to "restart" and inherits the
+ * origin's content/properties. For mid-chain continues, nothing needs to be
+ * rewritten because the chain's origin stays in place.
+ *
+ * Used by `deleteRow` above (UI command path) and by Lane 7b's row-insertion
+ * reject path in `src/review/store/revision-actions.ts`.
+ */
+export function removeTableRowPure(table: TableNode, rowIndex: number): TableNode {
+  if (rowIndex < 0 || rowIndex >= table.rows.length) {
+    return table;
+  }
+
+  const grid = buildLogicalGrid(table);
   const promotions: Array<{
     originColumnIndex: number;
     originColumnSpan: number;
@@ -528,43 +549,140 @@ function deleteRow(
   }> = [];
 
   for (let column = 0; column < grid.columnCount; ) {
-    const origin = originAt(grid, deleteIndex, column);
+    const origin = originAt(grid, rowIndex, column);
     if (!origin) {
       column += 1;
       continue;
     }
-    if (origin.rowIndex === deleteIndex && origin.rowSpan > 1) {
+    if (origin.rowIndex === rowIndex && origin.rowSpan > 1) {
       promotions.push({
         originColumnIndex: origin.columnIndex,
         originColumnSpan: origin.columnSpan,
-        promotedRowIndex: deleteIndex + 1,
+        promotedRowIndex: rowIndex + 1,
         originCell: origin.cell,
       });
     }
     column = origin.columnIndex + origin.columnSpan;
   }
 
-  // Apply promotions to the row immediately after the deleted one.
-  const nextRows = table.rows.map((row, rowIndex) => {
-    if (rowIndex !== deleteIndex + 1 || promotions.length === 0) return row;
-    return applyVMergePromotions(row, promotions);
-  }).filter((_, rowIndex) => rowIndex !== deleteIndex);
+  const nextRows = table.rows
+    .map((row, index) => {
+      if (index !== rowIndex + 1 || promotions.length === 0) return row;
+      return applyVMergePromotions(row, promotions);
+    })
+    .filter((_, index) => index !== rowIndex);
 
-  const focusRowIndex = Math.max(0, Math.min(deleteIndex, nextRows.length - 1));
-  const nextTable: TableNode = {
-    ...table,
-    rows: nextRows,
+  return { ...table, rows: nextRows };
+}
+
+/**
+ * Pure model-level cell removal for a row within a table.
+ *
+ * Removes `table.rows[rowIndex].cells[cellIndex]` while preserving:
+ *
+ * 1. **Row logical-column footprint.** The row occupies the same total
+ *    logical column count as before — if the removed cell had
+ *    `gridSpan = N`, an adjacent cell absorbs +N via its own `gridSpan`.
+ *    Preference: the immediately preceding cell absorbs the delta; if
+ *    the removed cell is the first in the row, the immediately following
+ *    cell absorbs instead. This keeps the table-level `gridColumns` array
+ *    unchanged (important — shrinking `gridColumns` would cascade-change
+ *    every sibling row).
+ *
+ * 2. **vMerge chain integrity.** If the removed cell is the origin of a
+ *    vMerge chain that extends past this row, the chain's first
+ *    following continue cell is promoted to `"restart"` (inheriting the
+ *    origin's content/properties). Mid-chain continues and tail
+ *    continues are unaffected — when the origin's content moves, the
+ *    chain shape stays valid by construction.
+ *
+ * 3. **Single-cell row invariant.** If the row contains only one cell,
+ *    removing it is equivalent to removing the row entirely — a
+ *    different operation with different grid semantics. This helper
+ *    declines the operation and returns `table` unchanged; callers must
+ *    use `removeTableRowPure` instead.
+ *
+ * Used by Lane 7b's cellIns reject path in
+ * `src/review/store/revision-actions.ts`. The Lane 7b parser stamps
+ * `metadata.tableRevisionCoordinates.cellIndex` at parse time so the
+ * reject path never needs a runtime position → cell reverse lookup.
+ */
+export function removeCellFromRow(
+  table: TableNode,
+  rowIndex: number,
+  cellIndex: number,
+): TableNode {
+  if (rowIndex < 0 || rowIndex >= table.rows.length) {
+    return table;
+  }
+  const row = table.rows[rowIndex];
+  if (!row || cellIndex < 0 || cellIndex >= row.cells.length) {
+    return table;
+  }
+  if (row.cells.length <= 1) {
+    // Last cell in row — out of scope. Caller should use removeTableRowPure.
+    return table;
+  }
+
+  const removed = row.cells[cellIndex]!;
+  const removedSpan = Math.max(1, removed.gridSpan ?? 1);
+
+  // Compute vMerge promotions for the removed cell's logical column range,
+  // mirroring the row-removal logic but scoped to one row.
+  const grid = buildLogicalGrid(table);
+  const promotions: Array<{
+    originColumnIndex: number;
+    originColumnSpan: number;
+    promotedRowIndex: number;
+    originCell: TableCellNode;
+  }> = [];
+
+  // Walk the logical columns the removed cell covers. If it's a vMerge origin
+  // spanning rows, promote the next-row continue.
+  let cursor = row.gridBefore ?? 0;
+  for (let i = 0; i < cellIndex; i += 1) {
+    cursor += Math.max(1, row.cells[i]!.gridSpan ?? 1);
+  }
+  const columnStart = cursor;
+  const columnEnd = columnStart + removedSpan;
+  for (let column = columnStart; column < columnEnd; ) {
+    const origin = originAt(grid, rowIndex, column);
+    if (!origin) {
+      column += 1;
+      continue;
+    }
+    if (origin.rowIndex === rowIndex && origin.rowSpan > 1) {
+      promotions.push({
+        originColumnIndex: origin.columnIndex,
+        originColumnSpan: origin.columnSpan,
+        promotedRowIndex: rowIndex + 1,
+        originCell: origin.cell,
+      });
+    }
+    column = origin.columnIndex + origin.columnSpan;
+  }
+
+  const nextRowCells = row.cells.filter((_, index) => index !== cellIndex);
+  // Rebalance gridSpan: preceding cell absorbs the delta if it exists,
+  // otherwise the new first cell (which was the following cell pre-removal).
+  const absorberIndex = cellIndex > 0 ? cellIndex - 1 : 0;
+  const absorber = nextRowCells[absorberIndex]!;
+  const absorberSpan = Math.max(1, absorber.gridSpan ?? 1);
+  nextRowCells[absorberIndex] = {
+    ...absorber,
+    gridSpan: absorberSpan + removedSpan,
   };
 
-  return commitTableChange(
-    document,
-    root,
-    selection.tableBlockIndex,
-    nextTable,
-    fallbackSelection,
-    focusRowIndex,
-    selection.anchorCell.columnIndex,
-  );
+  const nextRow: TableRowNode = { ...row, cells: nextRowCells };
+  const nextRows = table.rows.map((candidate, index) => {
+    if (index === rowIndex) return nextRow;
+    if (index === rowIndex + 1 && promotions.length > 0) {
+      return applyVMergePromotions(candidate, promotions);
+    }
+    return candidate;
+  });
+
+  return { ...table, rows: nextRows };
 }
 
 function applyVMergePromotions(

package/src/core/selection/mapping.ts

@@ -236,6 +236,26 @@ export function areAnchorsEqual(
   return false;
 }
 
+/**
+ * Returns `true` when no step in the mapping can change this anchor's
+ * positions. Safe to use as a pre-check before calling `mapAnchor` to avoid
+ * allocating a new anchor object in hot per-revision / per-comment remap loops.
+ *
+ * Conservative: if any step starts at or before the anchor's end position the
+ * function returns `false` and the caller must run the full `mapAnchor` path.
+ * Detached anchors always return `true` — `mapAnchor` already short-circuits
+ * them by reference.
+ */
+export function anchorUnaffectedByMapping(
+  anchor: EditorAnchorProjection,
+  mapping: TransactionMapping,
+): boolean {
+  if (anchor.kind === "detached") return true;
+  if (mapping.steps.length === 0) return true;
+  const end = anchor.kind === "range" ? anchor.range.to : anchor.at;
+  return mapping.steps.every((s) => s.from > end);
+}
+
 export function storyTargetsEqual(
   left: EditorStoryTarget | undefined,
   right: EditorStoryTarget | undefined,

package/src/core/state/editor-state.ts

@@ -33,7 +33,8 @@ export type EditorWarningCode =
   | "revision_anchor_detached"
   | "large_document_degraded"
   | "font_substitution"
-  | "image_missing";
+  | "image_missing"
+  | "review_target_not_found";
 
 export interface EditorWarning {
   warningId: string;

package/src/index.ts

@@ -288,6 +288,22 @@ export type {
   EditorStatePolicyMigration,
   EditorStatePartLoadFailure,
   EditorStatePartPersistFailure,
+  // Lane 8 Track H (v2.x) — agent-helper widening types. Runtime wiring
+  // lands in Phase 2; re-exported from the root as stable type surface so
+  // workblocks and wrappers can start consuming the shapes in Phase 1.
+  TextProjection,
+  TextProjectionLine,
+  TextProjectionStoryEntry,
+  TextProjectionOptions,
+  ChangeAnchor,
+  ChangeFilter,
+  BatchEditOperation,
+  BatchEditOptions,
+  BatchEditResult,
+  BatchEditEntryResult,
+  WorkflowOverlayPatch,
+  AiExplanationScopeInput,
+  AiExplanationScopeResult,
 } from "./api/public-types.ts";
 
 // L7 Phase 2.5 — prerender cache public API. Platforms / ingest workers
@@ -301,3 +317,15 @@ export type {
   PrerenderCounters,
 } from "./runtime/prerender/prerender-document.ts";
 export type { CacheEnvelope } from "./runtime/prerender/cache-envelope.ts";
+
+// design-close-chrome Phase 4 / R9 — selection-tool registry extensibility.
+// Hosts can inject entries into the floating selection-tool precedence
+// chain by passing `customSelectionTools` on `WordReviewEditorProps`.
+// Render-side widening (host entries carrying a custom render function)
+// is deferred to Lane 8 API ergonomics.
+export {
+  resolveSelectionToolRegistry,
+  SELECTION_TOOL_REGISTRY,
+} from "./ui/headless/chrome-registry.ts";
+export type { SelectionToolRegistryEntry } from "./ui/headless/chrome-registry.ts";
+export type { SelectionToolKind } from "./ui/headless/selection-tool-types.ts";

package/src/io/docx-session.ts

@@ -32,6 +32,15 @@ import {
   createDefaultCanonicalDocument,
   createSelectionSnapshot,
 } from "../core/state/editor-state.ts";
+// NOTE: docx-session.ts is intentionally an integration orchestrator, not a
+// pure io module. It coordinates io (OOXML parse/export) with runtime
+// (surface projection, cache envelopes, read-only diagnostics) and
+// presentation. The runtime imports below (surface-projection,
+// prerender/cache-envelope, read-only-diagnostics-runtime) are load-bearing
+// and violate the nominal io→runtime boundary on purpose. The proper
+// long-term fix is to relocate this file to src/session/ (see
+// docs/plans/architecture-lane.md §F2). Do NOT add more runtime imports
+// here without first reading that deferral rationale.
 import { createEditorSurfaceSnapshot } from "../runtime/surface-projection.ts";
 import { MAIN_STORY_TARGET } from "../core/selection/mapping.ts";
 import {
@@ -73,8 +82,6 @@ import {
   WORKFLOW_PAYLOAD_CUSTOM_PROPS_PART_PATH,
   WORKFLOW_PAYLOAD_CUSTOM_PROPS_RELATIONSHIP_TYPE,
   WORKFLOW_PAYLOAD_ITEM_PROPS_CONTENT_TYPE,
-  WORKFLOW_PAYLOAD_ITEM_PROPS_PART_PATH,
-  WORKFLOW_PAYLOAD_PART_PATH,
   WORKFLOW_PAYLOAD_RELATIONSHIP_TYPE,
 } from "./ooxml/workflow-payload.ts";
 import {
@@ -457,6 +464,10 @@ export function loadDocxEditorSession(
     const parsedNumbering = numberingPartPath
       ? parseNumberingXml(
           decodeUtf8(sourcePackage.parts.get(numberingPartPath)?.bytes ?? new Uint8Array()),
+          {
+            relationships: sourcePackage.parts.get(numberingPartPath)?.relationships,
+            partPath: numberingPartPath,
+          },
         )
       : createEmptyNumberingCatalog();
     const mediaParts = collectInlineMediaParts(sourcePackage);
@@ -1329,6 +1340,10 @@ export async function loadDocxEditorSessionAsync(
     const parsedNumbering = numberingPartPath
       ? parseNumberingXml(
           decodeUtf8(sourcePackage.parts.get(numberingPartPath)?.bytes ?? new Uint8Array()),
+          {
+            relationships: sourcePackage.parts.get(numberingPartPath)?.relationships,
+            partPath: numberingPartPath,
+          },
         )
       : createEmptyNumberingCatalog();
     const mediaParts = collectInlineMediaParts(sourcePackage);
@@ -2017,6 +2032,7 @@ function exportDocxEditorSession(
       documentAttributes: state.sourceDocumentAttributes,
       media: currentDocument.media as MediaCatalog,
       finalSectionProperties: currentDocument.subParts?.finalSectionProperties,
+      namespaceFlavor: options?.exportStrictOoxml ? "strict" : "transitional",
     },
   );
   const revisionDocument = serializeRuntimeRevisionsIntoDocumentXml(
@@ -2163,6 +2179,9 @@ function exportDocxEditorSession(
     state.sourcePackage,
     sessionState.documentId,
   );
+  const internalEditorState = (
+    options as { _editorState?: import("./ooxml/workflow-payload.ts").EditorStatePayload } | undefined
+  )?._editorState;
 
   const exportSession = createExportSession(state.sourcePackage, [
     state.sourceDocumentPartPath,
@@ -2418,7 +2437,6 @@ function exportDocxEditorSession(
 
   ensureHostMetadataParts(exportSession, state.sourcePackage, currentDocument);
   // Schema 1.2: pass through editorState payload collected by the runtime channel.
-  const internalEditorState = (options as { _editorState?: import("./ooxml/workflow-payload.ts").EditorStatePayload } | undefined)?._editorState;
   ensureWorkflowPayloadParts(
     exportSession,
     sessionState,
@@ -2728,6 +2746,7 @@ function ensureImportedNumberingCatalogSupportsContent(
       ...catalog.instances,
       ...syntheticNullCatalog.instances,
     },
+    ...(catalog.numPicBullets !== undefined ? { numPicBullets: catalog.numPicBullets } : {}),
   };
 }
 

package/src/io/export/export-session.ts

@@ -42,7 +42,10 @@ export class ExportSession {
         return normalized;
       }),
     );
-    this.workingParts = cloneParts(sourcePackage.parts);
+    // Clone bytes only for owned paths; non-owned paths get their bytes from
+    // reattachPreservedParts (which always clones from sourcePackage) so the
+    // up-front copy here is wasted work for the majority of parts.
+    this.workingParts = clonePartsForExport(sourcePackage.parts, this.ownedPaths);
     this.packageRelationships = sourcePackage.manifest.packageRelationships.map(cloneRelationship);
   }
 
@@ -137,15 +140,16 @@ export function createExportSession(
   return new ExportSession(sourcePackage, ownedOutputPaths);
 }
 
-function cloneParts(parts: Map<string, OpcPackagePart>): Map<string, OpcPackagePart> {
+function clonePartsForExport(
+  parts: Map<string, OpcPackagePart>,
+  ownedPaths: ReadonlySet<string>,
+): Map<string, OpcPackagePart> {
   return new Map(
     [...parts.entries()].map(([path, part]) => [
       path,
-      {
-        ...part,
-        relationships: part.relationships.map(cloneRelationship),
-        bytes: new Uint8Array(part.bytes),
-      },
+      ownedPaths.has(path)
+        ? { ...part, relationships: part.relationships.map(cloneRelationship), bytes: new Uint8Array(part.bytes) }
+        : { ...part, relationships: part.relationships.map(cloneRelationship) },
     ]),
   );
 }

package/src/io/export/ooxml-namespaces.ts

@@ -0,0 +1,47 @@
+/**
+ * Lane 7c Slice 7c.4 — O6 Strict-flavor namespace URI constants.
+ *
+ * OOXML has two URI flavors (ECMA-376 Annex L):
+ *  - Transitional: classic "http://schemas.openxmlformats.org/…" URIs
+ *  - Strict: "http://purl.oclc.org/ooxml/…" URIs (ISO 29500 Strict)
+ *
+ * `nsUris(flavor)` returns the correct set for the requested flavor.
+ * All serializers default to "transitional" to preserve backward compatibility.
+ */
+
+export const TRANSITIONAL_NS = {
+  w:   "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+  r:   "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  a:   "http://schemas.openxmlformats.org/drawingml/2006/main",
+  pic: "http://schemas.openxmlformats.org/drawingml/2006/picture",
+  wp:  "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+  mc:  "http://schemas.openxmlformats.org/markup-compatibility/2006",
+} as const;
+
+export const STRICT_NS = {
+  w:   "http://purl.oclc.org/ooxml/wordprocessingml/main",
+  r:   "http://purl.oclc.org/ooxml/officeDocument/relationships",
+  a:   "http://purl.oclc.org/ooxml/drawingml/main",
+  pic: "http://purl.oclc.org/ooxml/drawingml/picture",
+  wp:  "http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing",
+  mc:  "http://purl.oclc.org/ooxml/markup-compatibility",
+} as const;
+
+export type NamespaceFlavor = "transitional" | "strict";
+
+export type NsUriSet = { readonly w: string; readonly r: string; readonly a: string; readonly pic: string; readonly wp: string; readonly mc: string };
+
+export function nsUris(flavor: NamespaceFlavor): NsUriSet {
+  return flavor === "strict" ? STRICT_NS : TRANSITIONAL_NS;
+}
+
+/** Extension namespaces present in Transitional but omitted in Strict (ECMA-376 Annex B). */
+export const TRANSITIONAL_EXTENSION_NAMESPACES = {
+  w14:  "http://schemas.microsoft.com/office/word/2010/wordml",
+  w15:  "http://schemas.microsoft.com/office/word/2012/wordml",
+  w16cid: "http://schemas.microsoft.com/office/word/2016/wordml/cid",
+  w16se: "http://schemas.microsoft.com/office/word/2015/wordml/symex",
+  wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+  wps:  "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
+  wpg:  "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+} as const;

package/src/io/export/reattach-preserved-parts.ts

@@ -12,22 +12,10 @@ export function reattachPreservedParts(
       continue;
     }
 
-    if (!workingParts.has(path)) {
-      workingParts.set(path, clonePart(sourcePart));
-      continue;
-    }
-
-    const currentPart = workingParts.get(path);
-    if (!currentPart) {
-      continue;
-    }
-
-    currentPart.contentType = sourcePart.contentType;
-    currentPart.relationships = sourcePart.relationships.map(cloneRelationship);
-    currentPart.relationshipsPartPath = sourcePart.relationshipsPartPath;
-    currentPart.compression = sourcePart.compression;
-    currentPart.bytes = new Uint8Array(sourcePart.bytes);
-    currentPart.crc32 = sourcePart.crc32;
+    // Always replace with a fresh clone so round-trip bytes are always the
+    // originals, regardless of whether the working entry has a bytes copy or
+    // a reference from the copy-on-write constructor path.
+    workingParts.set(path, clonePart(sourcePart));
   }
 
   const knownPackageRelationshipIds = new Set(packageRelationships.map((relationship) => relationship.id));

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

@@ -2,6 +2,8 @@ import type { CommentEntry, CommentThread } from "../../review/store/comment-sto
 import type { RevisionParagraphBoundary } from "../ooxml/revision-boundaries.ts";
 import type { ImportedCommentDefinition } from "../ooxml/parse-comments.ts";
 import { escapeXmlAttribute } from "./escape-xml-attribute.ts";
+import { parseXmlWithOffsets as parseXml } from "../ooxml/xml-parser.ts";
+import { localName } from "../ooxml/xml-attr-helpers.ts";
 
 interface XmlElementNode {
   type: "element";
@@ -600,7 +602,7 @@ function parseOoxmlNumericId(value: string): number | undefined {
 }
 
 export function mapParagraphBoundaries(documentXml: string): ParagraphBoundaryMap[] {
-  const root = parseXml(documentXml);
+  const root = parseXml(documentXml) as XmlElementNode;
   const documentElement = findChildElement(root, "document");
   const bodyElement = findChildElement(documentElement, "body");
   const paragraphs: ParagraphBoundaryMap[] = [];
@@ -878,103 +880,6 @@ function openingTagLength(xml: string, start: number): number {
   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 =>
@@ -988,36 +893,3 @@ function findChildElement(node: XmlElementNode, name: string): XmlElementNode {
   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};`;
-      }
-    },
-  );
-}