@pretextbook/remark-pretext 0.0.1 → 0.0.3

package/dist/index.js

@@ -0,0 +1,796 @@
+import { unified as _ } from "unified";
+import R from "remark-parse";
+import j from "remark-directive";
+import { visit as z } from "unist-util-visit";
+const q = {
+  // theorem-like (requires statement wrapping)
+  theorem: { type: "theorem", category: "theorem-like", requiresStatement: !0 },
+  lemma: { type: "lemma", category: "theorem-like", requiresStatement: !0 },
+  corollary: { type: "corollary", category: "theorem-like", requiresStatement: !0 },
+  proposition: { type: "proposition", category: "theorem-like", requiresStatement: !0 },
+  claim: { type: "claim", category: "theorem-like", requiresStatement: !0 },
+  fact: { type: "fact", category: "theorem-like", requiresStatement: !0 },
+  conjecture: { type: "conjecture", category: "theorem-like", requiresStatement: !0 },
+  axiom: { type: "axiom", category: "theorem-like", requiresStatement: !0 },
+  principle: { type: "principle", category: "theorem-like", requiresStatement: !0 },
+  hypothesis: { type: "hypothesis", category: "theorem-like", requiresStatement: !0 },
+  algorithm: { type: "algorithm", category: "theorem-like", requiresStatement: !0 },
+  // definition-like (requires statement wrapping)
+  definition: { type: "definition", category: "definition-like", requiresStatement: !0 },
+  notation: { type: "notation", category: "definition-like", requiresStatement: !0 },
+  // remark-like (no statement wrapping)
+  remark: { type: "remark", category: "remark-like", requiresStatement: !1 },
+  note: { type: "note", category: "remark-like", requiresStatement: !1 },
+  observation: { type: "observation", category: "remark-like", requiresStatement: !1 },
+  warning: { type: "warning", category: "remark-like", requiresStatement: !1 },
+  insight: { type: "insight", category: "remark-like", requiresStatement: !1 },
+  assemblage: { type: "assemblage", category: "remark-like", requiresStatement: !1 },
+  // example-like (exercise/project/task support nested tasks; require statement if no nested tasks)
+  example: { type: "example", category: "example-like", requiresStatement: !1 },
+  question: { type: "question", category: "example-like", requiresStatement: !1 },
+  problem: { type: "problem", category: "example-like", requiresStatement: !1 },
+  exercise: { type: "exercise", category: "example-like", requiresStatement: !0, hasNestedTasks: !0 },
+  activity: { type: "activity", category: "example-like", requiresStatement: !1 },
+  exploration: { type: "exploration", category: "example-like", requiresStatement: !1 },
+  investigation: { type: "investigation", category: "example-like", requiresStatement: !1 },
+  project: { type: "project", category: "example-like", requiresStatement: !0, hasNestedTasks: !0 },
+  // task (can have nested tasks, requires statement if no nested tasks)
+  task: { type: "task", category: "example-like", requiresStatement: !0, hasNestedTasks: !0 },
+  // proof-like (no statement wrapping)
+  proof: { type: "proof", category: "proof-like", requiresStatement: !1 },
+  case: { type: "case", category: "proof-like", requiresStatement: !1 },
+  // solution-like (no statement wrapping)
+  solution: { type: "solution", category: "solution-like", requiresStatement: !1 },
+  hint: { type: "hint", category: "solution-like", requiresStatement: !1 },
+  answer: { type: "answer", category: "solution-like", requiresStatement: !1 }
+}, pt = q;
+function ne(e) {
+  return q[e.toLowerCase()];
+}
+const W = new Set(
+  Object.entries(q).filter(([e, t]) => t.category === "proof-like" || t.category === "solution-like").map(([e]) => e)
+);
+function v(e, t, n) {
+  return {
+    type: "element",
+    name: e,
+    attributes: n ?? {},
+    children: t
+  };
+}
+function C(e) {
+  return e.type === "containerDirective" && e.name === "task";
+}
+function re(e) {
+  return e.type === "containerDirective" && W.has(e.name);
+}
+function D(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(v("p", [n])) : t.push(n);
+  return t;
+}
+function oe(e, t, n, r, o, s, i) {
+  const l = [];
+  if (n && l.push(n), e.hasNestedTasks) {
+    const c = r.findIndex(C);
+    if (c !== -1) {
+      const a = [];
+      for (let u = 0; u < r.length; u++)
+        C(r[u]) && a.push(u);
+      const f = a[a.length - 1], d = r.slice(0, c), m = r.slice(c).filter(C), k = [], g = [], L = [];
+      for (let u = c; u < r.length; u++) {
+        const p = r[u];
+        if (!C(p)) {
+          if (u < f) {
+            k.push(p);
+            continue;
+          }
+          if (re(p)) {
+            L.push(p);
+            continue;
+          }
+          g.push(p);
+        }
+      }
+      if (k.length > 0 && (o.messages ?? (o.messages = [])).push({
+        type: "warning",
+        reason: `Dropped ${k.length} non-task node(s) between task directives in ${e.type}.`,
+        category: "dropped-content-between-tasks",
+        position: k[0].position?.start
+      }), d.length > 0) {
+        const u = D(
+          d.map((p) => s(p, o)).filter((p) => p !== null)
+        );
+        u.length > 0 && l.push(v("introduction", u));
+      }
+      for (const u of m) {
+        const p = i(u, o);
+        p && l.push(p);
+      }
+      if (g.length > 0) {
+        const u = D(
+          g.map((p) => s(p, o)).filter((p) => p !== null)
+        );
+        u.length > 0 && l.push(v("conclusion", u));
+      }
+      for (const u of L) {
+        const p = i(u, o);
+        p && l.push(p);
+      }
+    } else
+      F(l, e, r, o, s, i);
+  } else
+    F(l, e, r, o, s, i);
+  return v(e.type, l, t);
+}
+function F(e, t, n, r, o, s) {
+  if (t.requiresStatement) {
+    const i = [], l = [];
+    for (const c of n)
+      if (c.type === "containerDirective" && W.has(c.name)) {
+        const a = s(c, r);
+        a && l.push(a);
+      } else
+        i.push(c);
+    if (i.length > 0) {
+      const c = D(
+        i.map((a) => o(a, r)).filter((a) => a !== null)
+      );
+      c.length > 0 && e.push(v("statement", c));
+    }
+    e.push(...l);
+  } else {
+    const i = D(
+      n.map((l) => o(l, r)).filter((l) => l !== null)
+    );
+    e.push(...i);
+  }
+}
+function B(e) {
+  return { type: "text", value: e };
+}
+function h(e, t, n) {
+  return {
+    type: "element",
+    name: e,
+    attributes: n ?? {},
+    children: t
+  };
+}
+function x(e, t, n) {
+  return h(e, [B(t)], n);
+}
+function H(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);
+  return t;
+}
+function $(e, t) {
+  return se(e, t).tree;
+}
+function se(e, t) {
+  const n = [], r = { ancestors: [], depth: 0, messages: n, source: t }, o = e.children;
+  return {
+    tree: { type: "root", children: U(o, r) },
+    messages: n
+  };
+}
+const N = ["chapter", "section", "subsection", "subsubsection", "paragraphs"];
+function ie(e) {
+  return N[Math.min(e - 1, N.length - 1)];
+}
+function U(e, t, n = !1) {
+  let r = 7;
+  for (const a of e)
+    a.type === "heading" && (r = Math.min(r, a.depth));
+  if (r === 7)
+    return w(e, t, n);
+  const o = [];
+  let s = null, i = [], l = [];
+  const c = () => {
+    s && (o.push(le(s, l, t)), s = null, l = []);
+  };
+  for (const a of e)
+    a.type === "heading" && a.depth === r ? (!s && i.length > 0 && (o.push(...w(i, t, n)), i = []), c(), s = a, l = []) : s ? l.push(a) : i.push(a);
+  return !s && i.length > 0 && o.push(...w(i, t, n)), c(), o;
+}
+function w(e, t, n = !1) {
+  const r = [];
+  for (let o = 0; o < e.length; o += 1) {
+    const s = e[o], i = T(s, t);
+    if (i !== null) {
+      if (i.name === "p" && i.children.length === 1 && i.children[0].name === "md") {
+        const l = i.children[0], c = r[r.length - 1], a = o + 1 < e.length ? T(e[o + 1], t) : null, f = a?.name === "p" ? a.children : null;
+        if (c?.name === "p")
+          c.children.push(l), f && (c.children.push(...f), o += 1);
+        else {
+          const d = [l];
+          f && (d.push(...f), o += 1), r.push(h("p", d));
+        }
+        continue;
+      }
+      if ((i.name === "ul" || i.name === "ol") && r.length > 0) {
+        const l = r[r.length - 1];
+        if (l?.name === "p") {
+          l.children.push(i);
+          continue;
+        }
+      }
+      r.push(i);
+    }
+  }
+  return n ? H(r) : r;
+}
+function le(e, t, n) {
+  const r = ie(e.depth), o = h("title", b(e.children, n)), s = ce(e), i = U(t, { ...n, depth: n.depth + 1 }, !0), l = H(i);
+  return h(r, [o, ...l], s);
+}
+function ce(e) {
+  const t = e.data;
+  return t?.id ? { "xml:id": t.id } : void 0;
+}
+const ae = {
+  paragraph: (e, t) => Z(e, t),
+  blockquote: (e, t) => ue(e, t),
+  list: (e, t) => pe(e, t),
+  code: (e, t) => he(e),
+  containerDirective: (e, t) => X(e, t)
+};
+function T(e, t) {
+  const n = ae[e.type];
+  return n ? n(e, t) : (t.messages && t.messages.push({
+    type: "warning",
+    reason: `Unknown block type: ${e.type}`,
+    category: "unknown-block-type"
+  }), null);
+}
+function Z(e, t) {
+  return h("p", b(e.children, t));
+}
+function ue(e, t) {
+  const n = e.children.filter((r) => r.type === "paragraph").map((r) => {
+    const o = { ...t, ancestors: [...t.ancestors, e], depth: t.depth + 1 };
+    return Z(r, o);
+  });
+  return h("blockquote", n);
+}
+function pe(e, t) {
+  const n = e.children.map((r) => {
+    const o = { ...t, ancestors: [...t.ancestors, e], depth: t.depth + 1 };
+    return fe(r, o);
+  });
+  return h(e.ordered ? "ol" : "ul", n);
+}
+function fe(e, t) {
+  const n = w(e.children, t);
+  return h("li", n);
+}
+function he(e, t) {
+  return x("program", e.value, e.lang ? { language: e.lang } : void 0);
+}
+function de(e, t) {
+  const n = e.value.split(/\\\\|[\r\n]+/).map((r) => r.trim()).filter((r) => r.length > 0);
+  return n.length > 1 ? h("md", n.map((r) => x("mrow", r))) : x("md", n[0] ?? "");
+}
+function me(e, t) {
+  return e.meta === "inline" ? x("m", e.value) : de(e);
+}
+function X(e, t) {
+  const n = ne(e.name);
+  if (!n)
+    return t.messages && t.messages.push({
+      type: "warning",
+      reason: `Unknown directive: ${e.name}`,
+      category: "unknown-directive"
+    }), null;
+  const r = ye(e), o = e.children, { title: s, body: i } = ge(o, t), l = { ...t, ancestors: [...t.ancestors, e], depth: t.depth + 1 };
+  return oe(
+    n,
+    r,
+    s,
+    i,
+    l,
+    (c, a) => T(c, a),
+    (c, a) => X(c, a)
+  );
+}
+function ge(e, t) {
+  const n = e[0];
+  return n?.type === "paragraph" && n.data?.directiveLabel === !0 ? {
+    title: h("title", b(n.children, t)),
+    body: e.slice(1)
+  } : { title: null, body: e };
+}
+function ye(e) {
+  const t = e.attributes ?? {}, n = {};
+  for (const [r, o] of Object.entries(t))
+    o != null && (n[r === "id" ? "xml:id" : r] = o);
+  return Object.keys(n).length > 0 ? n : void 0;
+}
+function ke(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 ve = {
+  text: (e, t) => B(e.value),
+  emphasis: (e, t) => {
+    const r = ke(e, t.source) === "underscore" ? "term" : "em";
+    return h(r, b(e.children, t));
+  },
+  strong: (e, t) => h("alert", b(e.children, t)),
+  inlineCode: (e, t) => x("c", e.value),
+  math: (e, t) => me(e)
+};
+function b(e, t) {
+  return e.flatMap((n) => xe(n, t)).filter((n) => n !== null);
+}
+function xe(e, t) {
+  const n = ve[e.type];
+  if (!n)
+    return t.messages && t.messages.push({
+      type: "warning",
+      reason: `Unknown inline type: ${e.type}`,
+      category: "unknown-inline-type"
+    }), null;
+  const r = { ...t, ancestors: [...t.ancestors, e] };
+  return n(e, r);
+}
+const be = [
+  // 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 }
+], K = "PTX_MATH_TOKEN_", I = new RegExp(`${K}(\\d+)`, "g");
+function Y(e, t) {
+  let n = null;
+  for (const r of be) {
+    const o = e.indexOf(r.open, t);
+    if (o === -1) continue;
+    const s = e.indexOf(r.close, o + r.open.length);
+    if (s !== -1 && !(r.open === "$" && (o > 0 && e[o - 1] === "$" || o + 1 < e.length && e[o + 1] === "$")) && (!n || o < n.index)) {
+      const i = e.substring(o + r.open.length, s);
+      n = { index: o, pattern: r, content: i };
+    }
+  }
+  return n;
+}
+function Ce(e, t) {
+  let n = t;
+  for (; n < e.length; ) {
+    const r = e.indexOf("`", n);
+    if (r === -1) return null;
+    let o = 0, s = r;
+    for (; s < e.length && e[s] === "`"; )
+      o++, s++;
+    const i = "`".repeat(o);
+    let l = s;
+    for (; l < e.length; ) {
+      const c = e.indexOf(i, l);
+      if (c === -1) break;
+      const a = c + o;
+      if (a >= e.length || e[a] !== "`")
+        return { start: r, end: a };
+      l = c + 1;
+    }
+    n = r + o;
+  }
+  return null;
+}
+function we(e) {
+  const t = /* @__PURE__ */ new Map();
+  let n = "", r = 0, o = 0;
+  for (; r < e.length; ) {
+    const s = Ce(e, r), i = Y(e, r);
+    if (s && (!i || s.start < i.index)) {
+      n += e.substring(r, s.end), r = s.end;
+      continue;
+    }
+    if (!i) {
+      n += e.substring(r);
+      break;
+    }
+    n += e.substring(r, i.index);
+    const l = `${K}${o}`;
+    n += l, t.set(l, {
+      type: "math",
+      value: i.content,
+      meta: i.pattern.isDisplay ? "display" : "inline"
+    }), r = i.index + i.pattern.open.length + i.content.length + i.pattern.close.length, o += 1;
+  }
+  return { markdown: n, tokens: t };
+}
+function De(e) {
+  const t = [];
+  let n = 0;
+  for (; n < e.length; ) {
+    const r = Y(e, n);
+    if (!r) {
+      n < e.length && t.push({ type: "text", value: e.substring(n) });
+      break;
+    }
+    r.index > n && t.push({
+      type: "text",
+      value: e.substring(n, r.index)
+    }), t.push({
+      type: "math",
+      value: r.content,
+      meta: r.pattern.isDisplay ? "display" : "inline"
+    }), n = r.index + r.pattern.open.length + r.content.length + r.pattern.close.length;
+  }
+  return t.length === 0 ? [{ type: "text", value: e }] : t;
+}
+function Se(e, t) {
+  const n = [];
+  let r = 0;
+  I.lastIndex = 0;
+  let o = I.exec(e);
+  for (; o; ) {
+    const s = o.index, i = o[0];
+    s > r && n.push({ type: "text", value: e.substring(r, s) });
+    const l = t.get(i);
+    l ? n.push(l) : n.push({ type: "text", value: i }), r = s + i.length, o = I.exec(e);
+  }
+  return r < e.length && n.push({ type: "text", value: e.substring(r) }), n.length === 0 ? [{ type: "text", value: e }] : n;
+}
+function V(e) {
+  z(e, "paragraph", (t) => {
+    const n = t.children || [], r = [];
+    for (const o of n)
+      if (o.type === "text") {
+        const s = De(o.value);
+        r.push(...s);
+      } else
+        r.push(o);
+    t.children = r;
+  });
+}
+function qe(e, t) {
+  z(e, "paragraph", (n) => {
+    const r = n.children || [], o = [];
+    for (const s of r)
+      if (s.type === "text") {
+        const i = Se(s.value, t);
+        o.push(...i);
+      } else
+        o.push(s);
+    n.children = o;
+  });
+}
+const ft = () => (e) => {
+  V(e);
+};
+function Ie(e) {
+  const t = e.trim();
+  if (!t.startsWith(":")) return null;
+  let n = 0;
+  for (let s = 0; s < t.length && t[s] === ":"; s++)
+    n++;
+  if (n < 3) return null;
+  const r = t.slice(n).trim(), o = r.match(/^([a-zA-Z0-9_-]+)(\[[^\]]*\])?(\{[^}]*\})?$/);
+  return r === "" ? { colons: n, label: null, lineIndex: -1, isOpen: !1 } : o ? { colons: n, label: o[0], lineIndex: -1, isOpen: !0 } : null;
+}
+function Te(e) {
+  const t = [], n = [];
+  for (const r of e)
+    if (r.isOpen) {
+      const o = {
+        colons: r.colons,
+        finalColons: r.colons,
+        label: r.label,
+        openLineIndex: r.lineIndex,
+        closeLineIndex: null,
+        children: [],
+        parent: null
+      };
+      if (t.length > 0) {
+        const s = t[t.length - 1];
+        o.parent = s, s.children.push(o);
+      } else
+        n.push(o);
+      t.push(o);
+    } else {
+      const o = t[t.length - 1];
+      o && o.colons === r.colons && (o.closeLineIndex = r.lineIndex, t.pop());
+    }
+  return n;
+}
+function G(e) {
+  if (e.children.length === 0)
+    e.finalColons = e.colons;
+  else {
+    const t = Math.max(...e.children.map(G));
+    e.finalColons = Math.max(e.colons, t + 1);
+  }
+  return e.finalColons;
+}
+function Ee(e, t, n) {
+  const r = e.slice(), o = [], s = t.slice();
+  for (; s.length > 0; ) {
+    const i = s.shift();
+    o.push(i), s.push(...i.children);
+  }
+  for (const i of o) {
+    if (i.openLineIndex >= 0) {
+      const l = r[i.openLineIndex], c = l.match(/^:+/)?.[0].length || 3, a = l.slice(c);
+      r[i.openLineIndex] = ":".repeat(i.finalColons) + a;
+    }
+    i.closeLineIndex !== null && i.closeLineIndex >= 0 && (r[i.closeLineIndex] = ":".repeat(i.finalColons));
+  }
+  return r;
+}
+function Me(e) {
+  const t = e.split(`
+`), n = [];
+  let r = !1, o = null;
+  for (let l = 0; l < t.length; l++) {
+    const c = t[l], f = c.trim().match(/^(`{3,}|~{3,})/);
+    if (f) {
+      const m = f[1];
+      r ? o && m[0] === o[0] && m.length >= o.length && (r = !1, o = null) : (r = !0, o = m);
+      continue;
+    }
+    if (r)
+      continue;
+    const d = Ie(c);
+    d && n.push({ ...d, lineIndex: l });
+  }
+  if (n.length === 0)
+    return e;
+  const s = Te(n);
+  for (const l of s)
+    G(l);
+  return Ee(t, s).join(`
+`);
+}
+function Le(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 r = n.match(/^([a-zA-Z][a-zA-Z0-9_-]*)(.*)$/);
+  if (!r) return null;
+  const [, o, s] = r;
+  return s && !/^(\[[^\]]*\]|\{[^}]*\})*$/.test(s) || !q[o.toLowerCase()] ? null : n;
+}
+function E(e) {
+  let t = 0;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] === " ")
+      t += 1;
+    else if (e[n] === "	")
+      t += 4;
+    else
+      break;
+  return t;
+}
+function Fe(e, t) {
+  const n = E(e[t]);
+  for (let r = t + 1; r < e.length; r++)
+    if (!J(e[r]))
+      return E(e[r]) > n;
+  return !1;
+}
+function J(e) {
+  return e.trim() === "";
+}
+function $e(e) {
+  const t = e.split(`
+`), n = [], r = {
+    level: 0,
+    openDirectives: [],
+    inCodeFence: !1,
+    codeFenceMarker: null
+  };
+  for (let o = 0; o < t.length; o++) {
+    const s = t[o], i = s.trim(), l = E(s), c = i.match(/^(`{3,}|~{3,})/);
+    if (c) {
+      const f = c[1];
+      r.inCodeFence ? r.codeFenceMarker && i.startsWith(r.codeFenceMarker) && (r.inCodeFence = !1, r.codeFenceMarker = null) : (r.inCodeFence = !0, r.codeFenceMarker = f), n.push(s);
+      continue;
+    }
+    if (r.inCodeFence) {
+      n.push(s);
+      continue;
+    }
+    if (J(s)) {
+      n.push("");
+      continue;
+    }
+    const a = Le(i);
+    if (a && Fe(t, o)) {
+      for (; r.openDirectives.length > 0 && !(r.openDirectives[r.openDirectives.length - 1].indentLevel < l); ) {
+        const g = r.openDirectives.pop();
+        g && n.push(":".repeat(g.colonCount));
+      }
+      const f = a.match(/^([a-zA-Z][a-zA-Z0-9_-]*)(.*)/), d = f ? f[1].toLowerCase() + (f[2] || "") : a, m = r.openDirectives.length * 1 + 3;
+      n.push(":".repeat(m) + d), r.openDirectives.push({
+        label: d,
+        indentLevel: l,
+        colonCount: m
+      }), r.level = l;
+    } else {
+      for (; r.openDirectives.length > 0 && l <= r.openDirectives[r.openDirectives.length - 1].indentLevel; ) {
+        const f = r.openDirectives.pop();
+        f && n.push(":".repeat(f.colonCount));
+      }
+      r.openDirectives.length > 0, n.push(s), r.level = l;
+    }
+  }
+  for (; r.openDirectives.length > 0; ) {
+    const o = r.openDirectives.pop();
+    o && n.push(":".repeat(o.colonCount));
+  }
+  return n.join(`
+`);
+}
+const Ne = function() {
+  return function(t, n) {
+    if (typeof n?.value == "string") {
+      const r = $e(n.value), o = Me(r), s = we(o), l = _().use(R).use(j).parse(s.markdown);
+      return qe(l, s.tokens), $(l, s.markdown);
+    }
+    return V(t), $(t);
+  };
+}, Ae = /["&'<>`]/g, Oe = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g, Pe = (
+  // 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
+), _e = /[|\\{}()[\]^$+*?.]/g, A = /* @__PURE__ */ new WeakMap();
+function Re(e, t) {
+  if (e = e.replace(
+    t.subset ? je(t.subset) : Ae,
+    r
+  ), t.subset || t.escapeOnly)
+    return e;
+  return e.replace(Oe, n).replace(Pe, r);
+  function n(o, s, i) {
+    return t.format(
+      (o.charCodeAt(0) - 55296) * 1024 + o.charCodeAt(1) - 56320 + 65536,
+      i.charCodeAt(s + 2),
+      t
+    );
+  }
+  function r(o, s, i) {
+    return t.format(
+      o.charCodeAt(0),
+      i.charCodeAt(s + 1),
+      t
+    );
+  }
+}
+function je(e) {
+  let t = A.get(e);
+  return t || (t = ze(e), A.set(e, t)), t;
+}
+function ze(e) {
+  const t = [];
+  let n = -1;
+  for (; ++n < e.length; )
+    t.push(e[n].replace(_e, "\\$&"));
+  return new RegExp("(?:" + t.join("|") + ")", "g");
+}
+function We(e) {
+  return "&#x" + e.toString(16).toUpperCase() + ";";
+}
+function Be(e, t) {
+  return Re(e, Object.assign({ format: We }, t));
+}
+const He = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g;
+function y(e, t, n) {
+  const r = Ue(e);
+  return n ? r.replace(n, o) : o(r);
+  function o(s) {
+    return Be(s, { subset: t });
+  }
+}
+function Ue(e) {
+  return String(e || "").replace(He, "");
+}
+const Ze = /]]>/g, Xe = [">"];
+function Ke(e) {
+  return "<![CDATA[" + y(e.value, Xe, Ze) + "]]>";
+}
+function Ye(e) {
+  return "<!--" + y(e.value, ["-"]) + "-->";
+}
+const Ve = ["	", `
+`, " ", '"', "&", "'", "/", "<", "=", ">"];
+function S(e) {
+  return y(e, Ve);
+}
+function O(e, t) {
+  const n = String(e);
+  if (typeof t != "string")
+    throw new TypeError("Expected character");
+  let r = 0, o = n.indexOf(t);
+  for (; o !== -1; )
+    r++, o = n.indexOf(t, o + t.length);
+  return r;
+}
+function M(e, t) {
+  const n = String(e);
+  let r = t.options.quote || '"';
+  if (t.options.quoteSmart) {
+    const o = r === '"' ? "'" : '"';
+    O(n, r) > O(n, o) && (r = o);
+  }
+  return r + y(n, ["<", "&", r]) + r;
+}
+function Ge(e, t) {
+  const n = S(e.name), r = e.public, o = e.system;
+  let s = "<!DOCTYPE";
+  return n !== "" && (s += " " + n), r ? s += " PUBLIC " + M(r, t) : o && (s += " SYSTEM"), o && (s += " " + M(o, t)), s + ">";
+}
+const Je = {}.hasOwnProperty;
+function Qe(e, t) {
+  const n = S(e.name), r = te(e, t), o = e.attributes || {}, s = r ? !1 : t.options.closeEmptyElements, i = [];
+  let l;
+  for (l in o)
+    if (Je.call(o, l)) {
+      const c = o[l];
+      c != null && i.push(S(l) + "=" + M(c, t));
+    }
+  return "<" + n + (i.length === 0 ? "" : " " + i.join(" ")) + (s ? (t.options.tightClose ? "" : " ") + "/" : "") + ">" + r + (s ? "" : "</" + n + ">");
+}
+const et = /\?>/g, tt = [">"];
+function nt(e) {
+  const t = S(e.name) || "x", n = y(e.value, tt, et);
+  return "<?" + t + (n ? " " + n : "") + "?>";
+}
+const rt = ["&", "<"];
+function Q(e) {
+  return y(e.value, rt);
+}
+function ot(e, t) {
+  return t.options.allowDangerousXml ? e.value : Q(e);
+}
+const st = {}.hasOwnProperty, P = {
+  cdata: Ke,
+  comment: Ye,
+  doctype: Ge,
+  element: Qe,
+  instruction: nt,
+  raw: ot,
+  root: te,
+  text: Q
+};
+function ee(e, t) {
+  const n = e && e.type;
+  if (!n)
+    throw new Error("Expected node, not `" + e + "`");
+  if (!st.call(P, n))
+    throw new Error("Cannot compile unknown node `" + n + "`");
+  const r = P[n];
+  return r(e, t);
+}
+function te(e, t) {
+  const n = e && e.children || [];
+  let r = -1;
+  const o = [];
+  for (; ++r < n.length; )
+    o[r] = ee(n[r], t);
+  return o.join("");
+}
+function it(e, t) {
+  const n = { options: {} };
+  if (typeof n.options.quote == "string" && n.options.quote !== '"' && n.options.quote !== "'")
+    throw new Error(
+      "Invalid quote `" + n.options.quote + "`, expected `'` or `\"`"
+    );
+  const r = Array.isArray(e) ? { type: "root", children: e } : e;
+  return ee(r, n);
+}
+function ht(e) {
+  const t = _().use(R).use(j).use(Ne), n = t.parse(e), r = t.runSync(n, { value: e });
+  return it(r.children);
+}
+export {
+  pt as DIRECTIVE_MAP,
+  W as PROOF_SOLUTION_NAMES,
+  ht as markdownToPretext,
+  $ as mdastToPtxast,
+  ft as remarkMath,
+  Ne as remarkPretext
+};