@portone/docx-editor 0.2.1 → 0.3.0

package/dist/{docx/propsXml.js → ooxml/props.js}

@@ -1,185 +1,10 @@
-// src/docx/propsXml.ts
-import {
-  elementChildren,
-  localPart,
-  namespaceDecls,
-  parseXml
-} from "../ooxml/xml.js";
-var RUN_PR_ORDER = [
-  "rStyle",
-  "rFonts",
-  "b",
-  "bCs",
-  "i",
-  "iCs",
-  "caps",
-  "smallCaps",
-  "strike",
-  "dstrike",
-  "outline",
-  "shadow",
-  "emboss",
-  "imprint",
-  "noProof",
-  "snapToGrid",
-  "vanish",
-  "webHidden",
-  "color",
-  "spacing",
-  "w",
-  "kern",
-  "position",
-  "sz",
-  "szCs",
-  "highlight",
-  "u",
-  "effect",
-  "bdr",
-  "shd",
-  "fitText",
-  "vertAlign",
-  "rtl",
-  "cs",
-  "em",
-  "lang",
-  "eastAsianLayout",
-  "specVanish",
-  "oMath",
-  "rPrChange"
-];
-var P_PR_ORDER = [
-  "pStyle",
-  "keepNext",
-  "keepLines",
-  "pageBreakBefore",
-  "framePr",
-  "widowControl",
-  "numPr",
-  "suppressLineNumbers",
-  "pBdr",
-  "shd",
-  "tabs",
-  "suppressAutoHyphens",
-  "kinsoku",
-  "wordWrap",
-  "overflowPunct",
-  "topLinePunct",
-  "autoSpaceDE",
-  "autoSpaceDN",
-  "bidi",
-  "adjustRightInd",
-  "snapToGrid",
-  "spacing",
-  "ind",
-  "contextualSpacing",
-  "mirrorIndents",
-  "suppressOverlap",
-  "jc",
-  "textDirection",
-  "textAlignment",
-  "textboxTightWrap",
-  "outlineLvl",
-  "divId",
-  "cnfStyle",
-  "rPr",
-  "sectPr",
-  "pPrChange"
-];
-var TC_PR_ORDER = [
-  "cnfStyle",
-  "tcW",
-  "gridSpan",
-  "hMerge",
-  "vMerge",
-  "tcBorders",
-  "shd",
-  "noWrap",
-  "tcMar",
-  "textDirection",
-  "tcFitText",
-  "vAlign",
-  "hideMark",
-  "headers",
-  "cellIns",
-  "cellDel",
-  "cellMerge",
-  "tcPrChange"
-];
-var TR_PR_ORDER = [
-  "cnfStyle",
-  "divId",
-  "gridBefore",
-  "gridAfter",
-  "wBefore",
-  "wAfter",
-  "cantSplit",
-  "trHeight",
-  "tblHeader",
-  "tblCellSpacing",
-  "jc",
-  "hidden",
-  "ins",
-  "del",
-  "trPrChange"
-];
-var TBL_PR_ORDER = [
-  "tblStyle",
-  "tblpPr",
-  "tblOverlap",
-  "bidiVisual",
-  "tblStyleRowBandSize",
-  "tblStyleColBandSize",
-  "tblW",
-  "jc",
-  "tblCellSpacing",
-  "tblInd",
-  "tblBorders",
-  "shd",
-  "tblLayout",
-  "tblCellMar",
-  "tblLook",
-  "tblCaption",
-  "tblDescription",
-  "tblPrChange"
-];
-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 attrsOf(source, tag) {
+// 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;
@@ -193,7 +18,7 @@ function innerXml(xml) {
 function parseProps(xml) {
   const open = readTag(xml, 0);
   if (!open || xml[0] !== "<") return null;
-  const attrs = attrsOf(xml, open);
+  const attrs = rawAttrs(xml, open);
   if (open.kind === "empty") {
     return open.end === xml.length ? { tag: open.name, attrs, children: [] } : null;
   }
@@ -259,17 +84,15 @@ function renderProps(props) {
   const inner = props.children.map((child) => (child.before ?? "") + child.xml).join("");
   return open + inner + tail + `</${props.tag}>`;
 }
-function insertIndex(children, name, order) {
+function insertIndex(children, name, order, tag) {
   const target = order.indexOf(name);
-  if (target === -1) return children.length;
-  let previous = -1;
-  for (const [index, child] of children.entries()) {
-    const known = order.indexOf(child.name);
-    const effective = known === -1 ? previous : known;
-    if (effective > target) return index;
-    previous = effective;
+  if (target === -1) {
+    throw new Error(
+      `${name} is not a child the order of ${tag} knows; add it to CHILD_ORDER`
+    );
   }
-  return children.length;
+  const at = children.findIndex((child) => order.indexOf(child.name) > target);
+  return at === -1 ? children.length : at;
 }
 function dropChildren(children, name) {
   const kept = [];
@@ -291,7 +114,8 @@ function tailWith(props, carried) {
   const tail = carried + (props.tail ?? "");
   return tail === "" ? {} : { tail };
 }
-function setPropsChild(props, name, xml, order) {
+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);
@@ -309,7 +133,7 @@ function setPropsChild(props, name, xml, order) {
   if (xml === null) {
     return { ...props, children: kept, ...tailWith(props, carried) };
   }
-  const index = insertIndex(kept, name, order);
+  const index = insertIndex(kept, name, order, props.tag);
   return {
     ...props,
     children: [...kept.slice(0, index), { name, xml }, ...kept.slice(index)],
@@ -319,6 +143,53 @@ function setPropsChild(props, name, xml, order) {
 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>`;
@@ -328,15 +199,16 @@ function parsePropsXml(xml) {
   }
 }
 export {
-  P_PR_ORDER,
-  RUN_PR_ORDER,
-  TBL_PR_ORDER,
-  TC_PR_ORDER,
-  TR_PR_ORDER,
+  attrsOf,
+  childElement,
+  editChild,
   innerXml,
+  orderedElement,
   parseProps,
   parsePropsXml,
   propsChild,
+  renderElement,
   renderProps,
-  setPropsChild
+  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;