@beyondwork/docx-react-component 1.0.29 → 1.0.30

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

@@ -0,0 +1,747 @@
+import type {
+  NumberingCatalog,
+  NumberingLevelDefinition,
+  NumberingLevelParagraphGeometry,
+  NumberingLevelOverride,
+  NumberingLevelOverrideDefinition,
+  ParagraphSpacing,
+  ParagraphIndentation,
+  TabStop,
+} from "../../model/canonical-document.ts";
+
+export interface ParsedParagraphNumberingReference {
+  paragraphIndex: number;
+  numberingInstanceId: string;
+  level: number;
+}
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+export function parseNumberingXml(xml: string): NumberingCatalog {
+  const root = parseXml(xml);
+  const numberingElement = findChildElement(root, "numbering");
+  const abstractDefinitions: NumberingCatalog["abstractDefinitions"] = {};
+  const instances: NumberingCatalog["instances"] = {};
+
+  for (const child of numberingElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    switch (localName(child.name)) {
+      case "abstractNum": {
+        const rawId = child.attributes["w:abstractNumId"] ?? child.attributes.abstractNumId;
+        if (!rawId) {
+          continue;
+        }
+
+        const abstractNumberingId = toCanonicalAbstractNumberingId(rawId);
+        abstractDefinitions[abstractNumberingId] = {
+          abstractNumberingId,
+          levels: readLevels(child),
+        };
+        break;
+      }
+      case "num": {
+        const rawId = child.attributes["w:numId"] ?? child.attributes.numId;
+        const abstractReference = findChildElementOptional(child, "abstractNumId");
+        const rawAbstractId =
+          abstractReference?.attributes["w:val"] ?? abstractReference?.attributes.val;
+
+        if (!rawId || !rawAbstractId) {
+          continue;
+        }
+
+        const numberingInstanceId = toCanonicalNumberingInstanceId(rawId);
+        instances[numberingInstanceId] = {
+          numberingInstanceId,
+          abstractNumberingId: toCanonicalAbstractNumberingId(rawAbstractId),
+          overrides: readOverrides(child),
+        };
+        break;
+      }
+    }
+  }
+
+  return {
+    abstractDefinitions,
+    instances,
+  };
+}
+
+export function parseParagraphNumberingReferences(
+  documentXml: string,
+): ParsedParagraphNumberingReference[] {
+  const root = parseXml(documentXml);
+  const documentElement = findChildElement(root, "document");
+  const bodyElement = findChildElement(documentElement, "body");
+  const references: ParsedParagraphNumberingReference[] = [];
+  let paragraphIndex = 0;
+
+  for (const child of bodyElement.children) {
+    if (child.type !== "element" || localName(child.name) !== "p") {
+      continue;
+    }
+
+    const paragraphProperties = findChildElementOptional(child, "pPr");
+    const numberingProperties = paragraphProperties
+      ? findChildElementOptional(paragraphProperties, "numPr")
+      : undefined;
+
+    if (numberingProperties) {
+      const levelNode = findChildElementOptional(numberingProperties, "ilvl");
+      const instanceNode = findChildElementOptional(numberingProperties, "numId");
+      const rawLevel = levelNode?.attributes["w:val"] ?? levelNode?.attributes.val;
+      const rawInstanceId = instanceNode?.attributes["w:val"] ?? instanceNode?.attributes.val;
+
+      if (rawLevel !== undefined && rawInstanceId) {
+        const level = parseInteger(rawLevel);
+        if (level !== undefined) {
+          references.push({
+            paragraphIndex,
+            numberingInstanceId: toCanonicalNumberingInstanceId(rawInstanceId),
+            level,
+          });
+        }
+      }
+    }
+
+    paragraphIndex += 1;
+  }
+
+  return references;
+}
+
+export function toCanonicalAbstractNumberingId(value: string): string {
+  return value.startsWith("abstract-num:") ? value : `abstract-num:${value}`;
+}
+
+export function toCanonicalNumberingInstanceId(value: string): string {
+  return value.startsWith("num:") ? value : `num:${value}`;
+}
+
+function readLevels(abstractNode: XmlElementNode): NumberingLevelDefinition[] {
+  const levels: NumberingLevelDefinition[] = [];
+
+  for (const child of abstractNode.children) {
+    if (child.type !== "element" || localName(child.name) !== "lvl") {
+      continue;
+    }
+
+    const rawLevel = child.attributes["w:ilvl"] ?? child.attributes.ilvl;
+    const level = rawLevel === undefined ? undefined : parseInteger(rawLevel);
+    if (level === undefined) {
+      continue;
+    }
+    const definition = readLevelDefinition(child, level);
+    if (!definition) {
+      continue;
+    }
+
+    levels.push(definition);
+  }
+
+  return levels.sort((left, right) => left.level - right.level);
+}
+
+function readOverrides(numNode: XmlElementNode): NumberingLevelOverride[] {
+  const overrides: NumberingLevelOverride[] = [];
+
+  for (const child of numNode.children) {
+    if (child.type !== "element" || localName(child.name) !== "lvlOverride") {
+      continue;
+    }
+
+    const rawLevel = child.attributes["w:ilvl"] ?? child.attributes.ilvl;
+    const level = rawLevel === undefined ? undefined : parseInteger(rawLevel);
+    if (level === undefined) {
+      continue;
+    }
+
+    const startOverrideNode = findChildElementOptional(child, "startOverride");
+    const rawStart = startOverrideNode?.attributes["w:val"] ?? startOverrideNode?.attributes.val;
+    const startAt = rawStart === undefined ? undefined : parseInteger(rawStart);
+    const levelDefinitionNode = findChildElementOptional(child, "lvl");
+    const levelDefinition = levelDefinitionNode
+      ? readLevelOverrideDefinition(levelDefinitionNode, level)
+      : undefined;
+
+    overrides.push({
+      level,
+      ...(startAt !== undefined ? { startAt } : {}),
+      ...(levelDefinition ? { levelDefinition } : {}),
+    });
+  }
+
+  return overrides.sort((left, right) => left.level - right.level);
+}
+
+function readLevelDefinition(
+  levelNode: XmlElementNode,
+  fallbackLevel?: number,
+): NumberingLevelDefinition | undefined {
+  const rawLevel = levelNode.attributes["w:ilvl"] ?? levelNode.attributes.ilvl;
+  const level = rawLevel === undefined ? fallbackLevel : parseInteger(rawLevel);
+  if (level === undefined) {
+    return undefined;
+  }
+
+  const startNode = findChildElementOptional(levelNode, "start");
+  const formatNode = findChildElementOptional(levelNode, "numFmt");
+  const textNode = findChildElementOptional(levelNode, "lvlText");
+  const paragraphStyleNode = findChildElementOptional(levelNode, "pStyle");
+  const rawStart = startNode?.attributes["w:val"] ?? startNode?.attributes.val;
+  const startAt = rawStart === undefined ? undefined : parseInteger(rawStart);
+  const format = formatNode?.attributes["w:val"] ?? formatNode?.attributes.val ?? "decimal";
+  const text = textNode?.attributes["w:val"] ?? textNode?.attributes.val ?? `%${level + 1}.`;
+  const paragraphStyleId =
+    paragraphStyleNode?.attributes["w:val"] ?? paragraphStyleNode?.attributes.val;
+  const isLegalNode = findChildElementOptional(levelNode, "isLgl");
+  const isLegalNumbering = readIsLegalNumberingValue(isLegalNode);
+  const suffixNode = findChildElementOptional(levelNode, "suff");
+  const suffixVal = suffixNode?.attributes["w:val"] ?? suffixNode?.attributes.val;
+  const suffix =
+    suffixVal === "space" || suffixVal === "nothing"
+      ? suffixVal
+      : suffixVal === "tab"
+        ? "tab"
+        : undefined;
+  const paragraphGeometry = readLevelParagraphGeometry(levelNode);
+
+  return {
+    level,
+    format,
+    text,
+    ...(startAt !== undefined ? { startAt } : {}),
+    ...(paragraphStyleId ? { paragraphStyleId } : {}),
+    ...(isLegalNumbering ? { isLegalNumbering: true } : {}),
+    ...(suffix ? { suffix } : {}),
+    ...(paragraphGeometry ? { paragraphGeometry } : {}),
+  };
+}
+
+function readLevelOverrideDefinition(
+  levelNode: XmlElementNode,
+  fallbackLevel?: number,
+): NumberingLevelOverrideDefinition | undefined {
+  const rawLevel = levelNode.attributes["w:ilvl"] ?? levelNode.attributes.ilvl;
+  const level = rawLevel === undefined ? fallbackLevel : parseInteger(rawLevel);
+  if (level === undefined) {
+    return undefined;
+  }
+
+  const startNode = findChildElementOptional(levelNode, "start");
+  const formatNode = findChildElementOptional(levelNode, "numFmt");
+  const textNode = findChildElementOptional(levelNode, "lvlText");
+  const paragraphStyleNode = findChildElementOptional(levelNode, "pStyle");
+  const rawStart = startNode?.attributes["w:val"] ?? startNode?.attributes.val;
+  const startAt = rawStart === undefined ? undefined : parseInteger(rawStart);
+  const format = formatNode?.attributes["w:val"] ?? formatNode?.attributes.val;
+  const text = textNode?.attributes["w:val"] ?? textNode?.attributes.val;
+  const paragraphStyleId =
+    paragraphStyleNode?.attributes["w:val"] ?? paragraphStyleNode?.attributes.val;
+  const isLegalNode = findChildElementOptional(levelNode, "isLgl");
+  const isLegalNumbering = readIsLegalNumberingValue(isLegalNode);
+  const suffixNode = findChildElementOptional(levelNode, "suff");
+  const suffixVal = suffixNode?.attributes["w:val"] ?? suffixNode?.attributes.val;
+  const suffix =
+    suffixVal === "space" || suffixVal === "nothing"
+      ? suffixVal
+      : suffixVal === "tab"
+        ? "tab"
+        : undefined;
+  const paragraphGeometry = readLevelParagraphGeometry(levelNode);
+
+  const hasExplicitFields =
+    startAt !== undefined ||
+    format !== undefined ||
+    text !== undefined ||
+    paragraphStyleId !== undefined ||
+    isLegalNumbering !== undefined ||
+    suffix !== undefined ||
+    paragraphGeometry !== undefined;
+
+  if (!hasExplicitFields) {
+    return undefined;
+  }
+
+  return {
+    level,
+    ...(startAt !== undefined ? { startAt } : {}),
+    ...(format !== undefined ? { format } : {}),
+    ...(text !== undefined ? { text } : {}),
+    ...(paragraphStyleId ? { paragraphStyleId } : {}),
+    ...(isLegalNumbering !== undefined ? { isLegalNumbering } : {}),
+    ...(suffix ? { suffix } : {}),
+    ...(paragraphGeometry ? { paragraphGeometry } : {}),
+  };
+}
+
+function readLevelParagraphGeometry(
+  levelNode: XmlElementNode,
+): NumberingLevelDefinition["paragraphGeometry"] | undefined {
+  const paragraphPropertiesNode = findChildElementOptional(levelNode, "pPr");
+  const justification = readLevelJustification(levelNode);
+  const spacing = paragraphPropertiesNode ? readParagraphSpacing(paragraphPropertiesNode) : undefined;
+  const indentation = paragraphPropertiesNode
+    ? readParagraphIndentation(paragraphPropertiesNode)
+    : undefined;
+  const tabStops = paragraphPropertiesNode ? readParagraphTabStops(paragraphPropertiesNode) : undefined;
+
+  if (!justification && !spacing && !indentation && (!tabStops || tabStops.length === 0)) {
+    return undefined;
+  }
+
+  return {
+    ...(justification ? { justification } : {}),
+    ...(spacing ? { spacing } : {}),
+    ...(indentation ? { indentation } : {}),
+    ...(tabStops && tabStops.length > 0 ? { tabStops } : {}),
+  };
+}
+
+function readLevelJustification(
+  levelNode: XmlElementNode,
+): NumberingLevelParagraphGeometry["justification"] {
+  const justificationNode = findChildElementOptional(levelNode, "lvlJc");
+  if (!justificationNode) {
+    return undefined;
+  }
+
+  const rawValue = (
+    justificationNode.attributes["w:val"] ??
+    justificationNode.attributes.val ??
+    ""
+  ).toLowerCase();
+
+  if (rawValue === "start") {
+    return "left";
+  }
+  if (rawValue === "end") {
+    return "right";
+  }
+  if (
+    rawValue === "left" ||
+    rawValue === "center" ||
+    rawValue === "right" ||
+    rawValue === "both" ||
+    rawValue === "distribute"
+  ) {
+    return rawValue;
+  }
+
+  return undefined;
+}
+
+function readParagraphIndentation(node: XmlElementNode): ParagraphIndentation | undefined {
+  const indNode = findChildElementOptional(node, "ind");
+  if (!indNode) {
+    return undefined;
+  }
+
+  const indentation: ParagraphIndentation = {};
+  const left =
+    indNode.attributes["w:start"] ??
+    indNode.attributes.start ??
+    indNode.attributes["w:left"] ??
+    indNode.attributes.left;
+  const right =
+    indNode.attributes["w:end"] ??
+    indNode.attributes.end ??
+    indNode.attributes["w:right"] ??
+    indNode.attributes.right;
+  const firstLine = indNode.attributes["w:firstLine"] ?? indNode.attributes.firstLine;
+  const hanging = indNode.attributes["w:hanging"] ?? indNode.attributes.hanging;
+
+  if (left !== undefined) {
+    const value = Number.parseInt(left, 10);
+    if (Number.isFinite(value)) indentation.left = value;
+  }
+  if (right !== undefined) {
+    const value = Number.parseInt(right, 10);
+    if (Number.isFinite(value)) indentation.right = value;
+  }
+  if (firstLine !== undefined) {
+    const value = Number.parseInt(firstLine, 10);
+    if (Number.isFinite(value)) indentation.firstLine = value;
+  }
+  if (hanging !== undefined) {
+    const value = Number.parseInt(hanging, 10);
+    if (Number.isFinite(value)) indentation.hanging = value;
+  }
+
+  if (
+    indentation.left === undefined &&
+    indentation.right === undefined &&
+    indentation.firstLine === undefined &&
+    indentation.hanging === undefined
+  ) {
+    return undefined;
+  }
+
+  return indentation;
+}
+
+function readParagraphSpacing(node: XmlElementNode): ParagraphSpacing | undefined {
+  const spacingNode = findChildElementOptional(node, "spacing");
+  if (!spacingNode) {
+    return undefined;
+  }
+
+  const spacing: ParagraphSpacing = {};
+  const before = spacingNode.attributes["w:before"] ?? spacingNode.attributes.before;
+  const after = spacingNode.attributes["w:after"] ?? spacingNode.attributes.after;
+  const line = spacingNode.attributes["w:line"] ?? spacingNode.attributes.line;
+  const lineRule = spacingNode.attributes["w:lineRule"] ?? spacingNode.attributes.lineRule;
+
+  if (before !== undefined) {
+    const value = Number.parseInt(before, 10);
+    if (Number.isFinite(value)) spacing.before = value;
+  }
+  if (after !== undefined) {
+    const value = Number.parseInt(after, 10);
+    if (Number.isFinite(value)) spacing.after = value;
+  }
+  if (line !== undefined) {
+    const value = Number.parseInt(line, 10);
+    if (Number.isFinite(value)) spacing.line = value;
+  }
+  if (lineRule !== undefined) {
+    const normalized = lineRule.toLowerCase();
+    if (normalized === "auto" || normalized === "exact") {
+      spacing.lineRule = normalized;
+    } else if (normalized === "atleast") {
+      spacing.lineRule = "atLeast";
+    }
+  }
+
+  if (
+    spacing.before === undefined &&
+    spacing.after === undefined &&
+    spacing.line === undefined &&
+    spacing.lineRule === undefined
+  ) {
+    return undefined;
+  }
+
+  return spacing;
+}
+
+function readParagraphTabStops(node: XmlElementNode): TabStop[] | undefined {
+  const tabsNode = findChildElementOptional(node, "tabs");
+  if (!tabsNode) {
+    return undefined;
+  }
+
+  const tabStops: TabStop[] = [];
+  for (const child of tabsNode.children) {
+    if (child.type !== "element" || localName(child.name) !== "tab") {
+      continue;
+    }
+
+    const pos = child.attributes["w:pos"] ?? child.attributes.pos;
+    const val = (child.attributes["w:val"] ?? child.attributes.val ?? "left").toLowerCase();
+    const leader = (child.attributes["w:leader"] ?? child.attributes.leader ?? "none").toLowerCase();
+    if (pos === undefined) {
+      continue;
+    }
+
+    const position = Number.parseInt(pos, 10);
+    if (!Number.isFinite(position)) {
+      continue;
+    }
+
+    const align = (["left", "center", "right", "decimal", "num", "bar", "clear"] as const).includes(
+      val as TabStop["align"],
+    )
+      ? (val as TabStop["align"])
+      : "left";
+    const leaderValue =
+      leader === "none" ||
+      leader === "dot" ||
+      leader === "hyphen" ||
+      leader === "underscore" ||
+      leader === "heavy"
+        ? (leader as Exclude<TabStop["leader"], "middleDot">)
+        : leader === "middledot"
+          ? "middleDot"
+          : undefined;
+
+    tabStops.push({
+      position,
+      align,
+      ...(leaderValue && leaderValue !== "none" ? { leader: leaderValue } : {}),
+    });
+  }
+
+  return tabStops.length > 0 ? tabStops : undefined;
+}
+
+function readIsLegalNumberingValue(
+  isLegalNode: XmlElementNode | undefined,
+): boolean | undefined {
+  if (!isLegalNode) {
+    return undefined;
+  }
+
+  const rawValue = (
+    isLegalNode.attributes["w:val"] ??
+    isLegalNode.attributes.val ??
+    "1"
+  ).toLowerCase();
+
+  if (rawValue === "0" || rawValue === "false" || rawValue === "off") {
+    return false;
+  }
+
+  return true;
+}
+
+function findChildElement(node: XmlElementNode, childLocalName: string): XmlElementNode {
+  const child = findChildElementOptional(node, childLocalName);
+  if (!child) {
+    throw new Error(`Expected <${childLocalName}> element in numbering XML.`);
+  }
+
+  return child;
+}
+
+function findChildElementOptional(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (entry): entry is XmlElementNode =>
+      entry.type === "element" && localName(entry.name) === childLocalName,
+  );
+}
+
+function localName(name: string): string {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+
+function parseInteger(value: string): number | undefined {
+  if (!/^-?\d+$/.test(value)) {
+    return undefined;
+  }
+
+  return Number.parseInt(value, 10);
+}
+
+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.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),
+      });
+      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.length > 0) {
+        stack[stack.length - 1]?.children.push({
+          type: "text",
+          text,
+        });
+      }
+      cursor = end;
+      continue;
+    }
+
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      if (end < 0) {
+        throw new Error("Malformed XML: missing closing >.");
+      }
+
+      const name = xml.slice(cursor + 2, end).trim();
+      const current = stack.pop();
+      if (!current || localName(current.name) !== localName(name)) {
+        throw new Error(`Malformed XML: unexpected closing tag </${name}>.`);
+      }
+
+      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;
+  }
+
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed element.");
+  }
+
+  return root;
+}
+
+function parseTag(tagBody: string): { name: string; attributes: Record<string, string> } {
+  let cursor = 0;
+  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+
+  const nameStart = cursor;
+  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+
+  const name = tagBody.slice(nameStart, cursor);
+  const attributes: Record<string, string> = {};
+
+  while (cursor < tagBody.length) {
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    if (cursor >= tagBody.length) {
+      break;
+    }
+
+    const keyStart = cursor;
+    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    const key = tagBody.slice(keyStart, cursor);
+
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+
+    if (tagBody[cursor] !== "=") {
+      attributes[key] = "";
+      continue;
+    }
+    cursor += 1;
+
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+
+    const quote = tagBody[cursor];
+    if (quote !== `"` && quote !== `'`) {
+      throw new Error(`Malformed XML attribute ${key}.`);
+    }
+    cursor += 1;
+
+    const valueStart = cursor;
+    while (cursor < tagBody.length && tagBody[cursor] !== quote) {
+      cursor += 1;
+    }
+    const rawValue = tagBody.slice(valueStart, cursor);
+    attributes[key] = decodeXmlEntities(rawValue);
+    cursor += 1;
+  }
+
+  return { name, attributes };
+}
+
+function findTagEnd(xml: string, start: number): number {
+  let cursor = start + 1;
+  let quote: string | null = null;
+
+  while (cursor < xml.length) {
+    const current = xml[cursor];
+    if (quote) {
+      if (current === quote) {
+        quote = null;
+      }
+      cursor += 1;
+      continue;
+    }
+
+    if (current === `"` || current === `'`) {
+      quote = current;
+      cursor += 1;
+      continue;
+    }
+
+    if (current === ">") {
+      return cursor;
+    }
+
+    cursor += 1;
+  }
+
+  throw new Error("Malformed XML: missing >.");
+}
+
+function decodeXmlEntities(value: string): string {
+  return value.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (match, entity) => {
+    switch (entity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return `"`;
+      case "apos":
+        return "'";
+      default:
+        if (entity.startsWith("#x")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        }
+        if (entity.startsWith("#")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+        }
+        return match;
+    }
+  });
+}