@portone/docx-editor 0.2.0 → 0.3.0

package/dist/ooxml/props.js

@@ -0,0 +1,214 @@
+// src/ooxml/props.ts
+import { childOrderOf } from "./childOrder.js";
+import { attrsText, emptyTagXml } from "./element.js";
+import { wName } from "./names.js";
+import { parseAttrs, readTag } from "./tagScan.js";
+import { elementChildren, localPart, namespaceDecls, parseXml } from "./xml.js";
+function rawAttrs(source, tag) {
+  const closeLength = tag.kind === "empty" ? 2 : 1;
+  const attrs = source.slice(tag.nameEnd, tag.end - closeLength).trim();
+  return attrs.length > 0 ? attrs : null;
+}
+function innerXml(xml) {
+  const open = readTag(xml, 0);
+  if (!open || xml[0] !== "<" || open.kind !== "open") return "";
+  const close = xml.lastIndexOf("</");
+  return close > open.end ? xml.slice(open.end, close) : "";
+}
+function parseProps(xml) {
+  const open = readTag(xml, 0);
+  if (!open || xml[0] !== "<") return null;
+  const attrs = rawAttrs(xml, open);
+  if (open.kind === "empty") {
+    return open.end === xml.length ? { tag: open.name, attrs, children: [] } : null;
+  }
+  if (open.kind !== "open") return null;
+  const children = [];
+  let depth = 0;
+  let childStart = -1;
+  let childName = "";
+  let i = open.end;
+  let gapStart = open.end;
+  const gapBefore = (start) => {
+    const gap = xml.slice(gapStart, start);
+    return gap.length > 0 ? { before: gap } : {};
+  };
+  while (i < xml.length) {
+    const lt = xml.indexOf("<", i);
+    if (lt === -1) return null;
+    const tag = readTag(xml, lt);
+    if (!tag) return null;
+    if (tag.kind === "other") {
+      i = tag.end;
+      continue;
+    }
+    if (depth === 0) {
+      if (tag.kind === "close") {
+        if (tag.name !== open.name || tag.end !== xml.length) return null;
+        const tail = xml.slice(gapStart, lt);
+        return tail.length > 0 ? { tag: open.name, attrs, children, tail } : { tag: open.name, attrs, children };
+      }
+      childStart = lt;
+      childName = tag.name;
+      if (tag.kind === "empty") {
+        children.push({
+          name: localPart(childName),
+          xml: xml.slice(childStart, tag.end),
+          ...gapBefore(childStart)
+        });
+        gapStart = tag.end;
+      } else {
+        depth = 1;
+      }
+    } else if (tag.kind === "open") {
+      depth += 1;
+    } else if (tag.kind === "close") {
+      depth -= 1;
+      if (depth === 0) {
+        children.push({
+          name: localPart(childName),
+          xml: xml.slice(childStart, tag.end),
+          ...gapBefore(childStart)
+        });
+        gapStart = tag.end;
+      }
+    }
+    i = tag.end;
+  }
+  return null;
+}
+function renderProps(props) {
+  const tail = props.tail ?? "";
+  if (props.children.length === 0 && tail.trim().length === 0) return "";
+  const open = props.attrs ? `<${props.tag} ${props.attrs}>` : `<${props.tag}>`;
+  const inner = props.children.map((child) => (child.before ?? "") + child.xml).join("");
+  return open + inner + tail + `</${props.tag}>`;
+}
+function insertIndex(children, name, order, tag) {
+  const target = order.indexOf(name);
+  if (target === -1) {
+    throw new Error(
+      `${name} is not a child the order of ${tag} knows; add it to CHILD_ORDER`
+    );
+  }
+  const at = children.findIndex((child) => order.indexOf(child.name) > target);
+  return at === -1 ? children.length : at;
+}
+function dropChildren(children, name) {
+  const kept = [];
+  let carried = "";
+  for (const child of children) {
+    const before = carried + (child.before ?? "");
+    if (child.name === name) {
+      carried = before;
+      continue;
+    }
+    carried = "";
+    kept.push(
+      before === "" ? { name: child.name, xml: child.xml } : { ...child, before }
+    );
+  }
+  return { kept, carried };
+}
+function tailWith(props, carried) {
+  const tail = carried + (props.tail ?? "");
+  return tail === "" ? {} : { tail };
+}
+function setChild(props, name, xml, parent) {
+  const order = childOrderOf(localPart(props.tag), parent);
+  const at = props.children.findIndex((entry) => entry.name === name);
+  if (at !== -1 && xml !== null) {
+    const rest = dropChildren(props.children.slice(at + 1), name);
+    return {
+      ...props,
+      children: [
+        ...props.children.slice(0, at),
+        { ...props.children[at], xml },
+        ...rest.kept
+      ],
+      ...tailWith(props, rest.carried)
+    };
+  }
+  const { kept, carried } = dropChildren(props.children, name);
+  if (xml === null) {
+    return { ...props, children: kept, ...tailWith(props, carried) };
+  }
+  const index = insertIndex(kept, name, order, props.tag);
+  return {
+    ...props,
+    children: [...kept.slice(0, index), { name, xml }, ...kept.slice(index)],
+    ...tailWith(props, carried)
+  };
+}
+function propsChild(children, name) {
+  return children.find((child) => child.name === name);
+}
+function attrsOf(props) {
+  return props.attrs === null ? [] : parseAttrs(props.attrs);
+}
+function withAttrs(props, attrs) {
+  return { ...props, attrs: attrs.length === 0 ? null : attrsText(attrs) };
+}
+function childElement(props, name) {
+  const child = propsChild(props.children, name);
+  if (child === void 0) return { tag: null, attrs: [] };
+  const parsed = parseProps(child.xml);
+  const attrs = parsed === null ? null : attrsOf(parsed);
+  return parsed === null || attrs === null ? null : { tag: parsed.tag, attrs };
+}
+function renderElement(props) {
+  return renderProps(props) || emptyTagXml(props.tag, props.attrs);
+}
+function orderedElement(tag, attrs, children) {
+  const empty = withAttrs({ tag, attrs: null, children: [] }, attrs);
+  return renderElement(
+    children.reduce(
+      (props, child) => setChild(props, child.name, child.xml),
+      empty
+    )
+  );
+}
+function editPath(props, path, edit, parent) {
+  const [name, ...rest] = path;
+  const current = propsChild(props.children, name);
+  const parsed = current === void 0 ? null : parseProps(current.xml);
+  if (current !== void 0 && parsed === null) return null;
+  if (rest.length === 0) {
+    const next = edit(parsed);
+    return setChild(props, name, next && renderElement(next), parent);
+  }
+  const nested = editPath(
+    parsed ?? { tag: wName(name), attrs: null, children: [] },
+    rest,
+    edit,
+    localPart(props.tag)
+  );
+  if (nested === null) return null;
+  const rendered = renderProps(nested);
+  return setChild(props, name, rendered === "" ? null : rendered, parent);
+}
+function editChild(props, path, edit) {
+  return editPath(props, path, edit, void 0);
+}
+function parsePropsXml(xml) {
+  try {
+    const wrapped = `<props ${namespaceDecls(xml)}>${xml}</props>`;
+    return elementChildren(parseXml(wrapped).documentElement)[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+export {
+  attrsOf,
+  childElement,
+  editChild,
+  innerXml,
+  orderedElement,
+  parseProps,
+  parsePropsXml,
+  propsChild,
+  renderElement,
+  renderProps,
+  setChild,
+  withAttrs
+};

package/dist/ooxml/simpleTypes.d.ts

@@ -0,0 +1,103 @@
+/**
+ * The simple types the schema names, one `{parse, format}` pair each.
+ *
+ * A measurement in OOXML is a union rather than a count. `w:pgSz w:w` is either a number of twips
+ * or a universal measure such as `8.5in` (§22.9.2.14, §22.9.2.15), and reading only the leading
+ * digits turns Letter paper into a page 8.5 twips wide. A boolean is any of `1`, `0`, `true`,
+ * `false`, `on` and `off` (§17.17.4). Deciding either at the call site is how a document comes to
+ * be read one way in one reader and another way in the next, so both are decided here, and the
+ * writer that puts a value back reaches for the same pair.
+ *
+ * Readers accept the decimal counts some producers write in integer slots. `format` answers null
+ * for a value it cannot record; a caller that intends to round must do so before formatting.
+ */
+import { type TabAlignment, type TabLeader } from "../model/tabStops";
+export interface SimpleType<T> {
+    /** null for an absent or unreadable value; see the type's producer compatibility rules */
+    parse(value: string | null): T | null;
+    /** null for a value the type cannot record */
+    format(value: T): string | null;
+}
+/** A twip is a twentieth of a point */
+export declare const TWIPS_PER_PT = 20;
+export declare const TWIPS_PER_INCH = 1440;
+/** `w:sz` counts a font size in half-points, so 24 is 12pt */
+export declare const HALF_POINTS_PER_PT = 2;
+/** `w:sz` on a border counts its thickness in eighths of a point */
+export declare const EIGHTHS_PER_PT = 8;
+/**
+ * The largest font size a writer here records.
+ *
+ * The schema puts no ceiling on `w:sz`, but Word's own limit is 819pt, and a size beyond it is
+ * one no word processor will show back.
+ */
+export declare const MAX_FONT_SIZE_PT = 819;
+/** `8.5in` -> 12240. null for anything ST_UniversalMeasure does not admit (§22.9.2.15) */
+export declare function universalMeasureToTwips(value: string): number | null;
+/** Twips, unsigned (§22.9.2.14): `w:pgSz`, `w:trHeight`, `w:spacing/@before`, `w:tcMar` */
+export declare const ST_TwipsMeasure: SimpleType<number>;
+/** Twips, signed (§17.18.81): `w:ind`, `w:tab/@pos`, `w:spacing/@line` */
+export declare const ST_SignedTwipsMeasure: SimpleType<number>;
+/**
+ * Half-points (§17.18.42): `w:sz` and `w:szCs`.
+ *
+ * `format` refuses a size no writer here records: one off the half-point step the unit counts in,
+ * one of nothing at all, and one past `MAX_FONT_SIZE_PT`.
+ */
+export declare const ST_HpsMeasure: SimpleType<number>;
+/** Half-points, signed (§17.18.80): `w:position` */
+export declare const ST_SignedHpsMeasure: SimpleType<number>;
+/**
+ * Eighths of a point (§17.18.23): the thickness of a border side.
+ *
+ * Alone among the measurements this restricts `ST_UnsignedDecimalNumber` rather than uniting with a
+ * universal measure, so a thickness is a count and a unit written beside it is not one.
+ */
+export declare const ST_EighthPointMeasure: SimpleType<number>;
+/** A whole number, signed (§17.18.10): `w:numId`, `w:ilvl`, `w:start` */
+export declare const ST_DecimalNumber: SimpleType<number>;
+/** A whole number, unsigned (§22.9.2.16): `w:id` on a comment or a note */
+export declare const ST_UnsignedDecimalNumber: SimpleType<number>;
+/**
+ * A boolean (§17.17.4).
+ *
+ * The schema unites `xsd:boolean` with the pair `on` and `off`, so all six spellings say the same
+ * thing and nothing else says either. An element that carries no `w:val` at all is on, which is a
+ * rule about the element rather than about this value, so it is the caller that applies it.
+ */
+export declare const ST_OnOff: SimpleType<boolean>;
+/** A color, which is either six hex digits or the word `auto` (§17.18.38) */
+export type HexColor = {
+    kind: "auto";
+} | {
+    kind: "rgb";
+    hex: string;
+};
+/**
+ * `ST_HexColor` keeps the digits exactly as the document spelled them, so a color read and written
+ * back leaves the file as it was. A caller comparing two colors gathers them first.
+ */
+export declare const ST_HexColor: SimpleType<HexColor>;
+/**
+ * The width of a table or a cell (§17.18.107), which `w:type` beside it says how to read.
+ *
+ * `number` is the bare count, meaning twips under `dxa` and fiftieths of a percent under `pct`.
+ * `percent` carried its own `%`, and `twips` was written as a universal measure, which says an
+ * absolute width whatever `w:type` claims.
+ */
+export type MeasurementOrPercent = {
+    kind: "number";
+    value: number;
+} | {
+    kind: "percent";
+    value: number;
+} | {
+    kind: "twips";
+    value: number;
+};
+export declare const ST_MeasurementOrPercent: SimpleType<MeasurementOrPercent>;
+/** The kinds of custom tab stop, with the two Transitional spellings folded in */
+export type TabJc = TabAlignment | "bar" | "clear";
+export declare const ST_TabJc: SimpleType<TabJc>;
+/** The character a tab stop draws the space it covers with (§17.18.85) */
+export declare const ST_TabTlc: SimpleType<TabLeader>;

package/dist/ooxml/simpleTypes.js

@@ -0,0 +1,182 @@
+// src/ooxml/simpleTypes.ts
+import {
+  TAB_LEADERS,
+  TAB_STOP_ALIGNMENTS
+} from "../model/tabStops.js";
+var TWIPS_PER_PT = 20;
+var TWIPS_PER_INCH = 1440;
+var HALF_POINTS_PER_PT = 2;
+var EIGHTHS_PER_PT = 8;
+var MAX_FONT_SIZE_PT = 819;
+var TWIPS_PER_UNIT = {
+  mm: TWIPS_PER_INCH / 25.4,
+  cm: TWIPS_PER_INCH / 2.54,
+  in: TWIPS_PER_INCH,
+  pt: TWIPS_PER_PT,
+  pc: TWIPS_PER_PT * 12,
+  pi: TWIPS_PER_PT * 12
+};
+var UNIVERSAL_MEASURE = /^(-?[0-9]+(?:\.[0-9]+)?)(mm|cm|in|pt|pc|pi)$/;
+function universalMeasureToTwips(value) {
+  const matched = UNIVERSAL_MEASURE.exec(value.trim());
+  if (!matched) return null;
+  const amount = Number(matched[1]);
+  const twips = amount * TWIPS_PER_UNIT[matched[2]];
+  return Number.isFinite(twips) ? twips : null;
+}
+var DECIMAL_NUMBER = /^[+-]?[0-9]+(?:\.[0-9]+)?$/;
+function decimalNumber(value) {
+  const text = value.trim();
+  if (!DECIMAL_NUMBER.test(text)) return null;
+  const parsed = Number(text);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function measure({ twipsPerUnit, signed }) {
+  const admits = (value) => signed || value >= 0;
+  return {
+    parse(value) {
+      if (value === null) return null;
+      const counted = decimalNumber(value);
+      if (counted !== null) return admits(counted) ? counted : null;
+      const twips = universalMeasureToTwips(value);
+      if (twips === null) return null;
+      const converted = twips / twipsPerUnit;
+      return admits(converted) ? converted : null;
+    },
+    format(value) {
+      if (!Number.isSafeInteger(value) || !admits(value)) return null;
+      return `${value}`;
+    }
+  };
+}
+var ST_TwipsMeasure = measure({
+  twipsPerUnit: 1,
+  signed: false
+});
+var ST_SignedTwipsMeasure = measure({
+  twipsPerUnit: 1,
+  signed: true
+});
+var HPS_MEASURE = measure({
+  twipsPerUnit: TWIPS_PER_PT / HALF_POINTS_PER_PT,
+  signed: false
+});
+var ST_HpsMeasure = {
+  parse: HPS_MEASURE.parse,
+  format(value) {
+    if (value <= 0 || value > MAX_FONT_SIZE_PT * HALF_POINTS_PER_PT) {
+      return null;
+    }
+    return HPS_MEASURE.format(value);
+  }
+};
+var ST_SignedHpsMeasure = measure({
+  twipsPerUnit: TWIPS_PER_PT / HALF_POINTS_PER_PT,
+  signed: true
+});
+function wholeNumber(signed) {
+  const admits = (value) => signed || value >= 0;
+  return {
+    parse(value) {
+      if (value === null) return null;
+      const parsed = decimalNumber(value);
+      if (parsed === null) return null;
+      const whole = Math.trunc(parsed);
+      return Number.isSafeInteger(whole) && admits(whole) ? whole : null;
+    },
+    format(value) {
+      if (!Number.isSafeInteger(value) || !admits(value)) return null;
+      return `${value}`;
+    }
+  };
+}
+var ST_EighthPointMeasure = wholeNumber(false);
+var ST_DecimalNumber = wholeNumber(true);
+var ST_UnsignedDecimalNumber = wholeNumber(false);
+var ST_OnOff = {
+  parse(value) {
+    if (value === null) return null;
+    const text = value.trim();
+    if (text === "1" || text === "true" || text === "on") return true;
+    if (text === "0" || text === "false" || text === "off") return false;
+    return null;
+  },
+  format(value) {
+    return value ? "1" : "0";
+  }
+};
+var HEX_RGB = /^[0-9a-fA-F]{6}$/;
+var ST_HexColor = {
+  parse(value) {
+    if (value === null) return null;
+    if (value === "auto") return { kind: "auto" };
+    return HEX_RGB.test(value) ? { kind: "rgb", hex: value } : null;
+  },
+  format(value) {
+    return value.kind === "auto" ? "auto" : value.hex;
+  }
+};
+var PERCENT = /^(-?[0-9]+(?:\.[0-9]+)?)%$/;
+var ST_MeasurementOrPercent = {
+  parse(value) {
+    if (value === null) return null;
+    const text = value.trim();
+    const percent = PERCENT.exec(text);
+    if (percent) {
+      const amount = decimalNumber(percent[1]);
+      return amount === null ? null : { kind: "percent", value: amount };
+    }
+    const counted = decimalNumber(text);
+    if (counted !== null) return { kind: "number", value: counted };
+    const twips = universalMeasureToTwips(text);
+    return twips === null ? null : { kind: "twips", value: twips };
+  },
+  format(value) {
+    if (!Number.isFinite(value.value)) return null;
+    if (value.kind === "percent") return `${value.value}%`;
+    if (value.kind === "twips") return `${value.value / TWIPS_PER_PT}pt`;
+    return ST_DecimalNumber.format(value.value);
+  }
+};
+var TAB_JC_BY_VALUE = {
+  ...Object.fromEntries(TAB_STOP_ALIGNMENTS.map((align) => [align, align])),
+  clear: "clear",
+  left: "start",
+  right: "end"
+};
+var ST_TabJc = {
+  parse(value) {
+    return value !== null && Object.hasOwn(TAB_JC_BY_VALUE, value) ? TAB_JC_BY_VALUE[value] : null;
+  },
+  format(value) {
+    return value;
+  }
+};
+var ST_TabTlc = {
+  parse(value) {
+    return TAB_LEADERS.find((leader) => leader === value) ?? null;
+  },
+  format(value) {
+    return value;
+  }
+};
+export {
+  EIGHTHS_PER_PT,
+  HALF_POINTS_PER_PT,
+  MAX_FONT_SIZE_PT,
+  ST_DecimalNumber,
+  ST_EighthPointMeasure,
+  ST_HexColor,
+  ST_HpsMeasure,
+  ST_MeasurementOrPercent,
+  ST_OnOff,
+  ST_SignedHpsMeasure,
+  ST_SignedTwipsMeasure,
+  ST_TabJc,
+  ST_TabTlc,
+  ST_TwipsMeasure,
+  ST_UnsignedDecimalNumber,
+  TWIPS_PER_INCH,
+  TWIPS_PER_PT,
+  universalMeasureToTwips
+};

package/dist/ooxml/tabStops.js

@@ -1,28 +1,7 @@
 // src/ooxml/tabStops.ts
+import { ST_SignedTwipsMeasure, ST_TabJc, ST_TabTlc } from "./simpleTypes.js";
 import { twipsToPt, wAttr } from "./units.js";
 import { childByLocalName } from "./xml.js";
-var ALIGN_BY_VALUE = {
-  left: "start",
-  start: "start",
-  center: "center",
-  right: "end",
-  end: "end",
-  decimal: "decimal",
-  num: "num",
-  bar: "bar",
-  clear: "clear"
-};
-var LEADERS = /* @__PURE__ */ new Set([
-  "none",
-  "dot",
-  "hyphen",
-  "underscore",
-  "heavy",
-  "middleDot"
-]);
-function tabLeader(value) {
-  return value !== null && LEADERS.has(value) ? value : void 0;
-}
 function readTabStopDirectives(pPr) {
   if (!pPr) return [];
   const tabs = childByLocalName(pPr, "tabs");
@@ -30,18 +9,20 @@ function readTabStopDirectives(pPr) {
   const stops = [];
   for (const tab of Array.from(tabs.children)) {
     if (tab.localName !== "tab") continue;
-    const positionPt = twipsToPt(wAttr(tab, "pos"));
-    const align = ALIGN_BY_VALUE[wAttr(tab, "val") ?? ""];
-    if (positionPt === null || align === void 0) continue;
+    const positionPt = twipsToPt(
+      ST_SignedTwipsMeasure.parse(wAttr(tab, "pos"))
+    );
+    const align = ST_TabJc.parse(wAttr(tab, "val"));
+    if (positionPt === null || align === null) continue;
     if (align === "clear") {
       stops.push({ positionPt, align });
       continue;
     }
-    const leader = tabLeader(wAttr(tab, "leader"));
+    const leader = ST_TabTlc.parse(wAttr(tab, "leader"));
     stops.push({
       positionPt,
       align,
-      ...leader === void 0 ? {} : { leader }
+      ...leader === null ? {} : { leader }
     });
   }
   return stops;

package/dist/ooxml/tagScan.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Reading one tag out of a part or a fragment without parsing the whole of it.
+ *
+ * Everything the writers hold is text, and an edit slices one element or one attribute out of it,
+ * so the spots those slices run between have to be found in the text itself. A `>` may stand
+ * inside an attribute value and a `<` inside a comment, which is why a tag is read construct by
+ * construct rather than searched for.
+ */
+import type { XmlAttr } from "./element";
+export type TagKind = "open" | "close" | "empty" | "other";
+export interface Tag {
+    kind: TagKind;
+    /** The name exactly as written, prefix included. Empty for a construct that has none */
+    name: string;
+    /** The spot where the tag name ends. This is the start of the attribute string */
+    nameEnd: number;
+    /** The spot right after the tag ends */
+    end: number;
+}
+/** Reads a single tag starting at a `<`. null if it cannot be made out */
+export declare function readTag(source: string, lt: number): Tag | null;
+/**
+ * Where the root element's opening tag starts, past the prolog.
+ *
+ * The prolog is walked construct by construct so that a `<` inside a comment or a processing
+ * instruction is not taken for the root. -1 when the source holds no element at all.
+ */
+export declare function rootTagAt(xml: string): number;
+/**
+ * The attribute text of an opening tag as pairs, references decoded, each name spelled as it was
+ * written. null for a shape a parser would refuse: an unquoted value, a missing name, one name
+ * given twice, or a reference nothing declares.
+ */
+export declare function parseAttrs(raw: string): XmlAttr[] | null;

package/dist/ooxml/tagScan.js

@@ -0,0 +1,108 @@
+// src/ooxml/tagScan.ts
+function skipPast(source, from, marker) {
+  const at = source.indexOf(marker, from);
+  return at === -1 ? -1 : at + marker.length;
+}
+function otherTag(end) {
+  return end === -1 ? null : { kind: "other", name: "", nameEnd: end, end };
+}
+function readTag(source, lt) {
+  if (source.startsWith("<?", lt)) return otherTag(skipPast(source, lt, "?>"));
+  if (source.startsWith("<!--", lt))
+    return otherTag(skipPast(source, lt, "-->"));
+  if (source.startsWith("<![CDATA[", lt))
+    return otherTag(skipPast(source, lt, "]]>"));
+  if (source.startsWith("<!", lt)) return otherTag(skipPast(source, lt, ">"));
+  const closing = source.startsWith("</", lt);
+  let i = lt + (closing ? 2 : 1);
+  const nameStart = i;
+  while (i < source.length && !" 	\r\n/>".includes(source[i])) i += 1;
+  const name = source.slice(nameStart, i);
+  if (!name) return null;
+  const nameEnd = i;
+  let quote = null;
+  while (i < source.length) {
+    const ch = source[i];
+    if (quote !== null) {
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      const selfClosing = source[i - 1] === "/";
+      const kind = closing ? "close" : selfClosing ? "empty" : "open";
+      return { kind, name, nameEnd, end: i + 1 };
+    }
+    i += 1;
+  }
+  return null;
+}
+function rootTagAt(xml) {
+  let at = 0;
+  for (; ; ) {
+    const lt = xml.indexOf("<", at);
+    if (lt === -1) return -1;
+    const tag = readTag(xml, lt);
+    if (!tag) return -1;
+    if (tag.kind !== "other") return lt;
+    at = tag.end;
+  }
+}
+var ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+var HIGHEST_CODE_POINT = 1114111;
+function referenceText(name) {
+  const named = ENTITIES[name];
+  if (named !== void 0) return named;
+  const numeric = /^#(?:[xX]([0-9a-fA-F]+)|(\d+))$/.exec(name);
+  if (!numeric) return null;
+  const [, hex, decimal] = numeric;
+  const code = Number.parseInt(hex ?? decimal, hex === void 0 ? 10 : 16);
+  if (code > HIGHEST_CODE_POINT || code >= 55296 && code <= 57343) {
+    return null;
+  }
+  return String.fromCodePoint(code);
+}
+function decodeReferences(value) {
+  if (!value.includes("&")) return value;
+  let decoded = "";
+  let at = 0;
+  for (; ; ) {
+    const amp = value.indexOf("&", at);
+    if (amp === -1) return decoded + value.slice(at);
+    const semicolon = value.indexOf(";", amp);
+    if (semicolon === -1) return null;
+    const text = referenceText(value.slice(amp + 1, semicolon));
+    if (text === null) return null;
+    decoded += value.slice(at, amp) + text;
+    at = semicolon + 1;
+  }
+}
+var ATTRIBUTE = /(\s*)([^\s=/><"']+)\s*=\s*(?:"([^"<]*)"|'([^'<]*)')/y;
+function parseAttrs(raw) {
+  const attrs = [];
+  const names = /* @__PURE__ */ new Set();
+  let at = 0;
+  for (; ; ) {
+    ATTRIBUTE.lastIndex = at;
+    const matched = ATTRIBUTE.exec(raw);
+    if (!matched) return raw.slice(at).trim() === "" ? attrs : null;
+    const [, separator, name, doubled, singled] = matched;
+    if (at > 0 && separator === "") return null;
+    if (names.has(name)) return null;
+    names.add(name);
+    const value = decodeReferences(doubled ?? singled);
+    if (value === null) return null;
+    attrs.push([name, value]);
+    at = ATTRIBUTE.lastIndex;
+  }
+}
+export {
+  parseAttrs,
+  readTag,
+  rootTagAt
+};