@pretextbook/pretext-html 0.1.1 → 0.3.0

package/dist/cli-CzoinNle.js

@@ -0,0 +1,639 @@
+import { readFile as A, writeFile as C } from "node:fs/promises";
+import * as w from "node:process";
+import * as a from "node:path";
+import { fileURLToPath as fe } from "node:url";
+import { fromXml as v } from "xast-util-from-xml";
+import { toXml as $ } from "xast-util-to-xml";
+import { injectThemeBridge as he } from "./theme.js";
+async function V(e, r) {
+  const t = a.resolve(e), n = a.resolve(t, `.${a.posix.normalize(r)}`);
+  if (n !== t && !n.startsWith(t + a.sep)) {
+    console.error(
+      `pretext-html: refusing to serve ${r} from outside ${t}`
+    );
+    return;
+  }
+  try {
+    return new Uint8Array(await A(n));
+  } catch {
+    return;
+  }
+}
+async function X(e) {
+  try {
+    return await A(e, "utf8");
+  } catch {
+    return;
+  }
+}
+let Z;
+function qe(e) {
+  Z = e;
+}
+function I() {
+  return Z ?? process.env.PRETEXT_HTML_ASSETS ?? a.resolve(a.dirname(fe(import.meta.url)), "..", "assets");
+}
+function me(e, r) {
+  return a.join(e, r);
+}
+const j = /* @__PURE__ */ new Map(), K = /* @__PURE__ */ new Map();
+let M, pe = 0, ee = V;
+function Ge(e) {
+  ee = e;
+}
+function we(e, r) {
+  const t = typeof e == "string" ? e : e instanceof URL ? e.href : e.url, n = K.get(t);
+  if (n !== void 0)
+    return Promise.resolve(new Response(n, { status: 200 }));
+  let o;
+  try {
+    o = new URL(t).host;
+  } catch {
+    o = "";
+  }
+  const i = j.get(o);
+  return i !== void 0 ? ge(i, t) : M(e, r);
+}
+const be = '<?xml version="1.0"?><pretext-preview-missing-file/>';
+async function ge(e, r) {
+  const t = decodeURIComponent(new URL(r).pathname), n = await ee(e, t);
+  if (n === void 0)
+    return new Response(be, { status: 200 });
+  const o = typeof n == "string" ? n : new Uint8Array(n);
+  return new Response(o, { status: 200 });
+}
+function te() {
+  M || (M = globalThis.fetch, globalThis.fetch = we);
+}
+function re(e) {
+  te();
+  const r = `mnt${++pe}.ptx.invalid`;
+  return j.set(r, e), `http://${r}`;
+}
+function ye(e) {
+  j.delete(new URL(e).host);
+}
+function xe(e, r) {
+  te(), K.set(e, r);
+}
+const ne = `<?xml version="1.0" encoding="UTF-8"?>
+<publication>
+  <source>
+    <directories external="../assets" generated="../generated-assets" />
+  </source>
+  <html>
+    <platform portable="yes"/>
+  </html>
+</publication>
+`;
+function y(e, r) {
+  for (const t of e.children)
+    if (t.type === "element" && t.name === r)
+      return t;
+}
+function B(e, r) {
+  let t = y(e, r);
+  return t || (t = { type: "element", name: r, attributes: {}, children: [] }, e.children.push(t)), t;
+}
+function O(e) {
+  if (!e)
+    return ne;
+  const r = v(e), t = y(r, "publication");
+  if (!t)
+    throw new Error(
+      "Invalid publication file: no root <publication> element found"
+    );
+  const n = B(t, "html"), o = B(n, "platform");
+  return o.attributes = { ...o.attributes, portable: "yes" }, $(r);
+}
+function N(e) {
+  if (!(e === void 0 || e === "" || e.startsWith("/")))
+    return e.endsWith("/") ? e : `${e}/`;
+}
+function ve(e) {
+  const r = v(e ?? ne), t = y(r, "publication"), n = t && y(t, "source"), o = n && y(n, "directories"), i = N(
+    o?.attributes?.external ?? void 0
+  ), c = N(
+    o?.attributes?.generated ?? void 0
+  );
+  return {
+    external: i,
+    generated: c,
+    managed: i !== void 0 && c !== void 0
+  };
+}
+const oe = "http://www.w3.org/2001/XInclude", _ = 64;
+async function Ee(e, r, t) {
+  return e.includes("include") ? (await ie(e, r, t)).content : e;
+}
+async function ie(e, r, t) {
+  const n = v(e), o = {
+    projectDir: a.resolve(t),
+    stack: [a.resolve(r)]
+  }, i = await x(
+    n,
+    a.dirname(a.resolve(r)),
+    { "": "" },
+    o
+  );
+  return { tree: n, content: i ? $(n) : e };
+}
+function $e(e) {
+  return e.data?.ptxIncludedFile;
+}
+function Pe(e, r) {
+  const t = e.data ?? (e.data = {});
+  t.ptxIncludedFile = r;
+}
+function P(e, r) {
+  let t = e;
+  for (const [n, o] of Object.entries(r.attributes))
+    (n === "xmlns" || n.startsWith("xmlns:")) && (t === e && (t = { ...e }), t[n === "xmlns" ? "" : n.slice(6)] = o ?? "");
+  return t;
+}
+function se(e, r) {
+  const t = e.name.indexOf(":"), n = t === -1 ? "" : e.name.slice(0, t);
+  return (t === -1 ? e.name : e.name.slice(t + 1)) === "include" && r[n] === oe;
+}
+async function x(e, r, t, n) {
+  let o = !1;
+  for (let i = 0; i < e.children.length; i++) {
+    const c = e.children[i];
+    if (c.type !== "element")
+      continue;
+    const s = P(t, c);
+    if (se(c, s)) {
+      const u = await ae(
+        c,
+        r,
+        s,
+        n
+      );
+      e.children.splice(i, 1, ...u), i += u.length - 1, o = !0;
+    } else await x(c, r, s, n) && (o = !0);
+  }
+  return o;
+}
+async function ae(e, r, t, n) {
+  const o = n.stack[n.stack.length - 1];
+  if (e.attributes.xpointer)
+    throw new Error(
+      `xi:include with xpointer is not supported by the JS preview build (in ${o})`
+    );
+  const i = e.attributes.href;
+  if (!i)
+    throw new Error(`xi:include without href (in ${o})`);
+  let c = i;
+  try {
+    c = decodeURIComponent(i);
+  } catch {
+  }
+  const s = a.resolve(r, c);
+  if (s !== n.projectDir && !s.startsWith(n.projectDir + a.sep))
+    throw new Error(
+      `xi:include escapes the project directory: ${i} (in ${o})`
+    );
+  if (n.stack.includes(s))
+    throw new Error(
+      `Circular xi:include: ${[...n.stack, s].join(" -> ")}`
+    );
+  if (n.stack.length >= _)
+    throw new Error(`xi:include nesting exceeds ${_} levels`);
+  const u = await X(s);
+  if (u === void 0) {
+    const f = ke(e, t);
+    if (f)
+      return await x(f, r, t, n), f.children;
+    throw new Error(`xi:include target not found: ${i} (in ${o})`);
+  }
+  if (e.attributes.parse === "text")
+    return [{ type: "text", value: u }];
+  let l;
+  try {
+    l = v(u);
+  } catch (f) {
+    throw new Error(
+      `Could not parse xi:include target ${s} as XML: ${f instanceof Error ? f.message : f}. (Included files must be well-formed, with a single root element.)`
+    );
+  }
+  n.stack.push(s);
+  try {
+    await x(l, a.dirname(s), { "": "" }, n);
+  } finally {
+    n.stack.pop();
+  }
+  const d = l.children.filter(
+    (f) => f.type === "element"
+  );
+  for (const f of d)
+    Pe(f, s);
+  return d;
+}
+function H(e) {
+  return e.name === "docinfo";
+}
+async function Te(e, r, t) {
+  try {
+    const o = v(e).children.find(
+      (l) => l.type === "element"
+    );
+    if (!o)
+      return;
+    const i = a.resolve(r), c = a.dirname(i), s = {
+      projectDir: a.resolve(t),
+      stack: [i]
+    }, u = P({ "": "" }, o);
+    for (const l of o.children) {
+      if (l.type !== "element")
+        continue;
+      const d = P(u, l);
+      if (H(l))
+        return await x(l, c, d, s), $(l);
+      if (se(l, d)) {
+        const m = (await ae(
+          l,
+          c,
+          d,
+          s
+        )).find(
+          (b) => b.type === "element" && H(b)
+        );
+        if (m)
+          return $(m);
+        continue;
+      }
+      break;
+    }
+    return;
+  } catch {
+    return;
+  }
+}
+function ke(e, r) {
+  for (const t of e.children) {
+    if (t.type !== "element")
+      continue;
+    const n = P(r, t), o = t.name.indexOf(":"), i = o === -1 ? "" : t.name.slice(0, o);
+    if ((o === -1 ? t.name : t.name.slice(o + 1)) === "fallback" && n[i] === oe)
+      return t;
+  }
+}
+function ce(e) {
+  return typeof e == "object" && e !== null && e.type === "element";
+}
+function Se(e) {
+  return /^(pf|xhtml):/.test(e.name);
+}
+function De(e, r, t) {
+  const n = [], o = e.children.find(ce);
+  if (o) {
+    const i = t?.parentId ?? "root";
+    le(o, i, t?.position ?? 1, r, i, n);
+  }
+  return n;
+}
+function le(e, r, t, n, o, i) {
+  const c = $e(e) ?? n;
+  let s, u;
+  if (Se(e))
+    u = "root";
+  else {
+    const d = e.attributes.label ?? e.attributes["xml:id"];
+    s = d ?? `${r}-${t}`, i.push({
+      id: s,
+      file: c,
+      line: e.position?.start.line ?? 1,
+      column: e.position?.start.column ?? 1,
+      endLine: e.position?.end.line ?? e.position?.start.line ?? 1,
+      parent: o
+    }), u = s;
+  }
+  let l = 0;
+  for (const d of e.children)
+    ce(d) && (l += 1, le(
+      d,
+      u,
+      l,
+      c,
+      s ?? o,
+      i
+    ));
+}
+function Ye(e, r) {
+  let t;
+  for (const n of e)
+    n.line <= r && (t = n);
+  return t ?? e[0];
+}
+function Ie() {
+  return me(I(), "xsl");
+}
+function Me() {
+  return "Suspending" in WebAssembly;
+}
+function Ae() {
+  if (!Me())
+    throw new Error(
+      "WebAssembly JSPI is not enabled. Run Node with --experimental-wasm-jspi (or use the pretext-html CLI, which re-launches itself with the flag)."
+    );
+}
+function J(e) {
+  return e.includes("'") ? e.includes('"') ? `concat(${e.split("'").map((t) => `'${t}'`).join(`, "'", `)})` : `"${e}"` : `'${e}'`;
+}
+function Xe(e) {
+  return e.replace(
+    /from '\.\/(https:\/\/[^']+)'/g,
+    (r, t) => `from '${t}'`
+  );
+}
+function je(e) {
+  return e.slice(0, 65536).replace(/<\?[\s\S]*?\?>/g, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(/<!DOCTYPE[^>]*>/gi, " ").match(/<\s*([A-Za-z][\w:-]*)/)?.[1];
+}
+async function z(e) {
+  const r = await X(e);
+  if (r === void 0)
+    throw new Error(
+      `Could not read ${e}. (In the browser build only absolute URLs are readable — pass sourceContent instead of relying on sourcePath.)`
+    );
+  return r;
+}
+async function Fe(e, r) {
+  const t = a.resolve(e), n = await X(t);
+  if (n !== void 0)
+    return Te(n, t, r);
+}
+function Le(e, r, t) {
+  const n = e.replace(/^\uFEFF/, "").replace(/<\?xml[\s\S]*?\?>/, "").replace(/<!DOCTYPE[^>]*>/i, ""), o = r === "chapter" || r === "part" ? "book" : "article";
+  return `<pretext>
+${t?.trim() ? `${t.trim()}
+` : ""}<${o}>
+<title/>
+${n}
+</${o}>
+</pretext>
+`;
+}
+let ue = !1;
+function Re(e) {
+  return e instanceof Error && /\bAborted\(/.test(e.message);
+}
+function Ue(e) {
+  return e instanceof Error && /memory access|out of bounds/i.test(e.message);
+}
+function We() {
+  if (ue)
+    throw new Error(
+      "The WebAssembly renderer aborted earlier in this process and cannot be reused. Restart the process (or reload the page) to render again."
+    );
+}
+function q(e) {
+  if (Re(e))
+    throw ue = !0, new Error(
+      "The WebAssembly renderer aborted and cannot be reused. Restart the process (or reload the page) to render again.",
+      { cause: e }
+    );
+  if (Ue(e))
+    throw new Error(
+      "The WebAssembly renderer hit a memory fault. Most often the document is too large for this build's stack — whole-book builds are a known limitation, so try a smaller document, or see the README about rebuilding libxslt-wasm with a larger stack. The same fault also results from running two renders concurrently against the shared libxslt state.",
+      { cause: e }
+    );
+}
+let S;
+async function de() {
+  return S || (S = (async () => {
+    const [e, r] = await Promise.all([
+      import("@pretextbook/libxslt-wasm"),
+      import("@pretextbook/libxslt-wasm/exslt")
+    ]);
+    return r.registerAll(), e;
+  })()), S;
+}
+const D = /* @__PURE__ */ new Map();
+async function Ce(e) {
+  const r = e;
+  let t = D.get(r);
+  return t || (t = (async () => {
+    const { XmlDocument: n, XsltStylesheet: o } = await de(), i = re(r), c = await V(
+      I(),
+      "/preview-html.xsl"
+    );
+    if (c === void 0)
+      throw new Error(
+        `Could not read preview-html.xsl from ${I()}. Check the assets location (PRETEXT_HTML_ASSETS under Node, setAssetsBase() in the browser).`
+      );
+    const s = new TextDecoder().decode(c), u = await n.fromString(s, {
+      url: `${i}/preview-html.xsl`,
+      options: { noEnt: !0, dtdLoad: !0, huge: !0 }
+    });
+    return o.fromXmlDocument(u);
+  })(), D.set(r, t), t.catch(() => D.delete(r))), t;
+}
+let G = Promise.resolve();
+function Be(e) {
+  const r = G.then(
+    () => Y(e),
+    () => Y(e)
+  );
+  return G = r.catch(() => {
+  }), r;
+}
+async function Y(e) {
+  Ae(), We();
+  const { XmlDocument: r } = await de(), t = await Ce(e.xslDir ?? Ie()), n = a.resolve(e.sourcePath), o = a.resolve(
+    e.projectDir ?? a.dirname(n)
+  ), i = e.sourceContent ?? await z(n), c = a.relative(o, n);
+  if (c.startsWith(".."))
+    throw new Error(
+      `sourcePath (${n}) must live inside projectDir (${o})`
+    );
+  const s = a.relative(
+    o,
+    a.resolve(e.mainSourcePath ?? n)
+  ), u = s.startsWith("..") ? c : s, l = re(o);
+  try {
+    let d, f = `${l}/__pretext-preview-publication.xml`;
+    if (e.publicationPath) {
+      const h = a.resolve(e.publicationPath);
+      d = O(
+        await z(h)
+      );
+      const g = a.relative(o, h);
+      g.startsWith("..") || (f = `${l}/${g.split(a.sep).join("/")}`);
+    } else
+      d = O();
+    xe(f, d);
+    const m = ve(d), b = a.dirname(a.resolve(o, u)), F = m.external !== void 0 && m.generated !== void 0 ? {
+      external: a.resolve(b, m.external),
+      generated: a.resolve(b, m.generated)
+    } : void 0;
+    let T, p;
+    if (e.sourceMap) {
+      const h = await ie(
+        i,
+        n,
+        o
+      );
+      T = h.tree, p = h.content;
+    } else
+      p = await Ee(
+        i,
+        n,
+        o
+      );
+    const E = je(p);
+    let L = { parentId: "root", position: 1 };
+    if (E !== "pretext" && E !== "mathbook")
+      if (e.fragment) {
+        const h = e.docinfo ?? (e.docinfoSourcePath ? await Fe(e.docinfoSourcePath, o) : void 0);
+        p = Le(p, E, h), L = { parentId: h?.trim() ? "root-1-2" : "root-1-1", position: 2 };
+      } else
+        throw new Error(
+          `The document root is <${E ?? "?"}>, not <pretext> — this looks like an xi:included fragment. Render the project's main source file instead, or pass the fragment option.`
+        );
+    const R = T ? De(T, n, L) : void 0, U = await r.fromString(p, {
+      url: `${l}/${u.split(a.sep).join("/")}`,
+      options: { noEnt: !0, dtdLoad: !0, huge: !0 }
+    }), W = {
+      publisher: J(f)
+    };
+    for (const [h, g] of Object.entries(e.stringParams ?? {}))
+      W[h] = J(g);
+    let k;
+    try {
+      k = await t.apply(U, W);
+    } catch (h) {
+      throw q(h), new Error(
+        "PreTeXt XSLT transform failed; see the PTX:ERROR/PTX:FATAL messages on stderr for details.",
+        { cause: h }
+      );
+    } finally {
+      U.delete();
+    }
+    try {
+      let h = Xe(k.toHtmlString());
+      return e.theme && (h = he(h, e.theme)), {
+        html: h,
+        ...R ? { sourceMap: R } : {},
+        ...F ? { assetDirs: F } : {}
+      };
+    } catch (h) {
+      throw q(h), h;
+    } finally {
+      k.delete();
+    }
+  } finally {
+    ye(l);
+  }
+}
+const Q = `Usage: pretext-html <source.ptx> [options]
+
+Render a PreTeXt document to a single standalone HTML page (portable build:
+one page, css/js/MathJax from CDN). No PreTeXt installation required.
+
+Options:
+  -o, --output <file>       Write HTML to a file instead of stdout
+  --publication <file>      Publication file (portable html is forced on)
+  --project-dir <dir>       Directory served to the transform for xi:includes
+                            (default: the source file's directory)
+  --param <name=value>      Extra XSLT string parameter (repeatable)
+  --xsl-dir <dir>           Use PreTeXt stylesheets from this directory
+                            instead of the vendored copy
+  --fragment                Allow a non-root source file: wrap the fragment
+                            in a minimal <pretext> document (an <article>,
+                            or a <book> for <chapter>/<part> fragments)
+  --docinfo <file>          File whose contents (a <docinfo> element) are
+                            injected into the wrapper in --fragment mode, so
+                            the fragment keeps the project's LaTeX macros
+  --docinfo-source <file>   Complete source file (e.g. main.ptx) to lift the
+                            <docinfo> from for --fragment mode, resolving
+                            xi:includes (used when --docinfo is not given)
+  --source-map <file>       Also write a JSON source map: HTML id → source
+                            file/line for every element (for editor sync)
+  -h, --help                Show this help
+`;
+function Oe(e) {
+  let r, t, n, o;
+  const i = {}, c = {};
+  for (let s = 0; s < e.length; s++) {
+    const u = e[s], l = () => {
+      if (s += 1, s >= e.length)
+        throw new Error(`Missing value for ${u}`);
+      return e[s];
+    };
+    switch (u) {
+      case "-h":
+      case "--help":
+        w.stdout.write(Q), w.exit(0);
+        break;
+      case "-o":
+      case "--output":
+        t = l();
+        break;
+      case "--publication":
+        i.publicationPath = l();
+        break;
+      case "--project-dir":
+        i.projectDir = l();
+        break;
+      case "--xsl-dir":
+        i.xslDir = l();
+        break;
+      case "--fragment":
+        i.fragment = !0;
+        break;
+      case "--docinfo":
+        n = l();
+        break;
+      case "--docinfo-source":
+        i.docinfoSourcePath = l();
+        break;
+      case "--source-map":
+        o = l(), i.sourceMap = !0;
+        break;
+      case "--param": {
+        const d = l(), f = d.indexOf("=");
+        if (f === -1)
+          throw new Error(`--param expects name=value, got: ${d}`);
+        c[d.slice(0, f)] = d.slice(f + 1);
+        break;
+      }
+      default:
+        if (u.startsWith("-"))
+          throw new Error(`Unknown option: ${u}`);
+        if (r)
+          throw new Error(`Unexpected extra argument: ${u}`);
+        r = u;
+    }
+  }
+  if (!r)
+    throw new Error(`No source file given.
+
+` + Q);
+  return Object.keys(c).length > 0 && (i.stringParams = c), {
+    options: { ...i, sourcePath: r },
+    output: t,
+    docinfoPath: n,
+    sourceMapPath: o
+  };
+}
+async function Qe(e) {
+  const { options: r, output: t, docinfoPath: n, sourceMapPath: o } = Oe(e);
+  n && (r.docinfo = await A(n, "utf8"));
+  const i = Date.now(), { html: c, sourceMap: s } = await Be(r);
+  w.stderr.write(`pretext-html: rendered in ${Date.now() - i}ms
+`), o && s && (await C(o, JSON.stringify(s, null, 2)), w.stderr.write(`pretext-html: wrote ${o}
+`)), t ? (await C(t, c), w.stderr.write(`pretext-html: wrote ${t}
+`)) : w.stdout.write(c);
+}
+export {
+  O as a,
+  Ge as b,
+  Ie as d,
+  Ye as f,
+  Me as i,
+  Qe as m,
+  Oe as p,
+  Be as r,
+  qe as s,
+  J as x
+};

package/dist/cli.js

@@ -1,6 +1,6 @@
 import "node:fs/promises";
 import "node:process";
-import { m as o, p as s } from "./cli-BQizBK0N.js";
+import { m as o, p as s } from "./cli-CzoinNle.js";
 export {
   o as main,
   s as parseArgs

package/dist/host.browser.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Browser implementation of the platform seam (see host.ts for the contract
+ * and host.node's counterpart). Substituted for `./host.js` when this package
+ * is built for the browser; vite.config.ts wires the alias.
+ *
+ * There is no filesystem here, so:
+ *
+ *  - Mount roots are base URLs rather than directories, and `readMount` is a
+ *    `fetch`. Containment is enforced by resolving against the base and
+ *    checking the result still sits under it.
+ *  - `readSource` can only read things that are actually addressable, i.e.
+ *    absolute URLs. A browser caller naming a virtual path (`/main.ptx`) gets
+ *    `undefined`, which means **`sourceContent` is effectively required** and
+ *    `xi:include`s cannot be resolved from disk. Pre-resolve includes, or
+ *    pass the merged document as `sourceContent`.
+ *  - `assetsBase()` defaults to the version-pinned jsDelivr copy of this
+ *    package, so an embedder needs no build configuration at all. Call
+ *    `setAssetsBase()` to self-host.
+ */
+/**
+ * Serve this package's `assets/` from somewhere other than jsDelivr — a
+ * self-hosted copy, an offline bundle, a same-origin path. Must be called
+ * before the first render; the compiled stylesheet is cached per root.
+ */
+export declare function setAssetsBase(base: string): void;
+export declare function assetsBase(): string;
+export declare function joinPath(root: string, child: string): string;
+export declare function readMount(root: string, relPath: string): Promise<Uint8Array | undefined>;
+export declare function readSource(location: string): Promise<string | undefined>;