@pretextbook/pretext-html 0.1.0

package/dist/cli-C6tfAVvi.js

@@ -0,0 +1,553 @@
+import { readFile as m, writeFile as j } from "node:fs/promises";
+import * as w from "node:process";
+import * as c from "node:path";
+import { fileURLToPath as K } from "node:url";
+import { fromXml as $ } from "xast-util-from-xml";
+import { toXml as y } from "xast-util-to-xml";
+const I = /* @__PURE__ */ new Map(), W = /* @__PURE__ */ new Map();
+let S, Q = 0;
+function ee(e, r) {
+  const t = typeof e == "string" ? e : e instanceof URL ? e.href : e.url, n = W.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 = I.get(o);
+  return i !== void 0 ? te(i, t) : S(e, r);
+}
+const F = '<?xml version="1.0"?><pretext-preview-missing-file/>';
+async function te(e, r) {
+  const t = decodeURIComponent(new URL(r).pathname), n = c.resolve(e, "." + c.posix.normalize(t));
+  if (n !== e && !n.startsWith(e + c.sep))
+    return console.error(
+      `pretext-html: refusing to serve ${t} from outside ${e}`
+    ), new Response(F, { status: 200 });
+  try {
+    const o = await m(n);
+    return new Response(new Uint8Array(o), { status: 200 });
+  } catch {
+    return new Response(F, { status: 200 });
+  }
+}
+function N() {
+  S || (S = globalThis.fetch, globalThis.fetch = ee);
+}
+function B(e) {
+  N();
+  const r = `mnt${++Q}.ptx.invalid`;
+  return I.set(r, c.resolve(e)), `http://${r}`;
+}
+function re(e) {
+  I.delete(new URL(e).host);
+}
+function ne(e, r) {
+  N(), W.set(e, r);
+}
+const oe = `<?xml version="1.0" encoding="UTF-8"?>
+<publication>
+  <source>
+    <directories external="../assets" generated="../generated-assets" />
+  </source>
+  <html>
+    <platform portable="yes"/>
+  </html>
+</publication>
+`;
+function _(e, r) {
+  for (const t of e.children)
+    if (t.type === "element" && t.name === r)
+      return t;
+}
+function M(e, r) {
+  let t = _(e, r);
+  return t || (t = { type: "element", name: r, attributes: {}, children: [] }, e.children.push(t)), t;
+}
+function L(e) {
+  if (!e)
+    return oe;
+  const r = $(e), t = _(r, "publication");
+  if (!t)
+    throw new Error(
+      "Invalid publication file: no root <publication> element found"
+    );
+  const n = M(t, "html"), o = M(n, "platform");
+  return o.attributes = { ...o.attributes, portable: "yes" }, y(r);
+}
+const H = "http://www.w3.org/2001/XInclude", R = 64;
+async function ie(e, r, t) {
+  return e.includes("include") ? (await J(e, r, t)).content : e;
+}
+async function J(e, r, t) {
+  const n = $(e), o = {
+    projectDir: c.resolve(t),
+    stack: [c.resolve(r)]
+  }, i = await x(
+    n,
+    c.dirname(c.resolve(r)),
+    { "": "" },
+    o
+  );
+  return { tree: n, content: i ? y(n) : e };
+}
+function se(e) {
+  return e.data?.ptxIncludedFile;
+}
+function ae(e, r) {
+  const t = e.data ?? (e.data = {});
+  t.ptxIncludedFile = r;
+}
+function v(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 q(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] === H;
+}
+async function x(e, r, t, n) {
+  let o = !1;
+  for (let i = 0; i < e.children.length; i++) {
+    const l = e.children[i];
+    if (l.type !== "element")
+      continue;
+    const s = v(t, l);
+    if (q(l, s)) {
+      const f = await z(
+        l,
+        r,
+        s,
+        n
+      );
+      e.children.splice(i, 1, ...f), i += f.length - 1, o = !0;
+    } else await x(l, r, s, n) && (o = !0);
+  }
+  return o;
+}
+async function z(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 l = i;
+  try {
+    l = decodeURIComponent(i);
+  } catch {
+  }
+  const s = c.resolve(r, l);
+  if (s !== n.projectDir && !s.startsWith(n.projectDir + c.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 >= R)
+    throw new Error(`xi:include nesting exceeds ${R} levels`);
+  let f;
+  try {
+    f = await m(s, "utf8");
+  } catch {
+    const u = le(e, t);
+    if (u)
+      return await x(u, r, t, n), u.children;
+    throw new Error(`xi:include target not found: ${i} (in ${o})`);
+  }
+  if (e.attributes.parse === "text")
+    return [{ type: "text", value: f }];
+  let a;
+  try {
+    a = $(f);
+  } catch (u) {
+    throw new Error(
+      `Could not parse xi:include target ${s} as XML: ${u instanceof Error ? u.message : u}. (Included files must be well-formed, with a single root element.)`
+    );
+  }
+  n.stack.push(s);
+  try {
+    await x(a, c.dirname(s), { "": "" }, n);
+  } finally {
+    n.stack.pop();
+  }
+  const d = a.children.filter(
+    (u) => u.type === "element"
+  );
+  for (const u of d)
+    ae(u, s);
+  return d;
+}
+function A(e) {
+  return e.name === "docinfo";
+}
+async function ce(e, r, t) {
+  try {
+    const o = $(e).children.find(
+      (a) => a.type === "element"
+    );
+    if (!o)
+      return;
+    const i = c.resolve(r), l = c.dirname(i), s = {
+      projectDir: c.resolve(t),
+      stack: [i]
+    }, f = v({ "": "" }, o);
+    for (const a of o.children) {
+      if (a.type !== "element")
+        continue;
+      const d = v(f, a);
+      if (A(a))
+        return await x(a, l, d, s), y(a);
+      if (q(a, d)) {
+        const h = (await z(
+          a,
+          l,
+          d,
+          s
+        )).find(
+          (g) => g.type === "element" && A(g)
+        );
+        if (h)
+          return y(h);
+        continue;
+      }
+      break;
+    }
+    return;
+  } catch {
+    return;
+  }
+}
+function le(e, r) {
+  for (const t of e.children) {
+    if (t.type !== "element")
+      continue;
+    const n = v(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] === H)
+      return t;
+  }
+}
+function G(e) {
+  return typeof e == "object" && e !== null && e.type === "element";
+}
+function ue(e) {
+  return /^(pf|xhtml):/.test(e.name);
+}
+function fe(e, r, t) {
+  const n = [], o = e.children.find(G);
+  if (o) {
+    const i = t?.parentId ?? "root";
+    Y(o, i, t?.position ?? 1, r, i, n);
+  }
+  return n;
+}
+function Y(e, r, t, n, o, i) {
+  const l = se(e) ?? n;
+  let s, f;
+  if (ue(e))
+    f = "root";
+  else {
+    const d = e.attributes.label ?? e.attributes["xml:id"];
+    s = d ?? `${r}-${t}`, i.push({
+      id: s,
+      file: l,
+      line: e.position?.start.line ?? 1,
+      column: e.position?.start.column ?? 1,
+      endLine: e.position?.end.line ?? e.position?.start.line ?? 1,
+      parent: o
+    }), f = s;
+  }
+  let a = 0;
+  for (const d of e.children)
+    G(d) && (a += 1, Y(
+      d,
+      f,
+      a,
+      l,
+      s ?? o,
+      i
+    ));
+}
+function Ie(e, r) {
+  let t;
+  for (const n of e)
+    n.line <= r && (t = n);
+  return t ?? e[0];
+}
+function V() {
+  return process.env.PRETEXT_HTML_ASSETS ?? c.resolve(c.dirname(K(import.meta.url)), "..", "assets");
+}
+function de() {
+  return c.join(V(), "xsl");
+}
+function pe() {
+  return c.join(V(), "preview-html.xsl");
+}
+function he() {
+  return "Suspending" in WebAssembly;
+}
+function me() {
+  if (!he())
+    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 U(e) {
+  return e.includes("'") ? e.includes('"') ? `concat(${e.split("'").map((t) => `'${t}'`).join(`, "'", `)})` : `"${e}"` : `'${e}'`;
+}
+function we(e) {
+  return e.replace(
+    /from '\.\/(https:\/\/[^']+)'/g,
+    (r, t) => `from '${t}'`
+  );
+}
+function ge(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 be(e, r) {
+  const t = c.resolve(e);
+  let n;
+  try {
+    n = await m(t, "utf8");
+  } catch {
+    return;
+  }
+  return ce(n, t, r);
+}
+function xe(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>
+`;
+}
+function C(e) {
+  if (e instanceof Error && /memory access|out of bounds/i.test(e.message))
+    throw new Error(
+      "The document is too large for the current WebAssembly build (stack overflow). Whole-book builds are a known limitation; try a smaller document, or see the README about rebuilding libxslt-wasm with a larger stack.",
+      { cause: e }
+    );
+}
+let P;
+async function Z() {
+  return P || (P = (async () => {
+    const [e, r] = await Promise.all([
+      import("@pretextbook/libxslt-wasm"),
+      import("@pretextbook/libxslt-wasm/exslt")
+    ]);
+    return r.registerAll(), e;
+  })()), P;
+}
+const k = /* @__PURE__ */ new Map();
+async function ye(e) {
+  const r = c.resolve(e);
+  let t = k.get(r);
+  return t || (t = (async () => {
+    const { XmlDocument: n, XsltStylesheet: o } = await Z(), i = B(r), l = await m(pe(), "utf8"), s = await n.fromString(l, {
+      url: `${i}/preview-html.xsl`,
+      options: { noEnt: !0, dtdLoad: !0, huge: !0 }
+    });
+    return o.fromXmlDocument(s);
+  })(), k.set(r, t), t.catch(() => k.delete(r))), t;
+}
+async function ve(e) {
+  me();
+  const { XmlDocument: r } = await Z(), t = await ye(e.xslDir ?? de()), n = c.resolve(e.sourcePath), o = c.resolve(
+    e.projectDir ?? c.dirname(n)
+  ), i = e.sourceContent ?? await m(n, "utf8"), l = c.relative(o, n);
+  if (l.startsWith(".."))
+    throw new Error(
+      `sourcePath (${n}) must live inside projectDir (${o})`
+    );
+  const s = B(o);
+  try {
+    let f, a = `${s}/__pretext-preview-publication.xml`;
+    if (e.publicationPath) {
+      const p = c.resolve(e.publicationPath);
+      f = L(
+        await m(p, "utf8")
+      );
+      const b = c.relative(o, p);
+      b.startsWith("..") || (a = `${s}/${b.split(c.sep).join("/")}`);
+    } else
+      f = L();
+    ne(a, f);
+    let d, u;
+    if (e.sourceMap) {
+      const p = await J(
+        i,
+        n,
+        o
+      );
+      d = p.tree, u = p.content;
+    } else
+      u = await ie(
+        i,
+        n,
+        o
+      );
+    const h = ge(u);
+    let g = { parentId: "root", position: 1 };
+    if (h !== "pretext" && h !== "mathbook")
+      if (e.fragment) {
+        const p = e.docinfo ?? (e.docinfoSourcePath ? await be(e.docinfoSourcePath, o) : void 0);
+        u = xe(u, h, p), g = { parentId: p?.trim() ? "root-1-2" : "root-1-1", position: 2 };
+      } else
+        throw new Error(
+          `The document root is <${h ?? "?"}>, not <pretext> — this looks like an xi:included fragment. Render the project's main source file instead, or pass the fragment option.`
+        );
+    const T = d ? fe(d, n, g) : void 0, D = await r.fromString(u, {
+      url: `${s}/${l.split(c.sep).join("/")}`,
+      options: { noEnt: !0, dtdLoad: !0, huge: !0 }
+    }), X = {
+      publisher: U(a)
+    };
+    for (const [p, b] of Object.entries(e.stringParams ?? {}))
+      X[p] = U(b);
+    let E;
+    try {
+      E = await t.apply(D, X);
+    } catch (p) {
+      throw C(p), new Error(
+        "PreTeXt XSLT transform failed; see the PTX:ERROR/PTX:FATAL messages on stderr for details.",
+        { cause: p }
+      );
+    } finally {
+      D.delete();
+    }
+    try {
+      return {
+        html: we(E.toHtmlString()),
+        ...T ? { sourceMap: T } : {}
+      };
+    } catch (p) {
+      throw C(p), p;
+    } finally {
+      E.delete();
+    }
+  } finally {
+    re(s);
+  }
+}
+const O = `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 $e(e) {
+  let r, t, n, o;
+  const i = {}, l = {};
+  for (let s = 0; s < e.length; s++) {
+    const f = e[s], a = () => {
+      if (s += 1, s >= e.length)
+        throw new Error(`Missing value for ${f}`);
+      return e[s];
+    };
+    switch (f) {
+      case "-h":
+      case "--help":
+        w.stdout.write(O), w.exit(0);
+        break;
+      case "-o":
+      case "--output":
+        t = a();
+        break;
+      case "--publication":
+        i.publicationPath = a();
+        break;
+      case "--project-dir":
+        i.projectDir = a();
+        break;
+      case "--xsl-dir":
+        i.xslDir = a();
+        break;
+      case "--fragment":
+        i.fragment = !0;
+        break;
+      case "--docinfo":
+        n = a();
+        break;
+      case "--docinfo-source":
+        i.docinfoSourcePath = a();
+        break;
+      case "--source-map":
+        o = a(), i.sourceMap = !0;
+        break;
+      case "--param": {
+        const d = a(), u = d.indexOf("=");
+        if (u === -1)
+          throw new Error(`--param expects name=value, got: ${d}`);
+        l[d.slice(0, u)] = d.slice(u + 1);
+        break;
+      }
+      default:
+        if (f.startsWith("-"))
+          throw new Error(`Unknown option: ${f}`);
+        if (r)
+          throw new Error(`Unexpected extra argument: ${f}`);
+        r = f;
+    }
+  }
+  if (!r)
+    throw new Error(`No source file given.
+
+` + O);
+  return Object.keys(l).length > 0 && (i.stringParams = l), {
+    options: { ...i, sourcePath: r },
+    output: t,
+    docinfoPath: n,
+    sourceMapPath: o
+  };
+}
+async function Te(e) {
+  const { options: r, output: t, docinfoPath: n, sourceMapPath: o } = $e(e);
+  n && (r.docinfo = await m(n, "utf8"));
+  const i = Date.now(), { html: l, sourceMap: s } = await ve(r);
+  w.stderr.write(`pretext-html: rendered in ${Date.now() - i}ms
+`), o && s && (await j(o, JSON.stringify(s, null, 2)), w.stderr.write(`pretext-html: wrote ${o}
+`)), t ? (await j(t, l), w.stderr.write(`pretext-html: wrote ${t}
+`)) : w.stdout.write(l);
+}
+export {
+  L as a,
+  de as d,
+  Ie as f,
+  he as i,
+  Te as m,
+  $e as p,
+  ve as r,
+  U as x
+};

package/dist/cli.d.ts

@@ -0,0 +1,10 @@
+import { RenderOptions } from './renderer.js';
+interface CliArgs {
+    options: RenderOptions;
+    output?: string;
+    docinfoPath?: string;
+    sourceMapPath?: string;
+}
+export declare function parseArgs(argv: string[]): CliArgs;
+export declare function main(argv: string[]): Promise<void>;
+export {};

package/dist/cli.js

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { renderHtml, defaultXslDir, isJspiAvailable, xpathStringLiteral, } from './renderer.js';
+export type { RenderOptions, RenderResult } from './renderer.js';
+export { findSourceMapEntry } from './sourcemap.js';
+export type { PtxSourceMap, SourceMapEntry } from './sourcemap.js';
+export { forcePortablePublication } from './publication.js';
+export { main as runCli } from './cli.js';

package/dist/index.js

@@ -0,0 +1,10 @@
+import { d as i, f as s, a as e, i as l, r as t, m as n, x as o } from "./cli-C6tfAVvi.js";
+export {
+  i as defaultXslDir,
+  s as findSourceMapEntry,
+  e as forcePortablePublication,
+  l as isJspiAvailable,
+  t as renderHtml,
+  n as runCli,
+  o as xpathStringLiteral
+};

package/dist/mounts.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Virtual-host fetch shim.
+ *
+ * The libxslt-wasm build is compiled with FILESYSTEM=0, so libxml2 cannot
+ * touch the real filesystem: any `file://` URL aborts inside the WASM sandbox.
+ * Instead, every external resource load (stylesheet imports, DTD entities,
+ * xi:includes, the publication file, `document()` calls) is routed through the
+ * *global* `fetch` via a JSPI-suspended import. That makes resource loading
+ * fully controllable from JavaScript: we register fake hosts under the
+ * reserved `.invalid` TLD and serve them from local directories or in-memory
+ * strings. No HTTP server, no real network traffic.
+ */
+/** Install the shim (idempotent). Must run before libxslt-wasm loads anything. */
+export declare function installFetchShim(): void;
+/**
+ * Serve `dir` under a unique fake origin. Returns the base URL
+ * (e.g. `http://mnt1.ptx.invalid`); resource paths append to it.
+ */
+export declare function mountDirectory(dir: string): string;
+export declare function unmountDirectory(baseUrl: string): void;
+/** Serve `content` for exactly `url`. Takes priority over directory mounts. */
+export declare function setVirtualFile(url: string, content: string): void;
+export declare function removeVirtualFile(url: string): void;

package/dist/publication.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Publication-file handling for single-page preview builds.
+ *
+ * The preview relies on PreTeXt's "portable HTML" mode
+ * (`<html><platform portable="yes"/></html>` in the publication file), which
+ * forces chunk level 0 (the whole document on one page), serves css/js from
+ * the jsDelivr CDN, and suppresses most auxiliary file output. Publisher
+ * variables can only come from a publication file — there is no stringparam
+ * for `portable` — so we rewrite the user's publication file (or synthesize a
+ * minimal one) and serve it through the fetch shim as a virtual file.
+ */
+/**
+ * Return publication-file XML with `<html><platform portable="yes"/></html>`
+ * forced, preserving everything else from `publicationXml` when given.
+ */
+export declare function forcePortablePublication(publicationXml?: string): string;