@pretextbook/remark-pretext 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,12 +1,214 @@
-import { unified as H } from "unified";
-import X from "remark-parse";
-import Z from "remark-directive";
-import { isTitlelessDivisionType as ce, isTopLevelDivisionType as V, divisionTypeAtRootDepth as ue, divisionTypeAtRelativeDepth as ae, isRootDivisionType as pe, rootChildDivision as M } from "@pretextbook/ptxast";
-import { visit as K } from "unist-util-visit";
-function fe(e, t = {}) {
+import { visit as V } from "unist-util-visit";
+import { unified as se } from "unified";
+import oe from "remark-parse";
+import _e from "remark-directive";
+import { getPtxSchemaChildElementNames as Ae, isPtxSchemaElementName as st, isTitlelessDivisionType as ot, isTopLevelDivisionType as Oe, divisionTypeAtRootDepth as lt, divisionTypeAtRelativeDepth as ct, isRootDivisionType as at, rootChildDivision as te } from "@pretextbook/ptxast";
+const Me = /([\w:.-]+)=(?:"([^"]*)"|'([^']*)'|([^\s"'{}]+))/g, ut = new RegExp(
+  String.raw`\s*\{#([\w:.-]+)((?:\s+${Me.source})*)\s*\}$`
+);
+function ht(e, t) {
+  const { start: n, end: i } = e.position ?? {}, r = t?.slice(n?.offset, i?.offset) ?? "";
+  return r[r.lastIndexOf("{") - 1] === "\\";
+}
+function ft(e, t) {
+  V(e, "heading", (n) => {
+    const i = n.children[n.children.length - 1];
+    if (i?.type !== "text") return;
+    const r = ut.exec(i.value);
+    if (!r || ht(n, t)) return;
+    const s = {};
+    for (const [, c, ...a] of r[2].matchAll(Me))
+      s[c] = a.find((h) => h !== void 0) ?? "";
+    n.data = {
+      ...n.data,
+      id: r[1],
+      attributes: s
+    }, i.value = i.value.slice(0, r.index), i.value || n.children.pop();
+  });
+}
+const pt = [
+  // Display math (check these first, before single $)
+  { open: "$$", close: "$$", isDisplay: !0 },
+  { open: "\\[", close: "\\]", isDisplay: !0 },
+  // Inline math
+  { open: "$", close: "$", isDisplay: !1 },
+  { open: "\\(", close: "\\)", isDisplay: !1 }
+], $e = "", Re = "", j = new RegExp(`${$e}\\d+${Re}`, "g"), be = /[\p{L}\p{N}]/u;
+function we(e, t) {
+  let n = 0;
+  for (let i = t - 1; i >= 0 && e[i] === "\\"; i--) n++;
+  return n % 2 === 1;
+}
+function dt(e, t) {
+  const n = e[t - 1] ?? "", i = e[t + 1] ?? "";
+  if (we(e, t) || n === "$" || i === "$" || be.test(n) || i === "" || /\s/.test(i)) return -1;
+  let r = e.indexOf("$", t + 1);
+  for (; r !== -1 && we(e, r); )
+    r = e.indexOf("$", r + 1);
+  if (r === -1) return -1;
+  const s = e.slice(t + 1, r);
+  return s.includes(`
+`) || s.includes("`") || /\s$/.test(s) || be.test(e[r + 1] ?? "") ? -1 : r;
+}
+function qe(e, t) {
+  let n = null;
+  for (const i of pt) {
+    let r = e.indexOf(i.open, t), s = -1;
+    for (; r !== -1 && (s = i.open === "$" ? dt(e, r) : e.indexOf(i.close, r + i.open.length), !(s !== -1 || i.open !== "$")); )
+      r = e.indexOf(i.open, r + 1);
+    if (!(r === -1 || s === -1) && (!n || r < n.index)) {
+      const c = e.substring(r + i.open.length, s);
+      n = { index: r, pattern: i, content: c };
+    }
+  }
+  return n;
+}
+function mt(e, t) {
+  let n = t;
+  for (; n < e.length; ) {
+    const i = e.indexOf("`", n);
+    if (i === -1) return null;
+    let r = 0, s = i;
+    for (; s < e.length && e[s] === "`"; )
+      r++, s++;
+    const c = "`".repeat(r);
+    let a = s;
+    for (; a < e.length; ) {
+      const h = e.indexOf(c, a);
+      if (h === -1) break;
+      const p = h + r;
+      if (p >= e.length || e[p] !== "`")
+        return { start: i, end: p };
+      a = h + 1;
+    }
+    n = i + r;
+  }
+  return null;
+}
+function Fe(e) {
+  const t = /* @__PURE__ */ new Map();
+  let n = "", i = 0, r = 0;
+  for (; i < e.length; ) {
+    const s = mt(e, i), c = qe(e, i);
+    if (s && (!c || s.start < c.index)) {
+      n += e.substring(i, s.end), i = s.end;
+      continue;
+    }
+    if (!c) {
+      n += e.substring(i);
+      break;
+    }
+    n += e.substring(i, c.index);
+    const a = `${$e}${r}${Re}`;
+    n += a;
+    const h = c.index + c.pattern.open.length + c.content.length + c.pattern.close.length;
+    t.set(a, {
+      type: "math",
+      value: c.content,
+      meta: c.pattern.isDisplay ? "display" : "inline",
+      source: e.substring(c.index, h)
+    }), i = h, r += 1;
+  }
+  return { markdown: n, tokens: t };
+}
+function gt(e) {
+  const t = [];
+  let n = 0;
+  for (; n < e.length; ) {
+    const i = qe(e, n);
+    if (!i) {
+      n < e.length && t.push({ type: "text", value: e.substring(n) });
+      break;
+    }
+    i.index > n && t.push({
+      type: "text",
+      value: e.substring(n, i.index)
+    }), t.push({
+      type: "math",
+      value: i.content,
+      meta: i.pattern.isDisplay ? "display" : "inline"
+    }), n = i.index + i.pattern.open.length + i.content.length + i.pattern.close.length;
+  }
+  return t.length === 0 ? [{ type: "text", value: e }] : t;
+}
+function yt(e, t) {
+  const n = [];
+  let i = 0;
+  j.lastIndex = 0;
+  let r = j.exec(e);
+  for (; r; ) {
+    const s = r.index, c = r[0];
+    s > i && n.push({ type: "text", value: e.substring(i, s) });
+    const a = t.get(c);
+    a ? n.push(a) : n.push({ type: "text", value: c }), i = s + c.length, r = j.exec(e);
+  }
+  return i < e.length && n.push({ type: "text", value: e.substring(i) }), n.length === 0 ? [{ type: "text", value: e }] : n;
+}
+function Pe(e, t) {
+  V(e, "text", (n, i, r) => {
+    if (!r || i === void 0) return;
+    const s = r.type === "paragraph" && !r.data?.directiveLabel, c = t(n.value).map(
+      (a) => a.type === "math" && !s ? { ...a, meta: "inline" } : a
+    );
+    return r.children.splice(i, 1, ...c), i + c.length;
+  });
+}
+function je(e) {
+  Pe(e, gt);
+}
+const vt = ["value", "url", "title", "alt"];
+function U(e, t) {
+  return e.replace(j, (n) => t.get(n)?.source ?? n);
+}
+function Xe(e, t) {
+  Pe(e, (n) => yt(n, t)), V(e, (n) => {
+    for (const i of vt)
+      typeof n[i] == "string" && (n[i] = U(n[i], t));
+    for (const [i, r] of Object.entries(n.attributes ?? {}))
+      typeof r == "string" && (n.attributes[i] = U(r, t));
+  });
+}
+const yi = () => (e) => {
+  je(e);
+}, bt = [
+  "blockQuote",
+  "codeFenced",
+  "codeIndented",
+  "definition",
+  "headingAtx",
+  "htmlFlow",
+  "list",
+  "setextUnderline",
+  "thematicBreak"
+];
+function wt() {
+  const e = this.data();
+  e.micromarkExtensions = e.micromarkExtensions?.map(
+    ({ text: t, ...n }) => n
+  );
+}
+function xt(e) {
+  const { markdown: t, tokens: n } = Fe(e), r = se().data("micromarkExtensions", [{ disable: { null: ["codeIndented"] } }]).use(oe).use(_e).use(wt).parse(t);
+  return Xe(r, n), {
+    tree: r,
+    source: t,
+    restoreSource: (s) => U(s, n)
+  };
+}
+function kt(e) {
+  const { markdown: t, tokens: n } = Fe(e);
+  for (const s of n.values()) s.meta = "inline";
+  const r = se().data("micromarkExtensions", [{ disable: { null: bt } }]).use(oe).parse(t);
+  return Xe(r, n), {
+    tree: r.children.flatMap((s) => s.children),
+    source: t,
+    restoreSource: (s) => U(s, n)
+  };
+}
+function Et(e, t = {}) {
   const n = {};
-  for (const [o, i] of Object.entries(t))
-    i != null && (n[o] = i);
+  for (const [i, r] of Object.entries(t))
+    r != null && (n[i] = r);
   return {
     type: "element",
     name: `plus:${e}`,
@@ -14,11 +216,1223 @@ function fe(e, t = {}) {
     children: []
   };
 }
-function he(e) {
+function Dt(e) {
   const t = e.name?.trim();
-  return t ? fe(t, e.attributes ?? {}) : null;
+  return t ? Et(t, e.attributes ?? {}) : null;
+}
+var ee, xe;
+function Tt() {
+  if (xe) return ee;
+  xe = 1;
+  var e = Object.defineProperty, t = Object.getOwnPropertyDescriptor, n = Object.getOwnPropertyNames, i = Object.prototype.hasOwnProperty, r = (l, o) => {
+    for (var u in o)
+      e(l, u, { get: o[u], enumerable: !0 });
+  }, s = (l, o, u, f) => {
+    if (o && typeof o == "object" || typeof o == "function")
+      for (let d of n(o))
+        !i.call(l, d) && d !== u && e(l, d, { get: () => o[d], enumerable: !(f = t(o, d)) || f.enumerable });
+    return l;
+  }, c = (l) => s(e({}, "__esModule", { value: !0 }), l), a = {};
+  r(a, {
+    XmlCdata: () => he,
+    XmlComment: () => fe,
+    XmlDeclaration: () => pe,
+    XmlDocument: () => de,
+    XmlDocumentType: () => me,
+    XmlElement: () => G,
+    XmlError: () => ge,
+    XmlNode: () => w,
+    XmlProcessingInstruction: () => K,
+    XmlText: () => Z,
+    parseXml: () => rt
+  }), ee = c(a);
+  var h = "", p = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g, m = class {
+    constructor(l) {
+      if (this.k = this.u(l, !0), this.d = 0, this.length = l.length, this.l = this.k !== this.length, this.h = l, this.l) {
+        let o = [];
+        for (let u = 0, f = 0; f < this.k; ++f)
+          o[f] = u, u += l.codePointAt(u) > 65535 ? 2 : 1;
+        this.A = o;
+      }
+    }
+    /**
+     * Whether the current character index is at the end of the input string.
+     */
+    get B() {
+      return this.d >= this.k;
+    }
+    // -- Protected Methods ------------------------------------------------------
+    /**
+     * Returns the number of characters in the given string, which may differ from
+     * the byte length if the string contains multibyte characters.
+     */
+    u(l, o = this.l) {
+      return o ? l.replace(p, "_").length : l.length;
+    }
+    // -- Public Methods ---------------------------------------------------------
+    /**
+     * Advances the scanner by the given number of characters, stopping if the end
+     * of the string is reached.
+     */
+    p(l = 1) {
+      this.d = Math.min(this.k, this.d + l);
+    }
+    /**
+     * Returns the byte index of the given character index in the string. The two
+     * may differ in strings that contain multibyte characters.
+     */
+    f(l = this.d) {
+      var o;
+      return this.l ? (o = this.A[l]) != null ? o : 1 / 0 : l;
+    }
+    /**
+     * Consumes and returns the given number of characters if possible, advancing
+     * the scanner and stopping if the end of the string is reached.
+     *
+     * If no characters could be consumed, an empty string will be returned.
+     */
+    G(l = 1) {
+      let o = this.m(l);
+      return this.p(l), o;
+    }
+    /**
+     * Consumes and returns the given number of bytes if possible, advancing the
+     * scanner and stopping if the end of the string is reached.
+     *
+     * It's up to the caller to ensure that the given byte count doesn't split a
+     * multibyte character.
+     *
+     * If no bytes could be consumed, an empty string will be returned.
+     */
+    v(l) {
+      let o = this.f(), u = this.h.slice(o, o + l);
+      return this.p(this.u(u)), u;
+    }
+    /**
+     * Consumes and returns all characters for which the given function returns
+     * `true`, stopping when `false` is returned or the end of the input is
+     * reached.
+     */
+    w(l) {
+      let { length: o, l: u, h: f } = this, d = this.f(), y = d;
+      if (u)
+        for (; y < o; ) {
+          let E = f[y], C = E >= "\uD800" && E <= "\uDBFF";
+          if (C && (E += f[y + 1]), !l(E))
+            break;
+          y += C ? 2 : 1;
+        }
+      else
+        for (; y < o && l(f[y]); )
+          ++y;
+      return this.v(y - d);
+    }
+    /**
+     * Consumes the given string if it exists at the current character index, and
+     * advances the scanner.
+     *
+     * If the given string doesn't exist at the current character index, an empty
+     * string will be returned and the scanner will not be advanced.
+     */
+    b(l) {
+      let { length: o } = l, u = this.f();
+      return l === this.h.slice(u, u + o) ? (this.p(o === 1 ? 1 : this.u(l)), l) : h;
+    }
+    /**
+     * Consumes characters until the given global regex is matched, advancing the
+     * scanner up to (but not beyond) the beginning of the match. If the regex
+     * doesn't match, nothing will be consumed.
+     *
+     * Returns the consumed string, or an empty string if nothing was consumed.
+     */
+    x(l) {
+      let o = this.h.slice(this.f()).search(l);
+      return o > 0 ? this.v(o) : h;
+    }
+    /**
+     * Consumes characters until the given string is found, advancing the scanner
+     * up to (but not beyond) that point. If the string is never found, nothing
+     * will be consumed.
+     *
+     * Returns the consumed string, or an empty string if nothing was consumed.
+     */
+    s(l) {
+      let o = this.f(), u = this.h.indexOf(l, o);
+      return u > 0 ? this.v(u - o) : h;
+    }
+    /**
+     * Returns the given number of characters starting at the current character
+     * index, without advancing the scanner and without exceeding the end of the
+     * input string.
+     */
+    m(l = 1) {
+      let { d: o, h: u } = this;
+      return this.l ? u.slice(this.f(o), this.f(o + l)) : u.slice(o, o + l);
+    }
+    /**
+     * Resets the scanner position to the given character _index_, or to the start
+     * of the input string if no index is given.
+     *
+     * If _index_ is negative, the scanner position will be moved backward by that
+     * many characters, stopping if the beginning of the string is reached.
+     */
+    n(l = 0) {
+      this.d = l >= 0 ? Math.min(this.k, l) : Math.max(0, this.d + l);
+    }
+  }, g = /["&<]/, x = /['&<]/, T = /\r\n|[\n\r\t]/g, D = /<|&|]]>/, L = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
+    amp: "&",
+    apos: "'",
+    gt: ">",
+    lt: "<",
+    quot: '"'
+  }));
+  function v(l) {
+    let o = l.codePointAt(0);
+    return o >= 97 && o <= 122 || o >= 65 && o <= 90 || o >= 48 && o <= 57 || o === 45 || o === 46 || o === 183 || o >= 768 && o <= 879 || o === 8255 || o === 8256 || b(l, o);
+  }
+  function b(l, o = l.codePointAt(0)) {
+    return o >= 97 && o <= 122 || o >= 65 && o <= 90 || o === 58 || o === 95 || o >= 192 && o <= 214 || o >= 216 && o <= 246 || o >= 248 && o <= 767 || o >= 880 && o <= 893 || o >= 895 && o <= 8191 || o === 8204 || o === 8205 || o >= 8304 && o <= 8591 || o >= 11264 && o <= 12271 || o >= 12289 && o <= 55295 || o >= 63744 && o <= 64975 || o >= 65008 && o <= 65533 || o >= 65536 && o <= 983039;
+  }
+  function ae(l) {
+    return l === "#" || v(l);
+  }
+  function nt(l) {
+    let o = l.codePointAt(0);
+    return o === 32 || o === 9 || o === 10 || o === 13;
+  }
+  function ue(l) {
+    return l >= 32 && l <= 55295 || l === 10 || l === 9 || l === 13 || l >= 57344 && l <= 65533 || l >= 65536 && l <= 1114111;
+  }
+  var S = class Be {
+    constructor() {
+      this.parent = null, this.start = -1, this.end = -1;
+    }
+    /**
+     * Document that contains this node, or `null` if this node is not associated
+     * with a document.
+     */
+    get document() {
+      var o, u;
+      return (u = (o = this.parent) == null ? void 0 : o.document) != null ? u : null;
+    }
+    /**
+     * Whether this node is the root node of the document (also known as the
+     * document element).
+     */
+    get isRootNode() {
+      return this.parent !== null && this.parent === this.document && this.type === Be.TYPE_ELEMENT;
+    }
+    /**
+     * Whether whitespace should be preserved in the content of this element and
+     * its children.
+     *
+     * This is influenced by the value of the special `xml:space` attribute, and
+     * will be `true` for any node whose `xml:space` attribute is set to
+     * "preserve". If a node has no such attribute, it will inherit the value of
+     * the nearest ancestor that does (if any).
+     *
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-white-space
+     */
+    get preserveWhitespace() {
+      var o;
+      return !!((o = this.parent) != null && o.preserveWhitespace);
+    }
+    /**
+     * Type of this node.
+     *
+     * The value of this property is a string that matches one of the static
+     * `TYPE_*` properties on the `XmlNode` class (e.g. `TYPE_ELEMENT`,
+     * `TYPE_TEXT`, etc.).
+     *
+     * The `XmlNode` class itself is a base class and doesn't have its own type
+     * name.
+     */
+    get type() {
+      return "";
+    }
+    /**
+     * Returns a JSON-serializable object representing this node, minus properties
+     * that could result in circular references.
+     */
+    toJSON() {
+      let o = {
+        type: this.type
+      };
+      return this.isRootNode && (o.isRootNode = !0), this.preserveWhitespace && (o.preserveWhitespace = !0), this.start !== -1 && (o.start = this.start, o.end = this.end), o;
+    }
+  };
+  S.TYPE_CDATA = "cdata", S.TYPE_COMMENT = "comment", S.TYPE_DOCUMENT = "document", S.TYPE_DOCUMENT_TYPE = "doctype", S.TYPE_ELEMENT = "element", S.TYPE_PROCESSING_INSTRUCTION = "pi", S.TYPE_TEXT = "text", S.TYPE_XML_DECLARATION = "xmldecl";
+  var w = S, Z = class extends w {
+    constructor(l = "") {
+      super(), this.text = l;
+    }
+    get type() {
+      return w.TYPE_TEXT;
+    }
+    toJSON() {
+      return Object.assign(w.prototype.toJSON.call(this), {
+        text: this.text
+      });
+    }
+  }, he = class extends Z {
+    get type() {
+      return w.TYPE_CDATA;
+    }
+  }, fe = class extends w {
+    constructor(l = "") {
+      super(), this.content = l;
+    }
+    get type() {
+      return w.TYPE_COMMENT;
+    }
+    toJSON() {
+      return Object.assign(w.prototype.toJSON.call(this), {
+        content: this.content
+      });
+    }
+  }, pe = class extends w {
+    constructor(l, o, u) {
+      super(), this.version = l, this.encoding = o ?? null, this.standalone = u ?? null;
+    }
+    get type() {
+      return w.TYPE_XML_DECLARATION;
+    }
+    toJSON() {
+      let l = w.prototype.toJSON.call(this);
+      l.version = this.version;
+      for (let o of ["encoding", "standalone"])
+        this[o] !== null && (l[o] = this[o]);
+      return l;
+    }
+  }, G = class Ue extends w {
+    constructor(o, u = /* @__PURE__ */ Object.create(null), f = []) {
+      super(), this.name = o, this.attributes = u, this.children = f;
+    }
+    /**
+     * Whether this element is empty (meaning it has no children).
+     */
+    get isEmpty() {
+      return this.children.length === 0;
+    }
+    get preserveWhitespace() {
+      let o = this;
+      for (; o instanceof Ue; ) {
+        if ("xml:space" in o.attributes)
+          return o.attributes["xml:space"] === "preserve";
+        o = o.parent;
+      }
+      return !1;
+    }
+    /**
+     * Text content of this element and all its descendants.
+     */
+    get text() {
+      return this.children.map((o) => "text" in o ? o.text : "").join("");
+    }
+    get type() {
+      return w.TYPE_ELEMENT;
+    }
+    toJSON() {
+      return Object.assign(w.prototype.toJSON.call(this), {
+        name: this.name,
+        attributes: this.attributes,
+        children: this.children.map((o) => o.toJSON())
+      });
+    }
+  }, de = class extends w {
+    constructor(l = []) {
+      super(), this.children = l;
+    }
+    get document() {
+      return this;
+    }
+    /**
+     * Root element of this document, or `null` if this document is empty.
+     */
+    get root() {
+      for (let l of this.children)
+        if (l instanceof G)
+          return l;
+      return null;
+    }
+    /**
+     * Text content of this document and all its descendants.
+     */
+    get text() {
+      return this.children.map((l) => "text" in l ? l.text : "").join("");
+    }
+    get type() {
+      return w.TYPE_DOCUMENT;
+    }
+    toJSON() {
+      return Object.assign(w.prototype.toJSON.call(this), {
+        children: this.children.map((l) => l.toJSON())
+      });
+    }
+  }, me = class extends w {
+    constructor(l, o, u, f) {
+      super(), this.name = l, this.publicId = o ?? null, this.systemId = u ?? null, this.internalSubset = f ?? null;
+    }
+    get type() {
+      return w.TYPE_DOCUMENT_TYPE;
+    }
+    toJSON() {
+      let l = w.prototype.toJSON.call(this);
+      l.name = this.name;
+      for (let o of ["publicId", "systemId", "internalSubset"])
+        this[o] !== null && (l[o] = this[o]);
+      return l;
+    }
+  }, ge = class extends Error {
+    constructor(l, o, u) {
+      let f = 1, d = "", y = 1;
+      for (let Q = 0; Q < o; ++Q) {
+        let ve = u[Q];
+        ve === `
+` ? (f = 1, d = "", y += 1) : (f += 1, d += ve);
+      }
+      let E = u.indexOf(`
+`, o);
+      d += E === -1 ? u.slice(o) : u.slice(o, E);
+      let C = 0;
+      d.length > 50 && (f < 40 ? d = d.slice(0, 50) : (C = f - 20, d = d.slice(C, f + 30))), super(
+        `${l} (line ${y}, column ${f})
+  ${d}
+` + " ".repeat(f - C + 1) + `^
+`
+      ), this.column = f, this.excerpt = d, this.line = y, this.name = "XmlError", this.pos = o;
+    }
+  }, K = class extends w {
+    constructor(l, o = "") {
+      super(), this.name = l, this.content = o;
+    }
+    get type() {
+      return w.TYPE_PROCESSING_INSTRUCTION;
+    }
+    toJSON() {
+      return Object.assign(w.prototype.toJSON.call(this), {
+        name: this.name,
+        content: this.content
+      });
+    }
+  }, ye = "", it = class {
+    /**
+     * @param xml XML string to parse.
+     * @param options Parser options.
+     */
+    constructor(l, o = {}) {
+      let u = this.document = new de();
+      this.j = u, this.g = o, this.c = new m(l), this.g.includeOffsets && (u.start = 0, u.end = l.length), this.parse();
+    }
+    /**
+     * Adds the given `XmlNode` as a child of `this.currentNode`.
+     */
+    i(l, o) {
+      return l.parent = this.j, this.g.includeOffsets && (l.start = this.c.f(o), l.end = this.c.f()), this.j.children.push(l), !0;
+    }
+    /**
+     * Adds the given _text_ to the document, either by appending it to a
+     * preceding `XmlText` node (if possible) or by creating a new `XmlText` node.
+     *
+     * When _normalize_ is `true` (the default), line breaks in _text_ are
+     * normalized per section 2.11 of the XML spec. This must be `false` for text
+     * that comes from a character or entity reference, since references aren't
+     * subject to line break normalization.
+     */
+    y(l, o, u = !0) {
+      let { children: f } = this.j, { length: d } = f;
+      if (u && (l = F(l)), d > 0) {
+        let y = f[d - 1];
+        if (y?.type === w.TYPE_TEXT) {
+          let E = y;
+          return E.text += l, this.g.includeOffsets && (E.end = this.c.f()), !0;
+        }
+      }
+      return this.i(new Z(l), o);
+    }
+    /**
+     * Consumes element attributes.
+     *
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-starttags
+     */
+    H() {
+      let l = /* @__PURE__ */ Object.create(null);
+      for (; this.e(); ) {
+        let o = this.q();
+        if (!o)
+          break;
+        let u = this.t() && this.I();
+        if (u === !1)
+          throw this.a("Attribute value expected");
+        if (o in l)
+          throw this.a(`Duplicate attribute: ${o}`);
+        if (o === "xml:space" && u !== "default" && u !== "preserve")
+          throw this.a('Value of the `xml:space` attribute must be "default" or "preserve"');
+        l[o] = u;
+      }
+      if (this.g.sortAttributes) {
+        let o = Object.keys(l).sort(), u = /* @__PURE__ */ Object.create(null);
+        for (let f = 0; f < o.length; ++f) {
+          let d = o[f];
+          u[d] = l[d];
+        }
+        l = u;
+      }
+      return l;
+    }
+    /**
+     * Consumes an `AttValue` (attribute value) if possible.
+     *
+     * @returns
+     *   Contents of the `AttValue` minus quotes, or `false` if nothing was
+     *   consumed. An empty string indicates that an `AttValue` was consumed but
+     *   was empty.
+     *
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-AttValue
+     */
+    I() {
+      let { c: l } = this, o = l.m();
+      if (o !== '"' && o !== "'")
+        return !1;
+      l.p();
+      let u, f = !1, d = ye, y = o === '"' ? g : x;
+      e: for (; !l.B; )
+        switch (u = l.x(y), u && (this.o(u), d += u.replace(T, " ")), l.m()) {
+          case o:
+            f = !0;
+            break e;
+          case "&":
+            d += this.C();
+            continue;
+          case "<":
+            throw this.a("Unescaped `<` is not allowed in an attribute value");
+          default:
+            break e;
+        }
+      if (!f)
+        throw this.a("Unclosed attribute");
+      return l.p(), d;
+    }
+    /**
+     * Consumes a CDATA section if possible.
+     *
+     * @returns Whether a CDATA section was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-cdata-sect
+     */
+    J() {
+      let { c: l } = this, o = l.d;
+      if (!l.b("<![CDATA["))
+        return !1;
+      let u = l.s("]]>");
+      if (this.o(u), !l.b("]]>"))
+        throw this.a("Unclosed CDATA section");
+      return this.g.preserveCdata ? this.i(new he(F(u)), o) : this.y(u, o);
+    }
+    /**
+     * Consumes character data if possible.
+     *
+     * @returns Whether character data was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#dt-chardata
+     */
+    K() {
+      let { c: l } = this, o = l.d, u = l.x(D);
+      if (!u)
+        return !1;
+      if (this.o(u), l.m(3) === "]]>")
+        throw this.a("Element content may not contain the CDATA section close delimiter `]]>`");
+      return this.y(u, o);
+    }
+    /**
+     * Consumes a comment if possible.
+     *
+     * @returns Whether a comment was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Comment
+     */
+    D() {
+      let { c: l } = this, o = l.d;
+      if (!l.b("<!--"))
+        return !1;
+      let u = l.s("--");
+      if (this.o(u), !l.b("-->"))
+        throw l.m(2) === "--" ? this.a("The string `--` isn't allowed inside a comment") : this.a("Unclosed comment");
+      return this.g.preserveComments ? this.i(new fe(F(u)), o) : !0;
+    }
+    /**
+     * Consumes a reference in a content context if possible.
+     *
+     * This differs from `consumeReference()` in that a consumed reference will be
+     * added to the document as a text node instead of returned.
+     *
+     * @returns Whether a reference was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#entproc
+     */
+    L() {
+      let l = this.c.d, o = this.C();
+      return o ? this.y(o, l, !1) : !1;
+    }
+    /**
+     * Consumes a doctype declaration if possible.
+     *
+     * This is a loose implementation since doctype declarations are currently
+     * discarded without further parsing.
+     *
+     * @returns Whether a doctype declaration was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#dtd
+     */
+    M() {
+      let { c: l } = this, o = l.d;
+      if (!l.b("<!DOCTYPE"))
+        return !1;
+      let u = this.e() && this.q();
+      if (!u)
+        throw this.a("Expected a name");
+      let f, d;
+      if (this.e()) {
+        if (l.b("PUBLIC")) {
+          if (f = this.e() && this.N(), f === !1)
+            throw this.a("Expected a public identifier");
+          this.e();
+        }
+        if (f !== void 0 || l.b("SYSTEM")) {
+          if (this.e(), d = this.r(), d === !1)
+            throw this.a("Expected a system identifier");
+          this.e();
+        }
+      }
+      let y;
+      if (l.b("[")) {
+        if (y = l.x(/\][\x20\t\r\n]*>/), !l.b("]"))
+          throw this.a("Unclosed internal subset");
+        this.e();
+      }
+      if (!l.b(">"))
+        throw this.a("Unclosed doctype declaration");
+      return this.g.preserveDocumentType ? this.i(new me(u, f, d, y), o) : !0;
+    }
+    /**
+     * Consumes an element if possible.
+     *
+     * @returns Whether an element was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-element
+     */
+    E() {
+      let { c: l } = this, o = l.d;
+      if (!l.b("<"))
+        return !1;
+      let u = this.q();
+      if (!u)
+        return l.n(o), !1;
+      let f = this.H(), d = !!l.b("/>"), y = new G(u, f);
+      if (y.parent = this.j, !d) {
+        if (!l.b(">"))
+          throw this.a(`Unclosed start tag for element \`${u}\``);
+        this.j = y;
+        do
+          this.K();
+        while (this.E() || this.L() || this.J() || this.F() || this.D());
+        let E = l.d, C;
+        if (!l.b("</") || !(C = this.q()) || C !== u)
+          throw l.n(E), this.a(`Missing end tag for element ${u}`);
+        if (this.e(), !l.b(">"))
+          throw this.a(`Unclosed end tag for element ${u}`);
+        this.j = y.parent;
+      }
+      return this.i(y, o);
+    }
+    /**
+     * Consumes an `Eq` production if possible.
+     *
+     * @returns Whether an `Eq` production was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Eq
+     */
+    t() {
+      return this.e(), this.c.b("=") ? (this.e(), !0) : !1;
+    }
+    /**
+     * Consumes `Misc` content if possible.
+     *
+     * @returns Whether anything was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Misc
+     */
+    z() {
+      return this.D() || this.F() || this.e();
+    }
+    /**
+     * Consumes one or more `Name` characters if possible.
+     *
+     * @returns `Name` characters, or an empty string if none were consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Name
+     */
+    q() {
+      return b(this.c.m()) ? this.c.w(v) : ye;
+    }
+    /**
+     * Consumes a processing instruction if possible.
+     *
+     * @returns Whether a processing instruction was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-pi
+     */
+    F() {
+      let { c: l } = this, o = l.d;
+      if (!l.b("<?"))
+        return !1;
+      let u = this.q();
+      if (u) {
+        if (u.toLowerCase() === "xml")
+          throw l.n(o), this.a("XML declaration isn't allowed here");
+      } else
+        throw this.a("Invalid processing instruction");
+      if (!this.e()) {
+        if (l.b("?>"))
+          return this.i(new K(u), o);
+        throw this.a("Whitespace is required after a processing instruction name");
+      }
+      let f = l.s("?>");
+      if (this.o(f), !l.b("?>"))
+        throw this.a("Unterminated processing instruction");
+      return this.i(new K(u, F(f)), o);
+    }
+    /**
+     * Consumes a prolog if possible.
+     *
+     * @returns Whether a prolog was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-prolog-dtd
+     */
+    O() {
+      let { c: l } = this, o = l.d;
+      for (this.P(); this.z(); )
+        ;
+      if (this.M())
+        for (; this.z(); )
+          ;
+      return o < l.d;
+    }
+    /**
+     * Consumes a public identifier literal if possible.
+     *
+     * @returns
+     *   Value of the public identifier literal minus quotes, or `false` if
+     *   nothing was consumed. An empty string indicates that a public id literal
+     *   was consumed but was empty.
+     *
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-PubidLiteral
+     */
+    N() {
+      let l = this.c.d, o = this.r();
+      if (o !== !1 && !/^[-\x20\r\na-zA-Z0-9'()+,./:=?;!*#@$_%]*$/.test(o))
+        throw this.c.n(l), this.a("Invalid character in public identifier");
+      return o;
+    }
+    /**
+     * Consumes a reference if possible.
+     *
+     * This differs from `consumeContentReference()` in that a consumed reference
+     * will be returned rather than added to the document.
+     *
+     * @returns
+     *   Parsed reference value, or `false` if nothing was consumed (to
+     *   distinguish from a reference that resolves to an empty string).
+     *
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Reference
+     */
+    C() {
+      let { c: l } = this;
+      if (!l.b("&"))
+        return !1;
+      let o = l.w(ae);
+      if (l.G() !== ";")
+        throw this.a("Unterminated reference (a reference must end with `;`)");
+      let u;
+      if (o[0] === "#") {
+        let f = o[1] === "x" ? parseInt(o.slice(2), 16) : parseInt(o.slice(1), 10);
+        if (isNaN(f) || !/^#(?:x[0-9A-Fa-f]+|[0-9]+)$/.test(o))
+          throw this.a("Invalid character reference");
+        if (!ue(f))
+          throw this.a("Character reference resolves to an invalid character");
+        u = String.fromCodePoint(f);
+      } else if (u = L[o], u === void 0) {
+        let {
+          ignoreUndefinedEntities: f,
+          resolveUndefinedEntity: d
+        } = this.g, y = `&${o};`;
+        if (d) {
+          let E = d(y);
+          if (E != null) {
+            let C = typeof E;
+            if (C !== "string")
+              throw new TypeError(`\`resolveUndefinedEntity()\` must return a string, \`null\`, or \`undefined\`, but returned a value of type ${C}`);
+            return E;
+          }
+        }
+        if (f)
+          return y;
+        throw l.n(-y.length), this.a(`Named entity isn't defined: ${y}`);
+      }
+      return u;
+    }
+    /**
+     * Consumes a `SystemLiteral` if possible.
+     *
+     * A `SystemLiteral` is similar to an attribute value, but allows the
+     * characters `<` and `&` and doesn't replace references.
+     *
+     * @returns
+     *   Value of the `SystemLiteral` minus quotes, or `false` if nothing was
+     *   consumed. An empty string indicates that a `SystemLiteral` was consumed
+     *   but was empty.
+     *
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-SystemLiteral
+     */
+    r() {
+      let { c: l } = this, o = l.b('"') || l.b("'");
+      if (!o)
+        return !1;
+      let u = l.s(o);
+      if (this.o(u), !l.b(o))
+        throw this.a("Missing end quote");
+      return u;
+    }
+    /**
+     * Consumes one or more whitespace characters if possible.
+     *
+     * @returns Whether any whitespace characters were consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#white
+     */
+    e() {
+      return !!this.c.w(nt);
+    }
+    /**
+     * Consumes an XML declaration if possible.
+     *
+     * @returns Whether an XML declaration was consumed.
+     * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-XMLDecl
+     */
+    P() {
+      let { c: l } = this, o = l.d;
+      if (!l.b("<?xml"))
+        return !1;
+      if (!this.e())
+        throw this.a("Invalid XML declaration");
+      let u = !!l.b("version") && this.t() && this.r();
+      if (u === !1)
+        throw this.a("XML version is missing or invalid");
+      if (!/^1\.[0-9]+$/.test(u))
+        throw this.a("Invalid character in version number");
+      let f, d;
+      if (this.e()) {
+        if (f = !!l.b("encoding") && this.t() && this.r(), f) {
+          if (!/^[A-Za-z][\w.-]*$/.test(f))
+            throw this.a("Invalid character in encoding name");
+          this.e();
+        }
+        if (d = !!l.b("standalone") && this.t() && this.r(), d) {
+          if (d !== "yes" && d !== "no")
+            throw this.a('Only "yes" and "no" are permitted as values of `standalone`');
+          this.e();
+        }
+      }
+      if (!l.b("?>"))
+        throw this.a("Invalid or unclosed XML declaration");
+      return this.g.preserveXmlDeclaration ? this.i(new pe(
+        u,
+        f || void 0,
+        d || void 0
+      ), o) : !0;
+    }
+    /**
+     * Returns an `XmlError` for the current scanner position.
+     */
+    a(l) {
+      let { c: o } = this;
+      return new ge(l, o.d, o.h);
+    }
+    /**
+     * Parses the XML input.
+     */
+    parse() {
+      if (this.c.b("\uFEFF"), this.O(), !this.E())
+        throw this.a("Root element is missing or invalid");
+      for (; this.z(); )
+        ;
+      if (!this.c.B)
+        throw this.a("Extra content at the end of the document");
+    }
+    /**
+     * Throws an invalid character error if any character in the given _string_
+     * isn't a valid XML character.
+     */
+    o(l) {
+      let { length: o } = l;
+      for (let u = 0; u < o; ++u) {
+        let f = l.codePointAt(u);
+        if (!ue(f))
+          throw this.c.n(-([...l].length - u)), this.a("Invalid character");
+        f > 65535 && (u += 1);
+      }
+    }
+  };
+  function F(l) {
+    let o = 0;
+    for (; (o = l.indexOf("\r", o)) !== -1; )
+      l = l[o + 1] === `
+` ? l.slice(0, o) + l.slice(o + 1) : l.slice(0, o) + `
+` + l.slice(o + 1);
+    return l;
+  }
+  function rt(l, o) {
+    return new it(l, o).document;
+  }
+  return ee;
+}
+var It = Tt();
+function Ct(e) {
+  const t = String(e), n = [];
+  return { toOffset: r, toPoint: i };
+  function i(s) {
+    if (typeof s == "number" && s > -1 && s <= t.length) {
+      let c = 0;
+      for (; ; ) {
+        let a = n[c];
+        if (a === void 0) {
+          const h = ke(t, n[c - 1]);
+          a = h === -1 ? t.length + 1 : h + 1, n[c] = a;
+        }
+        if (a > s)
+          return {
+            line: c + 1,
+            column: s - (c > 0 ? n[c - 1] : 0) + 1,
+            offset: s
+          };
+        c++;
+      }
+    }
+  }
+  function r(s) {
+    if (s && typeof s.line == "number" && typeof s.column == "number" && !Number.isNaN(s.line) && !Number.isNaN(s.column)) {
+      for (; n.length < s.line; ) {
+        const a = n[n.length - 1], h = ke(t, a), p = h === -1 ? t.length + 1 : h + 1;
+        if (a === p) break;
+        n.push(p);
+      }
+      const c = (s.line > 1 ? n[s.line - 2] : 0) + s.column - 1;
+      if (c < n[s.line - 1]) return c;
+    }
+  }
+}
+function ke(e, t) {
+  const n = e.indexOf("\r", t), i = e.indexOf(`
+`, t);
+  return i === -1 ? n : n === -1 || n + 1 === i ? i : n < i ? n : i;
 }
-const $ = {
+function St(e) {
+  return !e || typeof e != "object" ? "" : "position" in e || "type" in e ? Ee(e.position) : "start" in e || "end" in e ? Ee(e) : "line" in e || "column" in e ? ne(e) : "";
+}
+function ne(e) {
+  return De(e && e.line) + ":" + De(e && e.column);
+}
+function Ee(e) {
+  return ne(e && e.start) + "-" + ne(e && e.end);
+}
+function De(e) {
+  return e && typeof e == "number" ? e : 1;
+}
+class I extends Error {
+  /**
+   * Create a message for `reason`.
+   *
+   * > 🪦 **Note**: also has obsolete signatures.
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Options | null | undefined} [options]
+   * @returns
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {string} reason
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @param {Error | VFileMessage | string} causeOrReason
+   *   Reason for message, should use markdown.
+   * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+   *   Configuration (optional).
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns
+   *   Instance of `VFileMessage`.
+   */
+  // eslint-disable-next-line complexity
+  constructor(t, n, i) {
+    super(), typeof n == "string" && (i = n, n = void 0);
+    let r = "", s = {}, c = !1;
+    if (n && ("line" in n && "column" in n ? s = { place: n } : "start" in n && "end" in n ? s = { place: n } : "type" in n ? s = {
+      ancestors: [n],
+      place: n.position
+    } : s = { ...n }), typeof t == "string" ? r = t : !s.cause && t && (c = !0, r = t.message, s.cause = t), !s.ruleId && !s.source && typeof i == "string") {
+      const h = i.indexOf(":");
+      h === -1 ? s.ruleId = i : (s.source = i.slice(0, h), s.ruleId = i.slice(h + 1));
+    }
+    if (!s.place && s.ancestors && s.ancestors) {
+      const h = s.ancestors[s.ancestors.length - 1];
+      h && (s.place = h.position);
+    }
+    const a = s.place && "start" in s.place ? s.place.start : s.place;
+    this.ancestors = s.ancestors || void 0, this.cause = s.cause || void 0, this.column = a ? a.column : void 0, this.fatal = void 0, this.file = "", this.message = r, this.line = a ? a.line : void 0, this.name = St(s.place) || "1:1", this.place = s.place || void 0, this.reason = this.message, this.ruleId = s.ruleId || void 0, this.source = s.source || void 0, this.stack = c && s.cause && typeof s.cause.stack == "string" ? s.cause.stack : "", this.actual = void 0, this.expected = void 0, this.note = void 0, this.url = void 0;
+  }
+}
+I.prototype.file = "";
+I.prototype.name = "";
+I.prototype.reason = "";
+I.prototype.message = "";
+I.prototype.stack = "";
+I.prototype.column = void 0;
+I.prototype.line = void 0;
+I.prototype.ancestors = void 0;
+I.prototype.cause = void 0;
+I.prototype.fatal = void 0;
+I.prototype.place = void 0;
+I.prototype.ruleId = void 0;
+I.prototype.source = void 0;
+function Lt(e) {
+  const t = Ct(e);
+  let n;
+  try {
+    n = It.parseXml(String(e), {
+      // Positional offsets.
+      includeOffsets: !0,
+      // `<![CDATA[>&<]]>`
+      preserveCdata: !0,
+      // `<!--a-->`
+      preserveComments: !0,
+      // `<!DOCTYPE b>` (a specific declaration)
+      preserveDocumentType: !0,
+      // `<?xml?>` (a specific instruction)
+      preserveXmlDeclaration: !0
+    });
+  } catch (s) {
+    const c = (
+      /** @type {XmlError} */
+      s
+    ), a = t.toPoint(c.pos), h = new I(
+      "Could not parse XML with `@rgrove/parse-xml`",
+      {
+        cause: c,
+        place: a,
+        ruleId: "error",
+        source: "xast-util-from-xml"
+      }
+    );
+    throw h.fatal = !0, h.url = "https://github.com/syntax-tree/xast-util-from-xml#throws", h;
+  }
+  const i = { location: t }, r = At(n, i);
+  return ze(n, r, i), r;
+}
+function Nt(e) {
+  return { type: "cdata", value: e.text };
+}
+function _t(e) {
+  return { type: "comment", value: e.content };
+}
+function At(e, t) {
+  return { type: "root", children: Ye(e.children, t) };
+}
+function Ot(e) {
+  return {
+    type: "doctype",
+    name: e.name,
+    public: e.publicId || void 0,
+    system: e.systemId || void 0
+  };
+}
+function Mt(e, t) {
+  const n = Ye(e.children, t);
+  return {
+    type: "element",
+    name: e.name,
+    attributes: { ...e.attributes },
+    // @ts-expect-error: assume content matches.
+    children: n
+  };
+}
+function $t(e) {
+  return { type: "instruction", name: e.name, value: e.content };
+}
+function Rt(e) {
+  return { type: "text", value: e.text };
+}
+function qt(e) {
+  const t = [];
+  return e.version && t.push('version="' + e.version + '"'), e.encoding && t.push('encoding="' + e.encoding + '"'), e.standalone && t.push('standalone="' + e.standalone + '"'), { type: "instruction", name: "xml", value: t.join(" ") };
+}
+function Ye(e, t) {
+  const n = [];
+  let i = -1;
+  for (; ++i < e.length; ) {
+    const r = e[i];
+    let s;
+    r.type === "cdata" ? s = Nt(
+      /** @type {XmlCdata} */
+      r
+    ) : r.type === "comment" ? s = _t(
+      /** @type {XmlComment} */
+      r
+    ) : r.type === "doctype" ? s = Ot(
+      /** @type {XmlDocumentType} */
+      r
+    ) : r.type === "element" ? s = Mt(
+      /** @type {XmlElement} */
+      r,
+      t
+    ) : r.type === "pi" ? s = $t(
+      /** @type {XmlProcessingInstruction} */
+      r
+    ) : r.type === "text" ? s = Rt(
+      /** @type {XmlText} */
+      r
+    ) : r.type === "xmldecl" && (s = qt(
+      /** @type {XmlDeclaration} */
+      r
+    )), s && (ze(r, s, t), n.push(s));
+  }
+  return n;
+}
+function ze(e, t, n) {
+  const i = (
+    // Doesn’t practically happen as far as I found, but `-1` is used in the
+    // code, so let’s keep it in.
+    /* c8 ignore next */
+    e.start === -1 ? void 0 : n.location.toPoint(e.start)
+  ), r = (
+    // Same as above
+    /* c8 ignore next */
+    e.end === -1 ? void 0 : n.location.toPoint(e.end)
+  );
+  i && r && (t.position = { start: i, end: r });
+}
+const Ft = /<!--[\s\S]*?-->/g, le = /* @__PURE__ */ new Set(["me", "men", "mdn"]), Pt = /* @__PURE__ */ new Set([
+  ...le,
+  "c",
+  "cd",
+  "cline",
+  "m",
+  "md",
+  "mrow",
+  "pre"
+]), jt = /* @__PURE__ */ new Set([
+  "blockquote",
+  "containerDirective",
+  "listItem",
+  "root"
+]), Je = /* @__PURE__ */ new Set([
+  ...le,
+  ...Ae("p")
+]);
+for (const e of Ae("section"))
+  Je.delete(e);
+function Xt(e) {
+  return st(e) || le.has(e);
+}
+function R(e) {
+  let t;
+  try {
+    t = Lt(`<raw>${e.replace(Ft, "")}</raw>`);
+  } catch {
+    return null;
+  }
+  const i = t.children.find((s) => s.type === "element").children;
+  return i.every(
+    (s) => s.type === "element" ? Xt(s.name) : s.type !== "instruction"
+  ) ? i : null;
+}
+function Bt(e) {
+  const t = R(e);
+  if (t) return { children: t };
+  const [n] = R(e.replace(/>$/, "/>")) ?? [];
+  return n?.type === "element" ? { children: [], opens: n } : null;
+}
+function Ut(e, t, n) {
+  const i = new RegExp(`^<${n}(\\s[^]*)?(?<!/)>$`), r = new RegExp(`^</${n}\\s*>$`);
+  let s = 1;
+  for (let c = t + 1; c < e.length; c += 1) {
+    if (e[c].type !== "html") continue;
+    const { value: a } = e[c];
+    if (i.test(a) && (s += 1), r.test(a) && (s -= 1), s === 0) return c;
+  }
+  return -1;
+}
+function Yt(e) {
+  const t = [];
+  let n = null;
+  for (const i of e) {
+    if (i.type === "element" && !Je.has(i.name)) {
+      t.push(i), n = null;
+      continue;
+    }
+    !n && i.type === "text" && !i.value.trim() || (n || (n = { type: "element", name: "p", attributes: {}, children: [] }, t.push(n)), n.children.push(i));
+  }
+  return t;
+}
+function zt(e, t, n, i) {
+  const r = R(e[t].value);
+  if (r) return { nodes: r, end: t };
+  const s = e[t].position?.start.offset;
+  if (n === void 0 || s === void 0) return null;
+  let c = e[t].position?.end.offset;
+  for (let a = t + 1; a < e.length; a += 1) {
+    const h = e[a].position?.end.offset;
+    if (!n.slice(c, h).includes("</")) continue;
+    c = h;
+    const p = R(i(n.slice(s, h)));
+    if (p) return { nodes: p, end: a };
+  }
+  return null;
+}
+function Jt(e, t, n) {
+  V(e, (i) => {
+    if (!jt.has(i.type)) return;
+    const r = i.children;
+    for (let s = 0; s < r.length; s += 1) {
+      if (r[s].type !== "html") continue;
+      const c = zt(r, s, t, n);
+      if (!c) continue;
+      const a = Yt(c.nodes).map(
+        (h) => ({ type: "ptxRaw", element: h })
+      );
+      r.splice(s, c.end - s + 1, ...a), s += a.length - 1;
+    }
+  });
+}
+const H = {
   // theorem-like (requires statement wrapping)
   theorem: {
     type: "theorem",
@@ -158,16 +1572,16 @@ const $ = {
     category: "solution-like",
     requiresStatement: !1
   }
-}, Pt = $;
-function de(e) {
-  return $[e.toLowerCase()];
+}, vi = H;
+function Wt(e) {
+  return H[e.toLowerCase()];
 }
-const Y = new Set(
-  Object.entries($).filter(
+const We = new Set(
+  Object.entries(H).filter(
     ([e, t]) => t.category === "proof-like" || t.category === "solution-like"
   ).map(([e]) => e)
 );
-function L(e, t, n) {
+function M(e, t, n) {
   return {
     type: "element",
     name: e,
@@ -175,113 +1589,113 @@ function L(e, t, n) {
     children: t
   };
 }
-function w(e) {
+function P(e) {
   return e.type === "containerDirective" && e.name === "task";
 }
-function me(e) {
-  return e.type === "containerDirective" && Y.has(e.name);
+function Vt(e) {
+  return e.type === "containerDirective" && We.has(e.name);
 }
-function T(e) {
+function Y(e) {
   const t = [];
   for (const n of e)
-    n.name === "ul" || n.name === "ol" ? t.length > 0 && t[t.length - 1]?.name === "p" ? t[t.length - 1].children.push(n) : t.push(L("p", [n])) : t.push(n);
+    n.name === "ul" || n.name === "ol" ? t.length > 0 && t[t.length - 1]?.name === "p" ? t[t.length - 1].children.push(n) : t.push(M("p", [n])) : t.push(n);
   return t;
 }
-function ge(e, t, n, o, i, r, s) {
-  const l = [];
-  if (n && l.push(n), e.hasNestedTasks) {
-    const c = o.findIndex(w);
-    if (c !== -1) {
-      const u = [];
-      for (let f = 0; f < o.length; f++)
-        w(o[f]) && u.push(f);
-      const a = u[u.length - 1], p = o.slice(0, c), d = o.slice(c).filter(w), g = [], y = [], v = [];
-      for (let f = c; f < o.length; f++) {
-        const m = o[f];
-        if (!w(m)) {
-          if (f < a) {
-            g.push(m);
+function Ht(e, t, n, i, r, s, c) {
+  const a = [];
+  if (n && a.push(n), e.hasNestedTasks) {
+    const h = i.findIndex(P);
+    if (h !== -1) {
+      const p = [];
+      for (let v = 0; v < i.length; v++)
+        P(i[v]) && p.push(v);
+      const m = p[p.length - 1], g = i.slice(0, h), x = i.slice(h).filter(P), T = [], D = [], L = [];
+      for (let v = h; v < i.length; v++) {
+        const b = i[v];
+        if (!P(b)) {
+          if (v < m) {
+            T.push(b);
             continue;
           }
-          if (me(m)) {
-            v.push(m);
+          if (Vt(b)) {
+            L.push(b);
             continue;
           }
-          y.push(m);
+          D.push(b);
         }
       }
-      if (g.length > 0 && (i.messages ?? (i.messages = [])).push({
+      if (T.length > 0 && (r.messages ?? (r.messages = [])).push({
         type: "warning",
-        reason: `Dropped ${g.length} non-task node(s) between task directives in ${e.type}.`,
+        reason: `Dropped ${T.length} non-task node(s) between task directives in ${e.type}.`,
         category: "dropped-content-between-tasks",
-        position: g[0].position?.start
-      }), p.length > 0) {
-        const f = T(
-          p.map((m) => r(m, i)).filter((m) => m !== null)
+        position: T[0].position?.start
+      }), g.length > 0) {
+        const v = Y(
+          g.map((b) => s(b, r)).filter((b) => b !== null)
         );
-        f.length > 0 && l.push(L("introduction", f));
+        v.length > 0 && a.push(M("introduction", v));
       }
-      for (const f of d) {
-        const m = s(f, i);
-        m && l.push(m);
+      for (const v of x) {
+        const b = c(v, r);
+        b && a.push(b);
       }
-      if (y.length > 0) {
-        const f = T(
-          y.map((m) => r(m, i)).filter((m) => m !== null)
+      if (D.length > 0) {
+        const v = Y(
+          D.map((b) => s(b, r)).filter((b) => b !== null)
         );
-        f.length > 0 && l.push(L("conclusion", f));
+        v.length > 0 && a.push(M("conclusion", v));
       }
-      for (const f of v) {
-        const m = s(f, i);
-        m && l.push(m);
+      for (const v of L) {
+        const b = c(v, r);
+        b && a.push(b);
       }
     } else
-      j(
-        l,
+      Te(
+        a,
         e,
-        o,
         i,
         r,
-        s
+        s,
+        c
       );
   } else
-    j(
-      l,
+    Te(
+      a,
       e,
-      o,
       i,
       r,
-      s
+      s,
+      c
     );
-  return L(e.type, l, t);
+  return M(e.type, a, t);
 }
-function j(e, t, n, o, i, r) {
+function Te(e, t, n, i, r, s) {
   if (t.requiresStatement) {
-    const s = [], l = [];
-    for (const c of n)
-      if (c.type === "containerDirective" && Y.has(c.name)) {
-        const u = r(c, o);
-        u && l.push(u);
+    const c = [], a = [];
+    for (const h of n)
+      if (h.type === "containerDirective" && We.has(h.name)) {
+        const p = s(h, i);
+        p && a.push(p);
       } else
-        s.push(c);
-    if (s.length > 0) {
-      const c = T(
-        s.map((u) => i(u, o)).filter((u) => u !== null)
+        c.push(h);
+    if (c.length > 0) {
+      const h = Y(
+        c.map((p) => r(p, i)).filter((p) => p !== null)
       );
-      c.length > 0 && e.push(L("statement", c));
+      h.length > 0 && e.push(M("statement", h));
     }
-    e.push(...l);
+    e.push(...a);
   } else {
-    const s = T(
-      n.map((l) => i(l, o)).filter((l) => l !== null)
+    const c = Y(
+      n.map((a) => r(a, i)).filter((a) => a !== null)
     );
-    e.push(...s);
+    e.push(...c);
   }
 }
-function E(e) {
+function Ve(e) {
   return { type: "text", value: e };
 }
-function h(e, t, n) {
+function k(e, t, n) {
   return {
     type: "element",
     name: e,
@@ -289,554 +1703,476 @@ function h(e, t, n) {
     children: t
   };
 }
-function k(e, t, n) {
-  return h(e, [E(t)], n);
+function _(e, t, n) {
+  return k(e, [Ve(t)], n);
 }
-function Q(e) {
+function He(e) {
   return { type: "comment", value: e.replace(/--/g, "- -") };
 }
-function R(e, t) {
-  const n = e?.position, o = n?.start?.offset, i = n?.end?.offset;
-  return t.source && o != null && i != null ? t.source.slice(o, i) : "";
+function q(e, t) {
+  const n = e?.position, i = n?.start?.offset, r = n?.end?.offset;
+  return t.source && i != null && r != null ? t.restoreSource(t.source.slice(i, r)) : "";
 }
-function P(e, t, n) {
-  return h("TODO", [Q(`todo: ${t}`), k("pre", n)], {
+function ce(e, t, n) {
+  return k("TODO", [He(`todo: ${t}`), _("pre", n)], {
     type: e
   });
 }
-function ye(e, t, n) {
-  return h("TODO", [Q(`todo: ${t}`), k("c", n)], {
+function Zt(e, t, n) {
+  return k("TODO", [He(`todo: ${t}`), _("c", n)], {
     type: e
   });
 }
-function q(e) {
+function z(e) {
   const t = [];
   for (const n of e)
-    n.name === "ul" || n.name === "ol" ? t.length > 0 && t[t.length - 1]?.name === "p" ? t[t.length - 1].children.push(n) : t.push(h("p", [n])) : t.push(n);
+    n.name === "ul" || n.name === "ol" ? t.length > 0 && t[t.length - 1]?.name === "p" ? t[t.length - 1].children.push(n) : t.push(k("p", [n])) : t.push(n);
   return t;
 }
-function B(e, t, n) {
-  return ve(e, t, n).tree;
+function Ie(e, t, n) {
+  return Gt(e, t, n).tree;
 }
-function ve(e, t, n) {
-  const o = [], i = {
+function Gt(e, t, n) {
+  const i = [], r = n?.restoreSource ?? ((g) => g);
+  Jt(e, t, r), ft(e, t);
+  const s = {
     ancestors: [],
     depth: 0,
-    messages: o,
+    messages: i,
     source: t,
+    restoreSource: r,
     topLevelDivision: n?.topLevelDivision ?? "chapter",
     documentRoot: n?.documentRoot,
     topLevelAttributes: n?.topLevelAttributes,
     topLevelAttributesApplied: n?.topLevelAttributes ? { done: !1 } : void 0,
     topLevelTitle: n?.topLevelTitle
-  }, r = e.children;
-  if (i.documentRoot) {
-    const a = S(i), p = i.topLevelTitle ? h("title", [E(i.topLevelTitle)]) : null, { introduction: d, rest: g } = I(r, i), y = C(g, i), v = [
-      ...p ? [p] : [],
-      ...d ? [d] : [],
-      ...y
+  }, c = e.children;
+  if (s.documentRoot) {
+    const g = B(s), x = s.topLevelTitle ? Ce(s.topLevelTitle, s) : null, { introduction: T, rest: D } = X(c, s), L = s.documentRoot === "slideshow" && Kt(D) ? Qt(D, s) : A(D, s), v = [
+      ...x ? [x] : [],
+      ...T ? [T] : [],
+      ...L
     ];
     return {
-      tree: { type: "root", children: [h(i.documentRoot, v, a)] },
-      messages: o
+      tree: { type: "root", children: [k(s.documentRoot, v, g)] },
+      messages: i
     };
   }
-  if (ce(i.topLevelDivision)) {
-    const a = S(i), p = q(
-      C(r, { ...i, depth: 1 }, !0)
+  if (ot(s.topLevelDivision)) {
+    const g = B(s), x = z(
+      A(c, { ...s, depth: 1 }, !0)
     );
     return {
-      tree: { type: "root", children: [h(i.topLevelDivision, p, a)] },
-      messages: o
+      tree: { type: "root", children: [k(s.topLevelDivision, x, g)] },
+      messages: i
     };
   }
-  if (i.topLevelTitle) {
-    const a = S(i), p = h("title", [E(i.topLevelTitle)]), d = {
-      ...i,
-      depth: i.depth + 1,
-      headingDepthOffset: (i.headingDepthOffset ?? 0) + 1
-    }, { introduction: g, rest: y } = I(r, d), v = q(
-      C(y, d, !0)
-    ), f = g ? [p, g, ...v] : [p, ...v];
+  if (s.topLevelTitle) {
+    const g = B(s), x = Ce(s.topLevelTitle, s), T = {
+      ...s,
+      depth: s.depth + 1,
+      headingDepthOffset: (s.headingDepthOffset ?? 0) + 1
+    }, { introduction: D, rest: L } = X(c, T), v = z(
+      A(L, T, !0)
+    ), b = D ? [x, D, ...v] : [x, ...v];
     return {
-      tree: { type: "root", children: [h(i.topLevelDivision, f, a)] },
-      messages: o
+      tree: { type: "root", children: [k(s.topLevelDivision, b, g)] },
+      messages: i
     };
   }
-  const { introduction: s, rest: l } = I(r, i), c = C(l, i);
+  const { introduction: a, rest: h } = X(c, s), p = A(h, s);
   return {
-    tree: { type: "root", children: s ? [s, ...c] : c },
-    messages: o
+    tree: { type: "root", children: a ? [a, ...p] : p },
+    messages: i
   };
 }
-function C(e, t, n = !1) {
-  let o = 7;
-  for (const u of e)
-    u.type === "heading" && (o = Math.min(o, u.depth));
-  if (o === 7)
-    return x(e, t, n);
-  const i = [];
-  let r = null, s = [], l = [];
-  const c = () => {
-    r && (i.push(ke(r, l, t)), r = null, l = []);
+function Ce(e, t) {
+  const { tree: n, source: i, restoreSource: r } = kt(e);
+  return k(
+    "title",
+    N(n, { ...t, source: i, restoreSource: r })
+  );
+}
+function Kt(e) {
+  return e.some((t) => t.type === "thematicBreak");
+}
+function Qt(e, t) {
+  return A(e, t);
+}
+function A(e, t, n = !1) {
+  let i = 7;
+  for (const p of e)
+    p.type === "heading" && (i = Math.min(i, p.depth));
+  if (i === 7)
+    return $(e, t, n);
+  const r = [];
+  let s = null, c = [], a = [];
+  const h = () => {
+    s && (r.push(en(s, a, t)), s = null, a = []);
   };
-  for (const u of e)
-    u.type === "heading" && u.depth === o ? (!r && s.length > 0 && (i.push(
-      ...x(s, t, n)
-    ), s = []), c(), r = u, l = []) : r ? l.push(u) : s.push(u);
-  return !r && s.length > 0 && i.push(
-    ...x(s, t, n)
-  ), c(), i;
-}
-function x(e, t, n = !1) {
-  const o = [];
-  for (let i = 0; i < e.length; i += 1) {
-    const r = e[i], s = O(r, t);
-    if (s !== null) {
-      if (s.name === "p" && s.children.length === 1 && s.children[0].name === "md") {
-        const l = s.children[0], c = o[o.length - 1], u = i + 1 < e.length ? O(e[i + 1], t) : null, a = u?.name === "p" ? u.children : null;
-        if (c?.name === "p")
-          c.children.push(l), a && (c.children.push(
-            ...a
-          ), i += 1);
+  for (const p of e)
+    p.type === "heading" && p.depth === i ? (!s && c.length > 0 && (r.push(
+      ...$(c, t, n)
+    ), c = []), h(), s = p, a = []) : s ? a.push(p) : c.push(p);
+  return !s && c.length > 0 && r.push(
+    ...$(c, t, n)
+  ), h(), r;
+}
+function $(e, t, n = !1) {
+  const i = [];
+  for (let r = 0; r < e.length; r += 1) {
+    const s = e[r], c = J(s, t);
+    if (c !== null) {
+      if (c.name === "p" && c.children.length === 1 && c.children[0].name === "md") {
+        const a = c.children[0], h = i[i.length - 1], p = r + 1 < e.length ? J(e[r + 1], t) : null, m = p?.name === "p" ? p.children : null;
+        if (h?.name === "p")
+          h.children.push(a), m && (h.children.push(
+            ...m
+          ), r += 1);
         else {
-          const p = [l];
-          a && (p.push(...a), i += 1), o.push(h("p", p));
+          const g = [a];
+          m && (g.push(...m), r += 1), i.push(k("p", g));
         }
         continue;
       }
-      if ((s.name === "ul" || s.name === "ol") && o.length > 0) {
-        const l = o[o.length - 1];
-        if (l?.name === "p") {
-          l.children.push(s);
+      if ((c.name === "ul" || c.name === "ol") && i.length > 0) {
+        const a = i[i.length - 1];
+        if (a?.name === "p") {
+          a.children.push(c);
           continue;
         }
       }
-      o.push(s);
+      i.push(c);
     }
   }
-  return n ? q(o) : o;
+  return n ? z(i) : i;
 }
-function ke(e, t, n) {
-  const o = e.depth + (n.headingDepthOffset ?? 0), i = n.documentRoot ? ue(n.documentRoot, o) : ae(n.topLevelDivision, o), r = h("title", b(e.children, n)), s = Ce(e, n), l = { ...n, depth: n.depth + 1 }, { introduction: c, rest: u } = I(t, l), a = C(u, l, !0), p = q(a), d = c ? [r, c, ...p] : [r, ...p];
-  return h(i, d, s);
+function en(e, t, n) {
+  const i = e.depth + (n.headingDepthOffset ?? 0), r = n.documentRoot ? lt(n.documentRoot, i) : ct(n.topLevelDivision, i), s = k("title", N(e.children, n)), c = rn(e, n), a = { ...n, depth: n.depth + 1 }, { introduction: h, rest: p } = X(t, a), m = A(p, a, !0), g = z(m), x = h ? [s, h, ...g] : [s, ...g];
+  return k(r, x, c);
 }
-function be(e) {
-  return e.type === "leafDirective" && V(e.name);
+function tn(e) {
+  return e.type === "leafDirective" && Oe(e.name);
 }
-function I(e, t) {
+function X(e, t) {
   const n = e.findIndex(
-    (l) => l.type === "heading" || be(l)
+    (a) => a.type === "heading" || tn(a)
   );
   if (n <= 0)
     return { introduction: null, rest: e };
-  const o = e.slice(0, n), i = e.slice(n), r = x(o, t, !0);
-  return { introduction: r.length > 0 ? h("introduction", r) : null, rest: i };
+  const i = e.slice(0, n), r = e.slice(n), s = $(i, t, !0);
+  return { introduction: s.length > 0 ? k("introduction", s) : null, rest: r };
 }
-function De(e) {
+function nn(e) {
   const t = e.data;
-  return t?.id ? { "xml:id": t.id } : void 0;
+  return t?.id ? { ...t.attributes, "xml:id": t.id } : void 0;
 }
-function Ce(e, t) {
-  const n = De(e), o = S(t);
-  if (!(!n && !o))
-    return { ...o, ...n };
+function rn(e, t) {
+  const n = nn(e), i = B(t);
+  if (!(!n && !i))
+    return { ...i, ...n };
 }
-function S(e) {
+function B(e) {
   if (e.depth !== 0) return;
   const t = e.topLevelAttributesApplied;
   if (!(!e.topLevelAttributes || !t || t.done))
     return t.done = !0, e.topLevelAttributes;
 }
-const Le = {
-  paragraph: (e, t) => G(e, t),
-  blockquote: (e, t) => xe(e, t),
-  list: (e, t) => we(e, t),
-  code: (e, t) => Se(e),
-  containerDirective: (e, t) => J(e, t),
-  leafDirective: (e, t) => Ae(e, t)
+const sn = {
+  paragraph: (e, t) => on(e, t),
+  blockquote: (e, t) => ln(e, t),
+  list: (e, t) => cn(e, t),
+  code: (e, t) => un(e),
+  containerDirective: (e, t) => Ze(e, t),
+  leafDirective: (e, t) => dn(e, t),
+  ptxRaw: (e) => e.element
 };
-function O(e, t) {
-  const n = Le[e.type];
+function J(e, t) {
+  const n = sn[e.type];
   return n ? n(e, t) : (t.messages && t.messages.push({
     type: "warning",
     reason: `Unknown block type: ${e.type}`,
     category: "unknown-block-type"
-  }), P(
+  }), ce(
     "unknown-block-type",
     `unknown block type "${e.type}"`,
-    R(e, t)
+    q(e, t)
   ));
 }
-function G(e, t) {
-  return h("p", b(e.children, t));
+function on(e, t) {
+  return k("p", N(e.children, t));
 }
-function xe(e, t) {
-  const n = e.children.filter((o) => o.type === "paragraph").map((o) => {
-    const i = {
+function ln(e, t) {
+  const n = e.children.filter((i) => i.type === "paragraph" || i.type === "ptxRaw").map((i) => {
+    const r = {
       ...t,
       ancestors: [...t.ancestors, e],
       depth: t.depth + 1
     };
-    return G(o, i);
+    return J(i, r);
   });
-  return h("blockquote", n);
+  return k("blockquote", n);
 }
-function we(e, t) {
-  const n = e.children.map((o) => {
-    const i = {
+function cn(e, t) {
+  const n = e.children.map((i) => {
+    const r = {
       ...t,
       ancestors: [...t.ancestors, e],
       depth: t.depth + 1
     };
-    return Ie(o, i);
+    return an(i, r);
   });
-  return h(e.ordered ? "ol" : "ul", n);
+  return k(e.ordered ? "ol" : "ul", n);
 }
-function Ie(e, t) {
-  const n = x(
+function an(e, t) {
+  const n = $(
     e.children,
     t
   );
-  return h("li", n);
+  return k("li", n);
 }
-function Se(e, t) {
-  return k(
+function un(e, t) {
+  return _(
     "program",
     e.value,
     e.lang ? { language: e.lang } : void 0
   );
 }
-function Te(e, t) {
-  const n = e.value.split(/\\\\|[\r\n]+/).map((o) => o.trim()).filter((o) => o.length > 0);
-  return n.length > 1 ? h(
+function hn(e, t) {
+  const n = e.value.split(/\\\\|[\r\n]+/).map((i) => i.trim()).filter((i) => i.length > 0);
+  return n.length > 1 ? k(
     "md",
-    n.map((o) => k("mrow", o))
-  ) : k("md", n[0] ?? "");
+    n.map((i) => _("mrow", i))
+  ) : _("md", n[0] ?? "");
 }
-function Ee(e, t) {
-  return e.meta === "inline" ? k("m", e.value) : Te(e);
+function fn(e, t) {
+  return e.meta === "inline" ? _("m", e.value) : hn(e);
 }
-function qe(e, t) {
-  return h("url", b(e.children, t), { href: e.url });
+function pn(e, t) {
+  const n = N(e.children, t);
+  return /^#./.test(e.url) ? k("xref", n, { ref: e.url.slice(1) }) : k("url", n, { href: e.url });
 }
-function Ae(e, t) {
-  const n = he(e);
+function dn(e, t) {
+  const n = Dt(e);
   return n || (t.messages && t.messages.push({
     type: "warning",
     reason: "Unnamed leaf directive",
     category: "unknown-directive"
-  }), P(
+  }), ce(
     "unknown-directive",
     "unnamed leaf directive",
-    R(e, t)
+    q(e, t)
   ));
 }
-function J(e, t) {
-  const n = de(e.name);
+function Ze(e, t) {
+  const n = Wt(e.name);
   if (!n)
     return t.messages && t.messages.push({
       type: "warning",
       reason: `Unknown directive: ${e.name}`,
       category: "unknown-directive"
-    }), P(
+    }), ce(
       "unknown-directive",
       `unknown directive "${e.name}"`,
-      R(e, t)
+      q(e, t)
     );
-  const o = Re(e), i = e.children, { title: r, body: s } = $e(
-    i,
+  const i = gn(e), r = e.children, { title: s, body: c } = mn(
+    r,
     t
-  ), l = {
+  ), a = {
     ...t,
     ancestors: [...t.ancestors, e],
     depth: t.depth + 1
   };
-  return ge(
+  return Ht(
     n,
-    o,
-    r,
+    i,
     s,
-    l,
-    (c, u) => O(c, u),
-    (c, u) => J(c, u)
+    c,
+    a,
+    (h, p) => J(h, p),
+    (h, p) => Ze(h, p)
   );
 }
-function $e(e, t) {
+function mn(e, t) {
   const n = e[0];
   return n?.type === "paragraph" && n.data?.directiveLabel === !0 ? {
-    title: h(
+    title: k(
       "title",
-      b(n.children, t)
+      N(n.children, t)
     ),
     body: e.slice(1)
   } : { title: null, body: e };
 }
-function Re(e) {
+function gn(e) {
   const t = e.attributes ?? {}, n = {};
-  for (const [o, i] of Object.entries(t))
-    i != null && (n[o === "id" ? "xml:id" : o] = i);
+  for (const [i, r] of Object.entries(t))
+    r != null && (n[i === "id" ? "xml:id" : i] = r);
   return Object.keys(n).length > 0 ? n : void 0;
 }
-function Fe(e, t) {
+function yn(e, t) {
   return !t || e.position?.start?.offset === null || e.position?.start?.offset === void 0 ? "asterisk" : t.charAt(e.position.start.offset) === "_" ? "underscore" : "asterisk";
 }
-const Me = {
-  text: (e, t) => E(e.value),
+const vn = {
+  text: (e, t) => Ve(e.value),
   emphasis: (e, t) => {
-    const o = Fe(e, t.source) === "underscore" ? "term" : "em";
-    return h(o, b(e.children, t));
+    const i = yn(e, t.source) === "underscore" ? "term" : "em";
+    return k(i, N(e.children, t));
   },
-  strong: (e, t) => h("alert", b(e.children, t)),
-  inlineCode: (e, t) => k("c", e.value),
-  math: (e, t) => Ee(e),
-  link: (e, t) => qe(e, t)
+  strong: (e, t) => k("alert", N(e.children, t)),
+  inlineCode: (e, t) => _("c", e.value),
+  math: (e, t) => fn(e),
+  link: (e, t) => pn(e, t)
 };
-function b(e, t) {
-  return e.flatMap((n) => Oe(n, t)).filter((n) => n !== null);
+function N(e, t) {
+  const n = [];
+  for (let i = 0; i < e.length; i += 1) {
+    const r = bn(e, i, t);
+    if (r) {
+      n.push(...r.children), i = r.end;
+      continue;
+    }
+    const s = wn(e[i], t);
+    s !== null && n.push(s);
+  }
+  return n;
+}
+function bn(e, t, n) {
+  const i = e[t];
+  if (i.type !== "html") return null;
+  const r = Bt(i.value);
+  if (!r) return null;
+  const { opens: s } = r;
+  if (!s)
+    return { children: r.children, end: t };
+  const c = Ut(e, t, s.name);
+  if (c === -1) return null;
+  if (Pt.has(s.name)) {
+    const p = {
+      start: i.position?.start,
+      end: e[c].position?.end
+    }, m = R(q({ position: p }, n));
+    return m && { children: m, end: c };
+  }
+  const a = N(e.slice(t + 1, c), n);
+  return { children: [{ ...s, children: a }], end: c };
 }
-function Oe(e, t) {
-  const n = Me[e.type];
+function wn(e, t) {
+  const n = vn[e.type];
   if (!n)
     return t.messages && t.messages.push({
       type: "warning",
       reason: `Unknown inline type: ${e.type}`,
       category: "unknown-inline-type"
-    }), ye(
+    }), Zt(
       "unknown-inline-type",
       `unknown inline type "${e.type}"`,
-      R(e, t)
+      q(e, t)
     );
-  const o = { ...t, ancestors: [...t.ancestors, e] };
-  return n(e, o);
-}
-const Ne = [
-  // Display math (check these first, before single $)
-  { open: "$$", close: "$$", isDisplay: !0 },
-  { open: "\\[", close: "\\]", isDisplay: !0 },
-  // Inline math
-  { open: "$", close: "$", isDisplay: !1 },
-  { open: "\\(", close: "\\)", isDisplay: !1 }
-], ee = "PTX_MATH_TOKEN_", F = new RegExp(`${ee}(\\d+)`, "g");
-function te(e, t) {
-  let n = null;
-  for (const o of Ne) {
-    const i = e.indexOf(o.open, t);
-    if (i === -1) continue;
-    const r = e.indexOf(o.close, i + o.open.length);
-    if (r !== -1 && !(o.open === "$" && (i > 0 && e[i - 1] === "$" || i + 1 < e.length && e[i + 1] === "$")) && (!n || i < n.index)) {
-      const s = e.substring(i + o.open.length, r);
-      n = { index: i, pattern: o, content: s };
-    }
-  }
-  return n;
-}
-function _e(e, t) {
-  let n = t;
-  for (; n < e.length; ) {
-    const o = e.indexOf("`", n);
-    if (o === -1) return null;
-    let i = 0, r = o;
-    for (; r < e.length && e[r] === "`"; )
-      i++, r++;
-    const s = "`".repeat(i);
-    let l = r;
-    for (; l < e.length; ) {
-      const c = e.indexOf(s, l);
-      if (c === -1) break;
-      const u = c + i;
-      if (u >= e.length || e[u] !== "`")
-        return { start: o, end: u };
-      l = c + 1;
-    }
-    n = o + i;
-  }
-  return null;
-}
-function Pe(e) {
-  const t = /* @__PURE__ */ new Map();
-  let n = "", o = 0, i = 0;
-  for (; o < e.length; ) {
-    const r = _e(e, o), s = te(e, o);
-    if (r && (!s || r.start < s.index)) {
-      n += e.substring(o, r.end), o = r.end;
-      continue;
-    }
-    if (!s) {
-      n += e.substring(o);
-      break;
-    }
-    n += e.substring(o, s.index);
-    const l = `${ee}${i}`;
-    n += l, t.set(l, {
-      type: "math",
-      value: s.content,
-      meta: s.pattern.isDisplay ? "display" : "inline"
-    }), o = s.index + s.pattern.open.length + s.content.length + s.pattern.close.length, i += 1;
-  }
-  return { markdown: n, tokens: t };
-}
-function je(e) {
-  const t = [];
-  let n = 0;
-  for (; n < e.length; ) {
-    const o = te(e, n);
-    if (!o) {
-      n < e.length && t.push({ type: "text", value: e.substring(n) });
-      break;
-    }
-    o.index > n && t.push({
-      type: "text",
-      value: e.substring(n, o.index)
-    }), t.push({
-      type: "math",
-      value: o.content,
-      meta: o.pattern.isDisplay ? "display" : "inline"
-    }), n = o.index + o.pattern.open.length + o.content.length + o.pattern.close.length;
-  }
-  return t.length === 0 ? [{ type: "text", value: e }] : t;
-}
-function Be(e, t) {
-  const n = [];
-  let o = 0;
-  F.lastIndex = 0;
-  let i = F.exec(e);
-  for (; i; ) {
-    const r = i.index, s = i[0];
-    r > o && n.push({ type: "text", value: e.substring(o, r) });
-    const l = t.get(s);
-    l ? n.push(l) : n.push({ type: "text", value: s }), o = r + s.length, i = F.exec(e);
-  }
-  return o < e.length && n.push({ type: "text", value: e.substring(o) }), n.length === 0 ? [{ type: "text", value: e }] : n;
+  const i = { ...t, ancestors: [...t.ancestors, e] };
+  return n(e, i);
 }
-function ne(e) {
-  K(e, "paragraph", (t) => {
-    const n = t.children || [], o = [];
-    for (const i of n)
-      if (i.type === "text") {
-        const r = je(i.value);
-        o.push(...r);
-      } else
-        o.push(i);
-    t.children = o;
-  });
-}
-function ze(e, t) {
-  K(e, "paragraph", (n) => {
-    const o = n.children || [], i = [];
-    for (const r of o)
-      if (r.type === "text") {
-        const s = Be(r.value, t);
-        i.push(...s);
-      } else
-        i.push(r);
-    n.children = i;
-  });
-}
-const jt = () => (e) => {
-  ne(e);
-};
-function We(e) {
+function xn(e) {
   const t = e.trim();
   if (!t.startsWith(":")) return null;
   let n = 0;
-  for (let r = 0; r < t.length && t[r] === ":"; r++)
+  for (let s = 0; s < t.length && t[s] === ":"; s++)
     n++;
   if (n < 3) return null;
-  const o = t.slice(n).trim(), i = o.match(
+  const i = t.slice(n).trim(), r = i.match(
     /^([a-zA-Z0-9_-]+)(\[[^\]]*\])?(\{[^}]*\})?$/
   );
-  return o === "" ? { colons: n, label: null, lineIndex: -1, isOpen: !1 } : i ? {
+  return i === "" ? { colons: n, label: null, lineIndex: -1, isOpen: !1 } : r ? {
     colons: n,
-    label: i[0],
+    label: r[0],
     lineIndex: -1,
     isOpen: !0
   } : null;
 }
-function Ue(e) {
+function kn(e) {
   const t = [], n = [];
-  for (const o of e)
-    if (o.isOpen) {
-      const i = {
-        colons: o.colons,
-        finalColons: o.colons,
-        label: o.label,
-        openLineIndex: o.lineIndex,
+  for (const i of e)
+    if (i.isOpen) {
+      const r = {
+        colons: i.colons,
+        finalColons: i.colons,
+        label: i.label,
+        openLineIndex: i.lineIndex,
         closeLineIndex: null,
         children: [],
         parent: null
       };
       if (t.length > 0) {
-        const r = t[t.length - 1];
-        i.parent = r, r.children.push(i);
+        const s = t[t.length - 1];
+        r.parent = s, s.children.push(r);
       } else
-        n.push(i);
-      t.push(i);
+        n.push(r);
+      t.push(r);
     } else {
-      const i = t[t.length - 1];
-      i && i.colons === o.colons && (i.closeLineIndex = o.lineIndex, t.pop());
+      const r = t[t.length - 1];
+      r && r.colons === i.colons && (r.closeLineIndex = i.lineIndex, t.pop());
     }
   return n;
 }
-function oe(e) {
+function Ge(e) {
   if (e.children.length === 0)
     e.finalColons = e.colons;
   else {
-    const t = Math.max(...e.children.map(oe));
+    const t = Math.max(...e.children.map(Ge));
     e.finalColons = Math.max(e.colons, t + 1);
   }
   return e.finalColons;
 }
-function He(e, t, n) {
-  const o = e.slice(), i = [], r = t.slice();
-  for (; r.length > 0; ) {
-    const s = r.shift();
-    i.push(s), r.push(...s.children);
+function En(e, t, n) {
+  const i = e.slice(), r = [], s = t.slice();
+  for (; s.length > 0; ) {
+    const c = s.shift();
+    r.push(c), s.push(...c.children);
   }
-  for (const s of i) {
-    if (s.openLineIndex >= 0) {
-      const l = o[s.openLineIndex], c = l.match(/^:+/)?.[0].length || 3, u = l.slice(c);
-      o[s.openLineIndex] = ":".repeat(s.finalColons) + u;
+  for (const c of r) {
+    if (c.openLineIndex >= 0) {
+      const a = i[c.openLineIndex], h = a.match(/^:+/)?.[0].length || 3, p = a.slice(h);
+      i[c.openLineIndex] = ":".repeat(c.finalColons) + p;
     }
-    s.closeLineIndex !== null && s.closeLineIndex >= 0 && (o[s.closeLineIndex] = ":".repeat(s.finalColons));
+    c.closeLineIndex !== null && c.closeLineIndex >= 0 && (i[c.closeLineIndex] = ":".repeat(c.finalColons));
   }
-  return o;
+  return i;
 }
-function Xe(e) {
+function Dn(e) {
   const t = e.split(`
 `), n = [];
-  let o = !1, i = null;
-  for (let l = 0; l < t.length; l++) {
-    const c = t[l], a = c.trim().match(/^(`{3,}|~{3,})/);
-    if (a) {
-      const d = a[1];
-      o ? i && d[0] === i[0] && d.length >= i.length && (o = !1, i = null) : (o = !0, i = d);
+  let i = !1, r = null;
+  for (let a = 0; a < t.length; a++) {
+    const h = t[a], m = h.trim().match(/^(`{3,}|~{3,})/);
+    if (m) {
+      const x = m[1];
+      i ? r && x[0] === r[0] && x.length >= r.length && (i = !1, r = null) : (i = !0, r = x);
       continue;
     }
-    if (o)
+    if (i)
       continue;
-    const p = We(c);
-    p && n.push({ ...p, lineIndex: l });
+    const g = xn(h);
+    g && n.push({ ...g, lineIndex: a });
   }
   if (n.length === 0)
     return e;
-  const r = Ue(n);
-  for (const l of r)
-    oe(l);
-  return He(t, r).join(`
+  const s = kn(n);
+  for (const a of s)
+    Ge(a);
+  return En(t, s).join(`
 `);
 }
-function Ze(e) {
+function Tn(e) {
   const t = e.trim();
   if (!t.endsWith(":")) return null;
   const n = t.slice(0, -1);
   if (!/^[a-zA-Z]/.test(n)) return null;
-  const o = n.match(/^([a-zA-Z][a-zA-Z0-9_-]*)(.*)$/);
-  if (!o) return null;
-  const [, i, r] = o;
-  return r && !/^(\[[^\]]*\]|\{[^}]*\})*$/.test(r) || !$[i.toLowerCase()] ? null : n;
+  const i = n.match(/^([a-zA-Z][a-zA-Z0-9_-]*)(.*)$/);
+  if (!i) return null;
+  const [, r, s] = i;
+  return s && !/^(\[[^\]]*\]|\{[^}]*\})*$/.test(s) || !H[r.toLowerCase()] ? null : n;
 }
-function N(e) {
+function ie(e) {
   let t = 0;
   for (let n = 0; n < e.length; n++)
     if (e[n] === " ")
@@ -847,85 +2183,85 @@ function N(e) {
       break;
   return t;
 }
-function Ve(e, t) {
-  const n = N(e[t]);
-  for (let o = t + 1; o < e.length; o++)
-    if (!ie(e[o]))
-      return N(e[o]) > n;
+function In(e, t) {
+  const n = ie(e[t]);
+  for (let i = t + 1; i < e.length; i++)
+    if (!Ke(e[i]))
+      return ie(e[i]) > n;
   return !1;
 }
-function ie(e) {
+function Ke(e) {
   return e.trim() === "";
 }
-function Ke(e, t) {
-  let n = 0, o = 0;
-  for (; o < e.length && n < t; )
-    if (e[o] === " ")
-      n++, o++;
-    else if (e[o] === "	")
-      n += 4, o++;
+function Cn(e, t) {
+  let n = 0, i = 0;
+  for (; i < e.length && n < t; )
+    if (e[i] === " ")
+      n++, i++;
+    else if (e[i] === "	")
+      n += 4, i++;
     else
       break;
-  return e.slice(o);
+  return e.slice(i);
 }
-function Ye(e) {
+function Sn(e) {
   const t = e.split(`
-`), n = [], o = {
+`), n = [], i = {
     level: 0,
     openDirectives: [],
     inCodeFence: !1,
     codeFenceMarker: null
   };
-  for (let i = 0; i < t.length; i++) {
-    const r = t[i], s = r.trim(), l = N(r), c = s.match(/^(`{3,}|~{3,})/);
-    if (c) {
-      const a = c[1];
-      o.inCodeFence ? o.codeFenceMarker && s.startsWith(o.codeFenceMarker) && (o.inCodeFence = !1, o.codeFenceMarker = null) : (o.inCodeFence = !0, o.codeFenceMarker = a), n.push(r);
+  for (let r = 0; r < t.length; r++) {
+    const s = t[r], c = s.trim(), a = ie(s), h = c.match(/^(`{3,}|~{3,})/);
+    if (h) {
+      const m = h[1];
+      i.inCodeFence ? i.codeFenceMarker && c.startsWith(i.codeFenceMarker) && (i.inCodeFence = !1, i.codeFenceMarker = null) : (i.inCodeFence = !0, i.codeFenceMarker = m), n.push(s);
       continue;
     }
-    if (o.inCodeFence) {
-      n.push(r);
+    if (i.inCodeFence) {
+      n.push(s);
       continue;
     }
-    if (ie(r)) {
+    if (Ke(s)) {
       n.push("");
       continue;
     }
-    const u = Ze(s);
-    if (u && Ve(t, i)) {
-      for (; o.openDirectives.length > 0 && !(o.openDirectives[o.openDirectives.length - 1].indentLevel < l); ) {
-        const y = o.openDirectives.pop();
-        y && n.push(":".repeat(y.colonCount));
+    const p = Tn(c);
+    if (p && In(t, r)) {
+      for (; i.openDirectives.length > 0 && !(i.openDirectives[i.openDirectives.length - 1].indentLevel < a); ) {
+        const D = i.openDirectives.pop();
+        D && n.push(":".repeat(D.colonCount));
       }
-      const a = u.match(/^([a-zA-Z][a-zA-Z0-9_-]*)(.*)/), p = a ? a[1].toLowerCase() + (a[2] || "") : u, d = o.openDirectives.length * 1 + 3;
-      n.push(":".repeat(d) + p), o.openDirectives.push({
-        label: p,
-        indentLevel: l,
-        colonCount: d,
+      const m = p.match(/^([a-zA-Z][a-zA-Z0-9_-]*)(.*)/), g = m ? m[1].toLowerCase() + (m[2] || "") : p, x = i.openDirectives.length * 1 + 3;
+      n.push(":".repeat(x) + g), i.openDirectives.push({
+        label: g,
+        indentLevel: a,
+        colonCount: x,
         bodyBaseIndent: -1
-      }), o.level = l;
+      }), i.level = a;
     } else {
-      for (; o.openDirectives.length > 0 && l <= o.openDirectives[o.openDirectives.length - 1].indentLevel; ) {
-        const a = o.openDirectives.pop();
-        a && n.push(":".repeat(a.colonCount));
+      for (; i.openDirectives.length > 0 && a <= i.openDirectives[i.openDirectives.length - 1].indentLevel; ) {
+        const m = i.openDirectives.pop();
+        m && n.push(":".repeat(m.colonCount));
       }
-      if (o.openDirectives.length > 0) {
-        const a = o.openDirectives[o.openDirectives.length - 1];
-        a.bodyBaseIndent < 0 && (a.bodyBaseIndent = l), n.push(Ke(r, a.bodyBaseIndent));
+      if (i.openDirectives.length > 0) {
+        const m = i.openDirectives[i.openDirectives.length - 1];
+        m.bodyBaseIndent < 0 && (m.bodyBaseIndent = a), n.push(Cn(s, m.bodyBaseIndent));
       } else
-        n.push(r);
-      o.level = l;
+        n.push(s);
+      i.level = a;
     }
   }
-  for (; o.openDirectives.length > 0; ) {
-    const i = o.openDirectives.pop();
-    i && n.push(":".repeat(i.colonCount));
+  for (; i.openDirectives.length > 0; ) {
+    const r = i.openDirectives.pop();
+    r && n.push(":".repeat(r.colonCount));
   }
   return n.join(`
 `);
 }
-const Qe = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/, Ge = /^division:\s*(\S+)\s*$/m, Je = /^id:\s*(\S+)\s*$/m, et = /^xmlid:\s*(\S+)\s*$/m, tt = /^xml:id:\s*(\S+)\s*$/m, nt = /^label:\s*(\S+)\s*$/m, ot = /^component:\s*(\S+)\s*$/m, it = /^title:\s*(.+?)\s*$/m;
-function rt(e) {
+const Ln = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/, Nn = /^division:\s*(\S+)\s*$/m, _n = /^id:\s*(\S+)\s*$/m, An = /^xmlid:\s*(\S+)\s*$/m, On = /^xml:id:\s*(\S+)\s*$/m, Mn = /^label:\s*(\S+)\s*$/m, $n = /^component:\s*(\S+)\s*$/m, Rn = /^title:\s*(.+?)\s*$/m;
+function qn(e) {
   if (e.length >= 2) {
     const t = e[0], n = e[e.length - 1];
     if (t === '"' && n === '"' || t === "'" && n === "'")
@@ -933,206 +2269,205 @@ function rt(e) {
   }
   return e;
 }
-function st(e) {
-  const t = e.match(Qe);
+function Fn(e) {
+  const t = e.match(Ln);
   if (!t)
     return { body: e };
-  const n = t[1], o = e.slice(t[0].length), i = n.match(Ge)?.[1];
-  let r, s;
-  i && pe(i) ? (s = i, r = M(i)) : i && V(i) && (r = i);
-  const l = {}, c = n.match(Je)?.[1] ?? n.match(et)?.[1] ?? n.match(tt)?.[1], u = n.match(nt)?.[1], a = n.match(ot)?.[1];
-  c && (l["xml:id"] = c), u && (l.label = u), a && (l.component = a);
-  const p = n.match(it)?.[1], d = p ? rt(p) : void 0;
+  const n = t[1], i = e.slice(t[0].length), r = n.match(Nn)?.[1];
+  let s, c;
+  r && at(r) ? (c = r, s = te(r)) : r && Oe(r) && (s = r);
+  const a = {}, h = n.match(_n)?.[1] ?? n.match(An)?.[1] ?? n.match(On)?.[1], p = n.match(Mn)?.[1], m = n.match($n)?.[1];
+  h && (a["xml:id"] = h), p && (a.label = p), m && (a.component = m);
+  const g = n.match(Rn)?.[1], x = g ? qn(g) : void 0;
   return {
-    division: r,
-    documentRoot: s,
-    attributes: Object.keys(l).length > 0 ? l : void 0,
-    title: d,
-    body: o
+    division: s,
+    documentRoot: c,
+    attributes: Object.keys(a).length > 0 ? a : void 0,
+    title: x,
+    body: i
   };
 }
-const lt = function(e) {
-  return function(n, o) {
-    if (typeof o?.value == "string") {
-      const i = st(o.value), r = e?.documentRoot ?? i.documentRoot, s = e?.topLevelDivision ?? i.division ?? (r ? M(r) : "chapter"), l = e?.topLevelAttributes ?? i.attributes, c = e?.topLevelTitle ?? i.title, u = Ye(
-        i.body
-      ), a = Xe(u), p = Pe(a), g = H().data("micromarkExtensions", [
-        { disable: { null: ["codeIndented"] } }
-      ]).use(X).use(Z).parse(p.markdown);
-      return ze(g, p.tokens), B(g, p.markdown, {
-        topLevelDivision: s,
-        documentRoot: r,
-        topLevelAttributes: l,
-        topLevelTitle: c
+const Pn = function(e) {
+  return function(n, i) {
+    if (typeof i?.value == "string") {
+      const r = Fn(i.value), s = e?.documentRoot ?? r.documentRoot, c = e?.topLevelDivision ?? r.division ?? (s ? te(s) : "chapter"), a = e?.topLevelAttributes ?? r.attributes, h = e?.topLevelTitle ?? r.title, p = Sn(
+        r.body
+      ), m = Dn(p), g = xt(m);
+      return Ie(g.tree, g.source, {
+        topLevelDivision: c,
+        documentRoot: s,
+        topLevelAttributes: a,
+        topLevelTitle: h,
+        restoreSource: g.restoreSource
       });
     }
-    return ne(n), B(n, void 0, {
-      topLevelDivision: e?.topLevelDivision ?? (e?.documentRoot ? M(e.documentRoot) : "chapter"),
+    return je(n), Ie(n, void 0, {
+      topLevelDivision: e?.topLevelDivision ?? (e?.documentRoot ? te(e.documentRoot) : "chapter"),
       documentRoot: e?.documentRoot,
       topLevelAttributes: e?.topLevelAttributes,
       topLevelTitle: e?.topLevelTitle
     });
   };
-}, ct = /["&'<>`]/g, ut = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g, at = (
+}, jn = /["&'<>`]/g, Xn = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g, Bn = (
   // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
   /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g
-), pt = /[|\\{}()[\]^$+*?.]/g, z = /* @__PURE__ */ new WeakMap();
-function ft(e, t) {
+), Un = /[|\\{}()[\]^$+*?.]/g, Se = /* @__PURE__ */ new WeakMap();
+function Yn(e, t) {
   if (e = e.replace(
-    t.subset ? ht(t.subset) : ct,
-    o
+    t.subset ? zn(t.subset) : jn,
+    i
   ), t.subset || t.escapeOnly)
     return e;
-  return e.replace(ut, n).replace(at, o);
-  function n(i, r, s) {
+  return e.replace(Xn, n).replace(Bn, i);
+  function n(r, s, c) {
     return t.format(
-      (i.charCodeAt(0) - 55296) * 1024 + i.charCodeAt(1) - 56320 + 65536,
-      s.charCodeAt(r + 2),
+      (r.charCodeAt(0) - 55296) * 1024 + r.charCodeAt(1) - 56320 + 65536,
+      c.charCodeAt(s + 2),
       t
     );
   }
-  function o(i, r, s) {
+  function i(r, s, c) {
     return t.format(
-      i.charCodeAt(0),
-      s.charCodeAt(r + 1),
+      r.charCodeAt(0),
+      c.charCodeAt(s + 1),
       t
     );
   }
 }
-function ht(e) {
-  let t = z.get(e);
-  return t || (t = dt(e), z.set(e, t)), t;
+function zn(e) {
+  let t = Se.get(e);
+  return t || (t = Jn(e), Se.set(e, t)), t;
 }
-function dt(e) {
+function Jn(e) {
   const t = [];
   let n = -1;
   for (; ++n < e.length; )
-    t.push(e[n].replace(pt, "\\$&"));
+    t.push(e[n].replace(Un, "\\$&"));
   return new RegExp("(?:" + t.join("|") + ")", "g");
 }
-function mt(e) {
+function Wn(e) {
   return "&#x" + e.toString(16).toUpperCase() + ";";
 }
-function gt(e, t) {
-  return ft(e, Object.assign({ format: mt }, t));
+function Vn(e, t) {
+  return Yn(e, Object.assign({ format: Wn }, t));
 }
-const yt = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g;
-function D(e, t, n) {
-  const o = vt(e);
-  return n ? o.replace(n, i) : i(o);
-  function i(r) {
-    return gt(r, { subset: t });
+const Hn = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g;
+function O(e, t, n) {
+  const i = Zn(e);
+  return n ? i.replace(n, r) : r(i);
+  function r(s) {
+    return Vn(s, { subset: t });
   }
 }
-function vt(e) {
-  return String(e || "").replace(yt, "");
+function Zn(e) {
+  return String(e || "").replace(Hn, "");
 }
-const kt = /]]>/g, bt = [">"];
-function Dt(e) {
-  return "<![CDATA[" + D(e.value, bt, kt) + "]]>";
+const Gn = /]]>/g, Kn = [">"];
+function Qn(e) {
+  return "<![CDATA[" + O(e.value, Kn, Gn) + "]]>";
 }
-function Ct(e) {
-  return "<!--" + D(e.value, ["-"]) + "-->";
+function ei(e) {
+  return "<!--" + O(e.value, ["-"]) + "-->";
 }
-const Lt = ["	", `
+const ti = ["	", `
 `, " ", '"', "&", "'", "/", "<", "=", ">"];
-function A(e) {
-  return D(e, Lt);
+function W(e) {
+  return O(e, ti);
 }
-function W(e, t) {
+function Le(e, t) {
   const n = String(e);
   if (typeof t != "string")
     throw new TypeError("Expected character");
-  let o = 0, i = n.indexOf(t);
-  for (; i !== -1; )
-    o++, i = n.indexOf(t, i + t.length);
-  return o;
+  let i = 0, r = n.indexOf(t);
+  for (; r !== -1; )
+    i++, r = n.indexOf(t, r + t.length);
+  return i;
 }
-function _(e, t) {
+function re(e, t) {
   const n = String(e);
-  let o = t.options.quote || '"';
+  let i = t.options.quote || '"';
   if (t.options.quoteSmart) {
-    const i = o === '"' ? "'" : '"';
-    W(n, o) > W(n, i) && (o = i);
+    const r = i === '"' ? "'" : '"';
+    Le(n, i) > Le(n, r) && (i = r);
   }
-  return o + D(n, ["<", "&", o]) + o;
-}
-function xt(e, t) {
-  const n = A(e.name), o = e.public, i = e.system;
-  let r = "<!DOCTYPE";
-  return n !== "" && (r += " " + n), o ? r += " PUBLIC " + _(o, t) : i && (r += " SYSTEM"), i && (r += " " + _(i, t)), r + ">";
-}
-const wt = {}.hasOwnProperty;
-function It(e, t) {
-  const n = A(e.name), o = le(e, t), i = e.attributes || {}, r = o ? !1 : t.options.closeEmptyElements, s = [];
-  let l;
-  for (l in i)
-    if (wt.call(i, l)) {
-      const c = i[l];
-      c != null && s.push(A(l) + "=" + _(c, t));
-    }
-  return "<" + n + (s.length === 0 ? "" : " " + s.join(" ")) + (r ? (t.options.tightClose ? "" : " ") + "/" : "") + ">" + o + (r ? "" : "</" + n + ">");
-}
-const St = /\?>/g, Tt = [">"];
-function Et(e) {
-  const t = A(e.name) || "x", n = D(e.value, Tt, St);
-  return "<?" + t + (n ? " " + n : "") + "?>";
+  return i + O(n, ["<", "&", i]) + i;
+}
+function ni(e, t) {
+  const n = W(e.name), i = e.public, r = e.system;
+  let s = "<!DOCTYPE";
+  return n !== "" && (s += " " + n), i ? s += " PUBLIC " + re(i, t) : r && (s += " SYSTEM"), r && (s += " " + re(r, t)), s + ">";
+}
+const ii = {}.hasOwnProperty;
+function ri(e, t) {
+  const n = W(e.name), i = tt(e, t), r = e.attributes || {}, s = i ? !1 : t.options.closeEmptyElements, c = [];
+  let a;
+  for (a in r)
+    if (ii.call(r, a)) {
+      const h = r[a];
+      h != null && c.push(W(a) + "=" + re(h, t));
+    }
+  return "<" + n + (c.length === 0 ? "" : " " + c.join(" ")) + (s ? (t.options.tightClose ? "" : " ") + "/" : "") + ">" + i + (s ? "" : "</" + n + ">");
 }
-const qt = ["&", "<"];
-function re(e) {
-  return D(e.value, qt);
+const si = /\?>/g, oi = [">"];
+function li(e) {
+  const t = W(e.name) || "x", n = O(e.value, oi, si);
+  return "<?" + t + (n ? " " + n : "") + "?>";
 }
-function At(e, t) {
-  return t.options.allowDangerousXml ? e.value : re(e);
-}
-const $t = {}.hasOwnProperty, U = {
-  cdata: Dt,
-  comment: Ct,
-  doctype: xt,
-  element: It,
-  instruction: Et,
-  raw: At,
-  root: le,
-  text: re
+const ci = ["&", "<"];
+function Qe(e) {
+  return O(e.value, ci);
+}
+function ai(e, t) {
+  return t.options.allowDangerousXml ? e.value : Qe(e);
+}
+const ui = {}.hasOwnProperty, Ne = {
+  cdata: Qn,
+  comment: ei,
+  doctype: ni,
+  element: ri,
+  instruction: li,
+  raw: ai,
+  root: tt,
+  text: Qe
 };
-function se(e, t) {
+function et(e, t) {
   const n = e && e.type;
   if (!n)
     throw new Error("Expected node, not `" + e + "`");
-  if (!$t.call(U, n))
+  if (!ui.call(Ne, n))
     throw new Error("Cannot compile unknown node `" + n + "`");
-  const o = U[n];
-  return o(e, t);
+  const i = Ne[n];
+  return i(e, t);
 }
-function le(e, t) {
+function tt(e, t) {
   const n = e && e.children || [];
-  let o = -1;
-  const i = [];
-  for (; ++o < n.length; )
-    i[o] = se(n[o], t);
-  return i.join("");
+  let i = -1;
+  const r = [];
+  for (; ++i < n.length; )
+    r[i] = et(n[i], t);
+  return r.join("");
 }
-function Rt(e, t) {
+function hi(e, t) {
   const n = { options: t || {} };
   if (typeof n.options.quote == "string" && n.options.quote !== '"' && n.options.quote !== "'")
     throw new Error(
       "Invalid quote `" + n.options.quote + "`, expected `'` or `\"`"
     );
-  const o = Array.isArray(e) ? { type: "root", children: e } : e;
-  return se(o, n);
+  const i = Array.isArray(e) ? { type: "root", children: e } : e;
+  return et(i, n);
 }
-function Bt(e, t) {
-  const n = H().use(X).use(Z).use(lt, t), o = n.parse(e), i = n.runSync(o, { value: e });
-  return Rt(i.children, {
+function bi(e, t) {
+  const n = se().use(oe).use(_e).use(Pn, t), i = n.parse(e), r = n.runSync(i, { value: e });
+  return hi(r.children, {
     closeEmptyElements: !0,
     tightClose: !0
   });
 }
 export {
-  Pt as DIRECTIVE_MAP,
-  Y as PROOF_SOLUTION_NAMES,
-  Bt as markdownToPretext,
-  B as mdastToPtxast,
-  jt as remarkMath,
-  lt as remarkPretext
+  vi as DIRECTIVE_MAP,
+  We as PROOF_SOLUTION_NAMES,
+  bi as markdownToPretext,
+  Ie as mdastToPtxast,
+  yi as remarkMath,
+  Pn as remarkPretext
 };