@beyondwork/docx-react-component 1.0.58 → 1.0.60

package/src/io/ooxml/parse-fill.ts

@@ -17,6 +17,9 @@
  * four fill families.
  */
 
+import { GRADIENT_STOP_UNITS } from "../../runtime/units.ts";
+import { localName } from "./xml-attr-helpers.ts";
+
 export interface XmlElementNode {
   type: "element";
   name: string;
@@ -57,6 +60,11 @@ export interface GradientFillResult {
   direction: GradientDirection;
   /** Rotate with shape (a:gradFill rotWithShape). Defaults true per OOXML. */
   rotWithShape?: boolean;
+  /**
+   * Phase 4.5 G5 — `a:gradFill flip` attribute ("x" | "y" | "xy") mirrors the
+   * gradient along the given axis/axes. Absent when no flip is specified.
+   */
+  flip?: "x" | "y" | "xy";
 }
 
 export interface PatternFillResult {
@@ -127,28 +135,104 @@ function parseSolidFillInner(solid: XmlElementNode): SolidFillResult | undefined
 function parseGradientFill(grad: XmlElementNode): GradientFillResult | undefined {
   const gsLst = findFirstChild(grad, "gsLst");
   if (!gsLst) return undefined;
-  const stops: GradientStop[] = [];
+
+  // Phase 4.5 G6 — collect stops with optional `pos` (null = unspecified);
+  // post-pass interpolates the nulls across neighbors rather than collapsing
+  // them all to 0. Matches real-world Word behavior where middle stops may
+  // omit pos and are laid out evenly between specified neighbors.
+  interface RawStop {
+    pos: number | null;
+    color: string;
+    colorType: "srgbClr" | "schemeClr";
+  }
+  const raw: RawStop[] = [];
   for (const child of gsLst.children) {
     if (child.type !== "element") continue;
     if (localName(child.name) !== "gs") continue;
     const posRaw = child.attributes.pos;
-    const pos = posRaw !== undefined ? parseInt(posRaw, 10) : 0;
+    let pos: number | null;
+    if (posRaw === undefined || posRaw === "") {
+      pos = null;
+    } else {
+      const n = parseInt(posRaw, 10);
+      pos = Number.isFinite(n) ? n : null;
+    }
     const token = extractColorToken(child);
     if (!token) continue;
-    stops.push({ pos: Number.isFinite(pos) ? pos : 0, ...token });
+    raw.push({ pos, ...token });
   }
-  if (stops.length === 0) return undefined;
+  if (raw.length === 0) return undefined;
+
+  const stops = interpolateStopPositions(raw);
 
   const direction = readGradientDirection(grad);
   const rotWithShapeRaw = grad.attributes.rotWithShape;
   const rotWithShape =
     rotWithShapeRaw === undefined ? undefined : rotWithShapeRaw !== "0" && rotWithShapeRaw !== "false";
+  const flipRaw = grad.attributes.flip;
+  const flip = flipRaw === "x" || flipRaw === "y" || flipRaw === "xy" ? flipRaw : undefined;
 
   const result: GradientFillResult = { kind: "gradient", stops, direction };
   if (rotWithShape !== undefined) result.rotWithShape = rotWithShape;
+  if (flip !== undefined) result.flip = flip;
   return result;
 }
 
+/**
+ * Phase 4.5 G6 — fill `null` positions by linear interpolation across
+ * defined neighbors. Leading nulls default to 0; trailing nulls default to
+ * 100000 (OOXML gsLst pos unit). Runs of nulls between known positions get
+ * evenly spaced.
+ */
+function interpolateStopPositions(raw: ReadonlyArray<{
+  pos: number | null;
+  color: string;
+  colorType: "srgbClr" | "schemeClr";
+}>): GradientStop[] {
+  const resolved: number[] = new Array(raw.length);
+  // Forward pass with leading-null default of 0
+  let lastKnownIndex = -1;
+  for (let i = 0; i < raw.length; i++) {
+    if (raw[i]?.pos !== null) {
+      resolved[i] = raw[i]!.pos as number;
+      // Fill intervening nulls (lastKnownIndex..i exclusive) by interpolation
+      if (lastKnownIndex >= 0 && i - lastKnownIndex > 1) {
+        const start = resolved[lastKnownIndex]!;
+        const end = resolved[i]!;
+        for (let j = lastKnownIndex + 1; j < i; j++) {
+          resolved[j] = start + ((end - start) * (j - lastKnownIndex)) / (i - lastKnownIndex);
+        }
+      } else if (lastKnownIndex < 0 && i > 0) {
+        // Leading nulls before first known pos — default to 0, then interp
+        for (let j = 0; j < i; j++) {
+          resolved[j] = (resolved[i]! * j) / i;
+        }
+      }
+      lastKnownIndex = i;
+    }
+  }
+  // Trailing nulls after the last known pos — default toward GRADIENT_STOP_UNITS
+  if (lastKnownIndex < raw.length - 1) {
+    const start = lastKnownIndex >= 0 ? resolved[lastKnownIndex]! : 0;
+    const end = GRADIENT_STOP_UNITS;
+    const count = raw.length - 1 - Math.max(lastKnownIndex, 0);
+    for (let j = Math.max(lastKnownIndex, 0) + 1; j < raw.length; j++) {
+      resolved[j] = start + ((end - start) * (j - Math.max(lastKnownIndex, 0))) / (count);
+    }
+  }
+  // All-null case: evenly distribute 0..GRADIENT_STOP_UNITS
+  if (lastKnownIndex < 0) {
+    for (let i = 0; i < raw.length; i++) {
+      resolved[i] = raw.length === 1 ? 0 : (GRADIENT_STOP_UNITS * i) / (raw.length - 1);
+    }
+  }
+  return raw.map((r, i) => ({
+    pos: Math.round(resolved[i]!),
+    color: r.color,
+    colorType: r.colorType,
+  }));
+}
+
 function readGradientDirection(grad: XmlElementNode): GradientDirection {
   const lin = findFirstChild(grad, "lin");
   if (lin) {
@@ -209,7 +293,3 @@ function findFirstChild(
   return undefined;
 }
 
-function localName(name: string): string {
-  const i = name.indexOf(":");
-  return i >= 0 ? name.slice(i + 1) : name;
-}

package/src/io/ooxml/parse-font-table.ts

@@ -14,22 +14,11 @@ import type {
   CanonicalFontEntry,
   CanonicalFontTable,
 } from "../../model/canonical-document.ts";
+import type { XmlElementNode } from "./xml-element.ts";
+import { parseXml } from "./xml-parser.ts";
+import { localName } from "./xml-attr-helpers.ts";
 
-interface XmlElementNode {
-  type: "element";
-  name: string;
-  attributes: Record<string, string>;
-  children: XmlNode[];
-}
-
-interface XmlTextNode {
-  type: "text";
-  text: string;
-}
-
-type XmlNode = XmlElementNode | XmlTextNode;
-
-const KNOWN_FAMILIES = new Set(["roman", "swiss", "modern", "script", "decorative"]);
+const KNOWN_FAMILIES = new Set<CanonicalFontEntry["family"]>(["roman", "swiss", "modern", "script", "decorative"]);
 
 export function parseFontTable(xml: string): CanonicalFontTable {
   const root = parseXml(xml);
@@ -50,7 +39,7 @@ export function parseFontTable(xml: string): CanonicalFontTable {
       switch (localName(sub.name)) {
         case "family": {
           const raw = sub.attributes["w:val"] ?? sub.attributes["val"];
-          if (raw && KNOWN_FAMILIES.has(raw)) {
+          if (raw && KNOWN_FAMILIES.has(raw as CanonicalFontEntry["family"])) {
             entry.family = raw as CanonicalFontEntry["family"];
           }
           break;
@@ -88,10 +77,6 @@ export function parseFontTable(xml: string): CanonicalFontTable {
 // XML helpers — same shape as parse-numbering.ts internals
 // ---------------------------------------------------------------------------
 
-function localName(name: string): string {
-  const separator = name.indexOf(":");
-  return separator >= 0 ? name.slice(separator + 1) : name;
-}
 
 function findChildElementOptional(
   node: XmlElementNode,
@@ -103,88 +88,3 @@ function findChildElementOptional(
   );
 }
 
-function parseXml(xml: string): XmlElementNode {
-  const root: XmlElementNode = {
-    type: "element",
-    name: "__root__",
-    attributes: {},
-    children: [],
-  };
-  const stack: XmlElementNode[] = [root];
-  let cursor = 0;
-
-  while (cursor < xml.length) {
-    if (xml.startsWith("<!--", cursor)) {
-      const end = xml.indexOf("-->", cursor);
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-    if (xml.startsWith("<?", cursor)) {
-      const end = xml.indexOf("?>", cursor);
-      cursor = end >= 0 ? end + 2 : xml.length;
-      continue;
-    }
-    if (xml[cursor] !== "<") {
-      const nextTag = xml.indexOf("<", cursor);
-      cursor = nextTag >= 0 ? nextTag : xml.length;
-      continue;
-    }
-    if (xml[cursor + 1] === "/") {
-      const end = xml.indexOf(">", cursor);
-      if (end < 0) throw new Error("Malformed XML: missing closing >.");
-      stack.pop();
-      cursor = end + 1;
-      continue;
-    }
-
-    const tagEnd = findTagEnd(xml, cursor);
-    const tagBody = xml.slice(cursor + 1, tagEnd);
-    const selfClosing = /\/\s*$/.test(tagBody);
-    const { name, attributes } = parseTag(tagBody.replace(/\/\s*$/, "").trim());
-
-    const element: XmlElementNode = {
-      type: "element",
-      name,
-      attributes,
-      children: [],
-    };
-    stack[stack.length - 1]?.children.push(element);
-    if (!selfClosing) stack.push(element);
-    cursor = tagEnd + 1;
-  }
-
-  return root;
-}
-
-function findTagEnd(xml: string, start: number): number {
-  let cursor = start + 1;
-  let inQuote: '"' | "'" | null = null;
-  while (cursor < xml.length) {
-    const ch = xml[cursor];
-    if (inQuote) {
-      if (ch === inQuote) inQuote = null;
-    } else {
-      if (ch === '"' || ch === "'") inQuote = ch;
-      else if (ch === ">") return cursor;
-    }
-    cursor++;
-  }
-  throw new Error("Malformed XML: missing closing >.");
-}
-
-function parseTag(body: string): { name: string; attributes: Record<string, string> } {
-  const attributes: Record<string, string> = {};
-  let cursor = 0;
-  while (cursor < body.length && !/\s/.test(body[cursor]!)) cursor++;
-  const name = body.slice(0, cursor);
-
-  const attrRegex = /([\w:\-.]+)\s*=\s*"([^"]*)"|([\w:\-.]+)\s*=\s*'([^']*)'/g;
-  let match: RegExpExecArray | null;
-  while ((match = attrRegex.exec(body)) !== null) {
-    const key = match[1] ?? match[3]!;
-    const value = match[2] ?? match[4] ?? "";
-    attributes[key] = value;
-  }
-
-  return { name, attributes };
-}

package/src/io/ooxml/parse-footnotes.ts

@@ -44,6 +44,8 @@ import {
   readTableStyleId,
   readTableWidth,
 } from "./parse-tables.ts";
+import { parseXmlWithOffsets as parseXml } from "./xml-parser.ts";
+import { localName, readStringAttr } from "./xml-attr-helpers.ts";
 
 // ---- XML node types (inline, no external dep) ----
 
@@ -77,7 +79,7 @@ const SPECIAL_NOTE_TYPES = new Set(["separator", "continuationSeparator"]);
  * Also accepts endnotes.xml (<w:endnotes> root).
  */
 export function parseFootnotesXml(xml: string): FootnoteCollection {
-  const root = parseXml(xml);
+  const root = parseXml(xml) as XmlElementNode;
 
   const footnotesElement = findChildElementOptional(root, "footnotes");
   const endnotesElement = findChildElementOptional(root, "endnotes");
@@ -131,7 +133,7 @@ export function parseEndnotesXml(
   xml: string,
   existing?: FootnoteCollection,
 ): FootnoteCollection {
-  const root = parseXml(xml);
+  const root = parseXml(xml) as XmlElementNode;
   const endnotesElement = findChildElementOptional(root, "endnotes");
   const endnotes: Record<string, FootnoteDefinition> = {
     ...(existing?.endnotes ?? {}),
@@ -165,7 +167,7 @@ export function parseEndnotesXml(
  * by the page-chrome renderer at the footnote divider line.
  */
 export function parseFootnoteSeparators(xml: string): FootnoteSeparators {
-  const root = parseXml(xml);
+  const root = parseXml(xml) as XmlElementNode;
   const footnotesEl = findChildElementOptional(root, "footnotes");
   const endnotesEl = findChildElementOptional(root, "endnotes");
   const containerEl = footnotesEl ?? endnotesEl;
@@ -179,7 +181,7 @@ export function parseFootnoteSeparators(xml: string): FootnoteSeparators {
     const name = localName(child.name);
     if (name !== "footnote" && name !== "endnote") continue;
 
-    const rawType = child.attributes["w:type"] ?? child.attributes.type ?? "";
+    const rawType = readStringAttr(child, "w:type") ?? "";
     if (rawType !== "separator" && rawType !== "continuationSeparator") continue;
 
     const paraEl = findChildElementOptional(child, "p");
@@ -210,9 +212,9 @@ function parseNoteElement(
   kind: "footnote" | "endnote",
 ): FootnoteDefinition | undefined {
   const rawId =
-    element.attributes["w:id"] ?? element.attributes.id ?? "";
+    readStringAttr(element, "w:id") ?? "";
   const rawType =
-    element.attributes["w:type"] ?? element.attributes.type ?? "";
+    readStringAttr(element, "w:type") ?? "";
 
   if (!rawId || SPECIAL_NOTE_IDS.has(rawId) || SPECIAL_NOTE_TYPES.has(rawType)) {
     return undefined;
@@ -347,7 +349,7 @@ function appendRunNodes(
 
     const name = localName(child.name);
     if (name === "fldChar") {
-      const fldType = child.attributes["w:fldCharType"] ?? child.attributes.fldCharType;
+      const fldType = readStringAttr(child, "w:fldCharType");
       if (fldType === "begin") {
         activeComplexField = { instruction: "", children: [], mode: "instruction" };
       } else if (fldType === "separate" && activeComplexField) {
@@ -414,13 +416,13 @@ function parseRunElement(rElement: XmlElementNode): InlineNode[] {
       // The in-note reference marker (superscript) - skip, rendered by the host
     } else if (name === "footnoteReference") {
       const noteId =
-        child.attributes["w:id"] ?? child.attributes.id ?? "";
+        readStringAttr(child, "w:id") ?? "";
       if (noteId) {
         nodes.push({ type: "footnote_ref", noteId, noteKind: "footnote" });
       }
     } else if (name === "endnoteReference") {
       const noteId =
-        child.attributes["w:id"] ?? child.attributes.id ?? "";
+        readStringAttr(child, "w:id") ?? "";
       if (noteId) {
         nodes.push({ type: "footnote_ref", noteId, noteKind: "endnote" });
       }
@@ -459,7 +461,7 @@ function parseRunChildNode(
   }
   if (name === "footnoteReference") {
     const noteId =
-      child.attributes["w:id"] ?? child.attributes.id ?? "";
+      readStringAttr(child, "w:id") ?? "";
     if (noteId) {
       return { type: "footnote_ref", noteId, noteKind: "footnote" };
     }
@@ -467,7 +469,7 @@ function parseRunChildNode(
   }
   if (name === "endnoteReference") {
     const noteId =
-      child.attributes["w:id"] ?? child.attributes.id ?? "";
+      readStringAttr(child, "w:id") ?? "";
     if (noteId) {
       return { type: "footnote_ref", noteId, noteKind: "endnote" };
     }
@@ -506,12 +508,12 @@ function parseHyperlinkElement(element: XmlElementNode): Extract<InlineNode, { t
 function parseBookmarkElement(
   element: XmlElementNode,
 ): Extract<InlineNode, { type: "bookmark_start" | "bookmark_end" }> {
-  const bookmarkId = element.attributes["w:id"] ?? element.attributes.id ?? "0";
+  const bookmarkId = readStringAttr(element, "w:id") ?? "0";
   if (localName(element.name) === "bookmarkStart") {
     return {
       type: "bookmark_start",
       bookmarkId,
-      name: element.attributes["w:name"] ?? element.attributes.name ?? "",
+      name: readStringAttr(element, "w:name") ?? "",
     };
   }
 
@@ -555,8 +557,7 @@ function createFieldNode(
 
 function readFieldInstruction(element: XmlElementNode): string | undefined {
   const instruction =
-    element.attributes["w:instr"] ??
-    element.attributes.instr ??
+    readStringAttr(element, "w:instr") ??
     extractTextContent(element);
   return instruction.trim().length > 0 ? instruction : undefined;
 }
@@ -575,7 +576,7 @@ function parseRunProperties(rElement: XmlElementNode): TextMark[] {
     }
 
     const name = localName(child.name);
-    const val = child.attributes["w:val"] ?? child.attributes.val ?? "true";
+    const val = readStringAttr(child, "w:val") ?? "true";
 
     switch (name) {
       case "b":
@@ -603,7 +604,7 @@ function parseRunProperties(rElement: XmlElementNode): TextMark[] {
         break;
       }
       case "sz": {
-        const szVal = child.attributes["w:val"] ?? child.attributes.val;
+        const szVal = readStringAttr(child, "w:val");
         if (szVal) {
           const size = Number.parseInt(szVal, 10);
           if (Number.isFinite(size) && size > 0) marks.push({ type: "fontSize", val: size });
@@ -611,7 +612,7 @@ function parseRunProperties(rElement: XmlElementNode): TextMark[] {
         break;
       }
       case "color": {
-        const colorVal = child.attributes["w:val"] ?? child.attributes.val;
+        const colorVal = readStringAttr(child, "w:val");
         // A.9: preserve "auto" verbatim for round-trip.
         if (colorVal) marks.push({ type: "textColor", color: colorVal });
         break;
@@ -632,13 +633,13 @@ function readParagraphSpacing(pPr: XmlElementNode): ParagraphSpacing | undefined
   const spacingNode = findChildElementOptional(pPr, "spacing");
   if (!spacingNode) return undefined;
   const result: ParagraphSpacing = {};
-  const before = spacingNode.attributes["w:before"] ?? spacingNode.attributes.before;
+  const before = readStringAttr(spacingNode, "w:before");
   if (before) result.before = Number.parseInt(before, 10);
-  const after = spacingNode.attributes["w:after"] ?? spacingNode.attributes.after;
+  const after = readStringAttr(spacingNode, "w:after");
   if (after) result.after = Number.parseInt(after, 10);
-  const line = spacingNode.attributes["w:line"] ?? spacingNode.attributes.line;
+  const line = readStringAttr(spacingNode, "w:line");
   if (line) result.line = Number.parseInt(line, 10);
-  const lineRule = spacingNode.attributes["w:lineRule"] ?? spacingNode.attributes.lineRule;
+  const lineRule = readStringAttr(spacingNode, "w:lineRule");
   if (lineRule === "auto" || lineRule === "exact" || lineRule === "atLeast") {
     result.lineRule = lineRule;
   }
@@ -649,13 +650,13 @@ function readParagraphIndentation(pPr: XmlElementNode): ParagraphIndentation | u
   const indNode = findChildElementOptional(pPr, "ind");
   if (!indNode) return undefined;
   const result: ParagraphIndentation = {};
-  const left = indNode.attributes["w:left"] ?? indNode.attributes.left;
+  const left = readStringAttr(indNode, "w:left");
   if (left) result.left = Number.parseInt(left, 10);
-  const right = indNode.attributes["w:right"] ?? indNode.attributes.right;
+  const right = readStringAttr(indNode, "w:right");
   if (right) result.right = Number.parseInt(right, 10);
-  const firstLine = indNode.attributes["w:firstLine"] ?? indNode.attributes.firstLine;
+  const firstLine = readStringAttr(indNode, "w:firstLine");
   if (firstLine) result.firstLine = Number.parseInt(firstLine, 10);
-  const hanging = indNode.attributes["w:hanging"] ?? indNode.attributes.hanging;
+  const hanging = readStringAttr(indNode, "w:hanging");
   if (hanging) result.hanging = Number.parseInt(hanging, 10);
   return Object.keys(result).length > 0 ? result : undefined;
 }
@@ -680,10 +681,6 @@ function findChildElementOptional(
   );
 }
 
-function localName(name: string): string {
-  const idx = name.indexOf(":");
-  return idx >= 0 ? name.slice(idx + 1) : name;
-}
 
 // ---- Simple secondary-story table support ----
 
@@ -864,7 +861,7 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
 
       const vmEl = findChildElementOptional(child, "vMerge");
       if (vmEl) {
-        const vmVal = vmEl.attributes["w:val"] ?? vmEl.attributes.val ?? "continue";
+        const vmVal = readStringAttr(vmEl, "w:val") ?? "continue";
         verticalMerge = vmVal === "restart" ? "restart" : "continue";
       }
       width = readCellWidth(child);
@@ -931,124 +928,3 @@ function escapeXmlText(text: string): string {
     .replace(/</g, "&lt;")
     .replace(/>/g, "&gt;");
 }
-
-// ---- Minimal XML parser (same pattern as parse-numbering.ts) ----
-
-function parseXml(xml: string): XmlElementNode {
-  const root: XmlElementNode = {
-    type: "element",
-    name: "__root__",
-    attributes: {},
-    children: [],
-    start: 0,
-    end: xml.length,
-  };
-  const stack: XmlElementNode[] = [root];
-  let cursor = 0;
-
-  while (cursor < xml.length) {
-    if (xml.startsWith("<!--", cursor)) {
-      const end = xml.indexOf("-->", cursor);
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-
-    if (xml.startsWith("<?", cursor)) {
-      const end = xml.indexOf("?>", cursor);
-      cursor = end >= 0 ? end + 2 : xml.length;
-      continue;
-    }
-
-    if (xml.startsWith("<![CDATA[", cursor)) {
-      const end = xml.indexOf("]]>", cursor);
-      const textEnd = end >= 0 ? end : xml.length;
-      stack[stack.length - 1]?.children.push({
-        type: "text",
-        text: xml.slice(cursor + 9, textEnd),
-        start: cursor,
-        end: end >= 0 ? end + 3 : xml.length,
-      });
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-
-    if (xml[cursor] !== "<") {
-      const nextTag = xml.indexOf("<", cursor);
-      const end = nextTag >= 0 ? nextTag : xml.length;
-      const text = decodeXmlEntities(xml.slice(cursor, end));
-      if (text.trim().length > 0 || (text.length > 0 && stack.length > 1)) {
-        stack[stack.length - 1]?.children.push({ type: "text", text, start: cursor, end });
-      }
-      cursor = end;
-      continue;
-    }
-
-    if (xml[cursor + 1] === "/") {
-      const end = xml.indexOf(">", cursor);
-      if (end < 0) break;
-      const current = stack.pop();
-      if (current) {
-        current.end = end + 1;
-      }
-      cursor = end + 1;
-      continue;
-    }
-
-    const tagEnd = xml.indexOf(">", cursor);
-    if (tagEnd < 0) break;
-
-    const tagContent = xml.slice(cursor + 1, tagEnd);
-    const selfClosing = tagContent.endsWith("/");
-    const normalized = selfClosing ? tagContent.slice(0, -1).trimEnd() : tagContent;
-
-    const spaceIndex = normalized.search(/\s/);
-    const tagName = spaceIndex >= 0 ? normalized.slice(0, spaceIndex) : normalized;
-    const attrString = spaceIndex >= 0 ? normalized.slice(spaceIndex + 1) : "";
-    const attributes = parseAttributes(attrString);
-
-    const element: XmlElementNode = {
-      type: "element",
-      name: tagName,
-      attributes,
-      children: [],
-      start: cursor,
-      end: tagEnd + 1,
-    };
-
-    stack[stack.length - 1]?.children.push(element);
-
-    if (!selfClosing) {
-      stack.push(element);
-    }
-
-    cursor = tagEnd + 1;
-  }
-
-  return root;
-}
-
-function parseAttributes(attrString: string): Record<string, string> {
-  const attrs: Record<string, string> = {};
-  const pattern = /([A-Za-z_:][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/gu;
-  for (const match of attrString.matchAll(pattern)) {
-    const name = match[1];
-    const value = match[3] ?? match[4] ?? "";
-    if (name) {
-      attrs[name] = decodeXmlEntities(value);
-    }
-  }
-  return attrs;
-}
-
-function decodeXmlEntities(text: string): string {
-  return text
-    .replace(/&amp;/g, "&")
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&quot;/g, '"')
-    .replace(/&apos;/g, "'")
-    .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number.parseInt(dec, 10)))
-    .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) =>
-      String.fromCodePoint(Number.parseInt(hex, 16)),
-    );
-}