@ai-matrx/print 0.6.2 → 0.7.1

package/dist/document.cjs

@@ -0,0 +1,2860 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/document.ts
+var document_exports = {};
+__export(document_exports, {
+  DEFAULT_FOOTER: () => DEFAULT_FOOTER,
+  DOCUMENT_FORMATS: () => DOCUMENT_FORMATS,
+  PAGE_SIZES: () => PAGE_SIZES,
+  buildPdfDefinition: () => buildPdfDefinition,
+  defaultImageLoader: () => defaultImageLoader,
+  documentCss: () => documentCss,
+  documentToDocx: () => documentToDocx,
+  documentToEpub: () => documentToEpub,
+  documentToHtml: () => documentToHtml,
+  documentToPdf: () => documentToPdf,
+  downloadDocumentExport: () => downloadDocumentExport,
+  exportDocument: () => exportDocument,
+  fillTemplate: () => fillTemplate,
+  formatBibliography: () => formatBibliography,
+  formatCitation: () => formatCitation,
+  normalizeReference: () => normalizeReference,
+  parseCitationGroup: () => parseCitationGroup,
+  parseDocument: () => parseDocument,
+  parseLength: () => parseLength,
+  plainText: () => plainText,
+  renderBlocksHtml: () => renderBlocksHtml,
+  resolveDocumentImages: () => resolveDocumentImages,
+  resolveSettings: () => resolveSettings,
+  splitFrontmatter: () => splitFrontmatter
+});
+module.exports = __toCommonJS(document_exports);
+
+// src/document/settings.ts
+var import_yaml = require("yaml");
+var PAGE_SIZES = {
+  letter: { width: 612, height: 792, label: "Letter" },
+  legal: { width: 612, height: 1008, label: "Legal" },
+  tabloid: { width: 792, height: 1224, label: "Tabloid" },
+  executive: { width: 522, height: 756, label: "Executive" },
+  a3: { width: 841.89, height: 1190.55, label: "A3" },
+  a4: { width: 595.28, height: 841.89, label: "A4" },
+  a5: { width: 419.53, height: 595.28, label: "A5" },
+  b5: { width: 498.9, height: 708.66, label: "B5" }
+};
+var DEFAULT_FOOTER = { center: "Page {page} of {pages}" };
+var BIBLIOGRAPHY_TITLES = {
+  apa: "References",
+  mla: "Works Cited",
+  chicago: "Bibliography"
+};
+function splitFrontmatter(source, notices) {
+  const text = source.replace(/^/, "");
+  const lines = text.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---" || lines[0] !== lines[0].trimStart()) {
+    return { data: {}, body: text, raw: null };
+  }
+  let close = -1;
+  for (let i = 1; i < lines.length; i++) {
+    const t2 = lines[i].trimEnd();
+    if (t2 === "---" || t2 === "...") {
+      close = i;
+      break;
+    }
+  }
+  if (close === -1) return { data: {}, body: text, raw: null };
+  const raw = lines.slice(1, close).join("\n");
+  const body = lines.slice(close + 1).join("\n");
+  let data;
+  try {
+    data = raw.trim() ? (0, import_yaml.parse)(raw) : {};
+  } catch (err) {
+    notices?.push({
+      code: "frontmatter-invalid",
+      message: `The document settings at the top could not be read: ${err.message.split("\n")[0]}`,
+      remedy: "Fix the YAML between the two --- lines (every setting is `name: value`, lists use `- item`)."
+    });
+    return { data: {}, body, raw };
+  }
+  if (data === null || typeof data !== "object" || Array.isArray(data)) {
+    notices?.push({
+      code: "frontmatter-invalid",
+      message: "The document settings at the top are not a list of `name: value` settings.",
+      remedy: "Write one setting per line between the --- lines, e.g. `title: Annual report`."
+    });
+    return { data: {}, body, raw };
+  }
+  return { data, body, raw };
+}
+var norm = (k) => k.replace(/[-_\s]/g, "").toLowerCase();
+function flatten(data) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(data)) out.set(norm(k), v);
+  for (const nest of ["page", "print", "document", "layout"]) {
+    const v = out.get(nest);
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      for (const [k, inner] of Object.entries(v)) {
+        const key = norm(k);
+        if (!out.has(key) || nest !== "page") out.set(key, inner);
+        if (nest === "page" && !out.has(`page${key}`)) out.set(`page${key}`, inner);
+      }
+    }
+  }
+  return out;
+}
+var str = (v) => {
+  if (v === null || v === void 0) return void 0;
+  if (typeof v === "string") return v.trim() || void 0;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (v instanceof Date) return v.toISOString().slice(0, 10);
+  return void 0;
+};
+var bool = (v) => {
+  if (typeof v === "boolean") return v;
+  if (typeof v === "string") {
+    const t2 = v.trim().toLowerCase();
+    if (["true", "yes", "on", "1"].includes(t2)) return true;
+    if (["false", "no", "off", "0", "none"].includes(t2)) return false;
+  }
+  if (typeof v === "number") return v !== 0;
+  return void 0;
+};
+function parseLength(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v * 72;
+  if (typeof v !== "string") return void 0;
+  const m = /^\s*(-?\d+(?:\.\d+)?)\s*(in|inch|inches|cm|mm|pt|px|")?\s*$/i.exec(v);
+  if (!m) return void 0;
+  const n = Number(m[1]);
+  switch ((m[2] ?? "in").toLowerCase()) {
+    case "cm":
+      return n / 2.54 * 72;
+    case "mm":
+      return n / 25.4 * 72;
+    case "pt":
+      return n;
+    case "px":
+      return n * 0.75;
+    default:
+      return n * 72;
+  }
+}
+function parseMargins(v, base) {
+  if (v && typeof v === "object" && !Array.isArray(v)) {
+    const o = v;
+    const all = parseLength(o.all ?? o.margin);
+    const pick = (k) => parseLength(o[k]) ?? parseLength(k === "left" || k === "right" ? o.x : o.y) ?? all ?? base[k];
+    return { top: pick("top"), right: pick("right"), bottom: pick("bottom"), left: pick("left") };
+  }
+  const parts = (typeof v === "number" ? [String(v)] : typeof v === "string" ? v.trim().split(/[\s,]+/) : []).map((p) => parseLength(/^\d+(\.\d+)?$/.test(p) ? Number(p) : p)).filter((n) => n !== void 0);
+  if (parts.length === 0) return void 0;
+  const [t2, r = t2, b = t2, l = r] = parts;
+  return { top: t2, right: r, bottom: b, left: l };
+}
+function parseGeometry(v, base) {
+  const items = Array.isArray(v) ? v.map(String) : typeof v === "string" ? v.split(",") : [];
+  if (items.length === 0) return void 0;
+  const m = { ...base };
+  let hit = false;
+  for (const item of items) {
+    const [k, val] = item.split("=").map((s) => s.trim().toLowerCase());
+    const len = parseLength(val);
+    if (!k || len === void 0) continue;
+    hit = true;
+    if (k === "margin") m.top = m.right = m.bottom = m.left = len;
+    else if (k === "top" || k === "tmargin") m.top = len;
+    else if (k === "bottom" || k === "bmargin") m.bottom = len;
+    else if (k === "left" || k === "lmargin" || k === "inner") m.left = len;
+    else if (k === "right" || k === "rmargin" || k === "outer") m.right = len;
+    else if (k === "hmargin") m.left = m.right = len;
+    else if (k === "vmargin") m.top = m.bottom = len;
+    else hit = hit || false;
+  }
+  return hit ? m : void 0;
+}
+function parseRunning(v) {
+  if (v === void 0) return void 0;
+  if (v === false || v === null) return null;
+  if (typeof v === "string") {
+    const t2 = v.trim();
+    if (!t2 || /^(none|off|false)$/i.test(t2)) return null;
+    if (t2.includes("|")) {
+      const [left, center, right] = t2.split("|").map((s) => s.trim());
+      return { left: left || void 0, center: center || void 0, right: right || void 0 };
+    }
+    return { center: t2 };
+  }
+  if (typeof v === "object" && !Array.isArray(v)) {
+    const o = v;
+    return { left: str(o.left), center: str(o.center ?? o.centre ?? o.middle), right: str(o.right) };
+  }
+  return void 0;
+}
+function parseName(n) {
+  if (typeof n === "string") {
+    const t2 = n.trim();
+    if (!t2) return null;
+    if (t2.includes(",")) {
+      const [family2, given] = t2.split(",").map((s) => s.trim());
+      return { family: family2, given: given || void 0 };
+    }
+    const parts = t2.split(/\s+/);
+    if (parts.length === 1) return { family: parts[0] };
+    return { family: parts[parts.length - 1], given: parts.slice(0, -1).join(" ") };
+  }
+  if (n && typeof n === "object") {
+    const o = n;
+    const family2 = str(o.family ?? o.last ?? o.surname);
+    const given = str(o.given ?? o.first);
+    const literal = str(o.literal ?? o.name);
+    if (!family2 && !given && !literal) return null;
+    return { family: family2, given, literal };
+  }
+  return null;
+}
+function normalizeReference(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw;
+  const id = str(o.id ?? o.key ?? o["citation-key"]);
+  if (!id) return null;
+  const names = (v) => {
+    const arr = Array.isArray(v) ? v : typeof v === "string" ? v.split(/\s+and\s+|;/) : [];
+    const out = arr.map(parseName).filter((x) => x !== null);
+    return out.length ? out : void 0;
+  };
+  let issued = o.issued && typeof o.issued === "object" ? o.issued : void 0;
+  const year2 = o.year ?? o.date ?? (typeof o.issued === "object" ? void 0 : o.issued);
+  if (!issued && year2 !== void 0) {
+    const y = str(year2);
+    const m = y ? /^(\d{4})(?:-(\d{1,2}))?(?:-(\d{1,2}))?/.exec(y) : null;
+    issued = m ? { "date-parts": [[Number(m[1]), ...m[2] ? [Number(m[2])] : [], ...m[3] ? [Number(m[3])] : []]] } : y ? { literal: y } : void 0;
+  }
+  return {
+    id,
+    type: str(o.type),
+    title: str(o.title),
+    author: names(o.author ?? o.authors),
+    editor: names(o.editor ?? o.editors),
+    issued,
+    "container-title": str(o["container-title"] ?? o.containerTitle ?? o.journal ?? o.website ?? o.booktitle),
+    publisher: str(o.publisher),
+    "publisher-place": str(o["publisher-place"] ?? o.publisherPlace ?? o.place ?? o.address),
+    volume: str(o.volume),
+    issue: str(o.issue ?? o.number),
+    page: str(o.page ?? o.pages),
+    edition: str(o.edition),
+    URL: str(o.URL ?? o.url),
+    DOI: str(o.DOI ?? o.doi)
+  };
+}
+function resolveSettings(data, notices, options = {}) {
+  const f = flatten(data);
+  const get = (...keys) => {
+    for (const k of keys) if (f.has(k)) return f.get(k);
+    return void 0;
+  };
+  const ignore = (key, value, remedy) => notices.push({
+    code: "setting-ignored",
+    message: `The setting "${key}: ${typeof value === "object" ? JSON.stringify(value) : String(value)}" was not understood, so the default is used.`,
+    remedy
+  });
+  let size = "letter";
+  let orientation = "portrait";
+  const sizeRaw = get("pagesize", "papersize", "paper", "size");
+  if (sizeRaw !== void 0) {
+    const s = String(sizeRaw).toLowerCase().replace(/paper$/, "").replace(/[\s-]/g, "");
+    const words = s.match(/[a-z]+\d*/g) ?? [];
+    const name = words.find((w) => w in PAGE_SIZES);
+    if (name) size = name;
+    else ignore("page size", sizeRaw, `Use one of: ${Object.keys(PAGE_SIZES).join(", ")}.`);
+    if (/landscape/.test(s)) orientation = "landscape";
+  }
+  const orientRaw = get("orientation", "pageorientation");
+  if (orientRaw !== void 0) {
+    const o = String(orientRaw).toLowerCase();
+    if (o === "landscape" || o === "portrait") orientation = o;
+    else ignore("orientation", orientRaw, "Use `portrait` or `landscape`.");
+  }
+  if (bool(get("landscape")) === true) orientation = "landscape";
+  let margins = { top: 72, right: 72, bottom: 72, left: 72 };
+  const marginRaw = get("margins", "margin", "pagemargins", "pagemargin");
+  if (marginRaw !== void 0) {
+    const m = parseMargins(marginRaw, margins);
+    if (m) margins = m;
+    else ignore("margins", marginRaw, "Write margins like `1in`, `2.5cm`, `20mm`, or `1in 0.75in` (top/bottom left/right).");
+  }
+  const geometry = get("geometry");
+  if (geometry !== void 0) {
+    const m = parseGeometry(geometry, margins);
+    if (m) margins = m;
+    else ignore("geometry", geometry, "Write it like pandoc: `geometry: margin=1in`.");
+  }
+  for (const side of ["top", "right", "bottom", "left"]) {
+    const v = get(`margin${side}`, `${side}margin`);
+    const len = parseLength(v);
+    if (len !== void 0) margins[side] = len;
+  }
+  const title = str(get("title")) ?? options.title;
+  const subtitle = str(get("subtitle"));
+  const authorRaw = get("author", "authors");
+  const author = Array.isArray(authorRaw) ? authorRaw.map((a) => typeof a === "string" ? a : str(a?.name)).filter(Boolean).join(", ") : str(authorRaw);
+  let date = str(get("date"));
+  if (date && /^today$/i.test(date)) {
+    const now = options.now ?? /* @__PURE__ */ new Date();
+    date = now.toLocaleDateString("en-US", { year: "numeric", month: "long", day: "numeric" });
+  }
+  const logo = str(get("logo", "coverlogo"));
+  const coverRaw = get("cover", "coverpage", "titlepage");
+  let cover = false;
+  if (coverRaw !== void 0) {
+    const b = bool(coverRaw);
+    if (b === void 0 && coverRaw && typeof coverRaw === "object") cover = true;
+    else if (b === void 0) ignore("cover", coverRaw, "Use `cover: true` or `cover: false`.");
+    else cover = b;
+  }
+  if (cover && !title) {
+    notices.push({
+      code: "setting-ignored",
+      message: "A cover page was asked for, but the document has no title.",
+      remedy: "Add `title: \u2026` to the settings at the top (subtitle, author, date and logo are optional)."
+    });
+  }
+  const tocRaw = get("toc", "tableofcontents", "contents");
+  let tocEnabled = false;
+  let tocDepth = 3;
+  let tocTitle = "Contents";
+  if (tocRaw !== void 0) {
+    if (tocRaw && typeof tocRaw === "object" && !Array.isArray(tocRaw)) {
+      const o = tocRaw;
+      tocEnabled = bool(o.enabled ?? true) ?? true;
+      const d = Number(o.depth);
+      if (Number.isFinite(d)) tocDepth = d;
+      tocTitle = str(o.title) ?? tocTitle;
+    } else {
+      const b = bool(tocRaw);
+      if (b === void 0) ignore("toc", tocRaw, "Use `toc: true`, or `toc: { depth: 2, title: Contents }`.");
+      else tocEnabled = b;
+    }
+  }
+  const depthRaw = get("tocdepth");
+  if (depthRaw !== void 0 && Number.isFinite(Number(depthRaw))) tocDepth = Number(depthRaw);
+  tocDepth = Math.min(6, Math.max(1, Math.round(tocDepth)));
+  tocTitle = str(get("toctitle")) ?? tocTitle;
+  const headerRaw = get("header", "pageheader", "runningheader");
+  const footerRaw = get("footer", "pagefooter", "runningfooter");
+  let header = parseRunning(headerRaw);
+  if (header === void 0) {
+    if (headerRaw !== void 0) ignore("header", headerRaw, 'Use text like `header: "{title} | | {date}"`, or `header: false`.');
+    header = null;
+  }
+  let footer = parseRunning(footerRaw);
+  if (footer === void 0) {
+    if (footerRaw !== void 0) ignore("footer", footerRaw, 'Use text like `footer: "Page {page} of {pages}"`, or `footer: false`.');
+    footer = DEFAULT_FOOTER;
+  }
+  if (bool(get("pagenumbers")) === false && footerRaw === void 0) footer = null;
+  const firstRaw = get("firstpage", "differentfirstpage", "titlepageheader");
+  let differentFirstPage = cover;
+  if (firstRaw !== void 0) {
+    const b = bool(firstRaw);
+    if (b !== void 0) differentFirstPage = b || cover;
+    else if (/different/i.test(String(firstRaw))) differentFirstPage = true;
+    else if (/same/i.test(String(firstRaw))) differentFirstPage = cover;
+    else ignore("firstPage", firstRaw, "Use `firstPage: different` or `firstPage: same`.");
+  }
+  let columns = 1;
+  const colRaw = get("columns", "cols", "columncount");
+  if (colRaw !== void 0) {
+    const n = Number(colRaw);
+    if (Number.isInteger(n) && n >= 1 && n <= 3) columns = n;
+    else ignore("columns", colRaw, "Use 1, 2 or 3.");
+  }
+  let citationStyle = "apa";
+  const cslRaw = get("citationstyle", "csl", "citestyle", "referencestyle");
+  if (cslRaw !== void 0) {
+    const s = String(cslRaw).toLowerCase();
+    if (/apa/.test(s)) citationStyle = "apa";
+    else if (/mla|modern-language/.test(s)) citationStyle = "mla";
+    else if (/chicago/.test(s)) citationStyle = "chicago";
+    else ignore("citation style", cslRaw, "Use `apa`, `mla` or `chicago`.");
+  }
+  const refs = /* @__PURE__ */ new Map();
+  for (const r of options.references ?? []) refs.set(r.id, r);
+  const refsRaw = get("references", "bibliography", "sources");
+  if (refsRaw !== void 0) {
+    if (Array.isArray(refsRaw)) {
+      for (const r of refsRaw) {
+        const item = normalizeReference(r);
+        if (item) refs.set(item.id, item);
+        else ignore("references", r, "Every reference needs an `id:` (the key you cite as [@id]) and usually `title`, `author`, `issued`/`year`.");
+      }
+    } else if (refsRaw && typeof refsRaw === "object") {
+      for (const [id, r] of Object.entries(refsRaw)) {
+        const item = normalizeReference({ id, ...r });
+        if (item) refs.set(item.id, item);
+      }
+    } else if (typeof refsRaw !== "string") {
+      ignore("references", refsRaw, "List references as CSL-JSON items: `- id: smith2020` with `title`, `author`, `issued`.");
+    }
+  }
+  let fontSize = 11;
+  const fsRaw = get("fontsize", "basefontsize");
+  if (fsRaw !== void 0) {
+    const n = parseLength(typeof fsRaw === "number" ? `${fsRaw}pt` : fsRaw);
+    if (n && n >= 6 && n <= 24) fontSize = n;
+    else ignore("fontSize", fsRaw, "Use a size in points between 6 and 24, e.g. `fontSize: 11`.");
+  }
+  return {
+    title,
+    subtitle,
+    author,
+    date,
+    logo,
+    lang: str(get("lang", "language")) ?? "en",
+    page: { size, ...PAGE_SIZES[size], orientation, margins },
+    cover: cover && Boolean(title),
+    toc: { enabled: tocEnabled, depth: tocDepth, title: tocTitle },
+    header,
+    footer,
+    differentFirstPage,
+    columns,
+    numberSections: bool(get("numbersections", "sectionnumbers", "numberedheadings", "numberheadings")) ?? false,
+    citationStyle,
+    bibliographyTitle: str(get("bibliographytitle", "referencestitle", "referencesectiontitle")) ?? BIBLIOGRAPHY_TITLES[citationStyle],
+    references: [...refs.values()],
+    hyphenate: bool(get("hyphenate", "hyphenation")) ?? true,
+    fontSize
+  };
+}
+function fillTemplate(template, s, page, pages) {
+  return template.replace(/\{(page|pages|title|subtitle|author|date)\}/gi, (_m, k) => {
+    switch (k.toLowerCase()) {
+      case "page":
+        return String(page);
+      case "pages":
+        return String(pages);
+      case "title":
+        return s.title ?? "";
+      case "subtitle":
+        return s.subtitle ?? "";
+      case "author":
+        return s.author ?? "";
+      default:
+        return s.date ?? "";
+    }
+  });
+}
+function templateParts(template, s) {
+  const filled = template.replace(/\{(title|subtitle|author|date)\}/gi, (m) => fillTemplate(m, s, "", ""));
+  const out = [];
+  let last = 0;
+  for (const m of filled.matchAll(/\{(page|pages)\}/gi)) {
+    if (m.index > last) out.push({ text: filled.slice(last, m.index) });
+    out.push({ field: m[1].toLowerCase() });
+    last = m.index + m[0].length;
+  }
+  if (last < filled.length) out.push({ text: filled.slice(last) });
+  return out;
+}
+
+// src/document/docx.ts
+var TW = 20;
+function strip(o) {
+  const out = {};
+  for (const [k, v] of Object.entries(o)) if (v !== void 0) out[k] = v;
+  return out;
+}
+var HEX = { text: "1F2937", heading: "111827", muted: "6B7280", link: "1D4ED8", rule: "D1D5DB", codeBg: "F6F8FA", danger: "B91C1C" };
+var MONO = "Consolas";
+function bm(c, id) {
+  let name = c.bookmarks.get(id);
+  if (name) return name;
+  const base = `m_${id.replace(/[^A-Za-z0-9_]/g, "_")}`.slice(0, 36);
+  name = base;
+  const used = new Set(c.bookmarks.values());
+  for (let n = 2; used.has(name); n++) name = `${base.slice(0, 33)}_${n}`;
+  c.bookmarks.set(id, name);
+  return name;
+}
+function runs(nodes, c, st = {}) {
+  const { d } = c;
+  const out = [];
+  const tr = (text, extra = {}) => new d.TextRun(
+    strip({
+      text,
+      bold: st.bold,
+      italics: st.italics,
+      strike: st.strike,
+      size: st.size ? st.size * 2 : void 0,
+      color: st.color,
+      ...extra
+    })
+  );
+  for (const n of nodes) {
+    switch (n.type) {
+      case "text":
+        out.push(tr(n.value));
+        break;
+      case "strong":
+        out.push(...runs(n.children, c, { ...st, bold: true }));
+        break;
+      case "emphasis":
+        out.push(...runs(n.children, c, { ...st, italics: true }));
+        break;
+      case "delete":
+        out.push(...runs(n.children, c, { ...st, strike: true }));
+        break;
+      case "code":
+        out.push(tr(n.value, { font: MONO, shading: { type: d.ShadingType.CLEAR, fill: "F3F4F6", color: "auto" } }));
+        break;
+      case "break":
+        out.push(new d.TextRun({ break: 1 }));
+        break;
+      case "link":
+        if (/^(https?:|mailto:|tel:)/i.test(n.url)) {
+          out.push(
+            new d.ExternalHyperlink({
+              link: n.url,
+              children: runs(n.children, c, { ...st, color: HEX.link })
+            })
+          );
+        } else out.push(...runs(n.children, c, st));
+        break;
+      case "image":
+        out.push(tr(n.alt));
+        break;
+      case "xref": {
+        if (!n.resolved) {
+          out.push(tr(n.label, { bold: true, color: HEX.danger }));
+          break;
+        }
+        const id = n.target.startsWith("sec:") ? n.target.slice(4) : n.target;
+        out.push(new d.InternalHyperlink({ anchor: bm(c, id), children: [tr(n.label, { color: HEX.link })] }));
+        break;
+      }
+      case "cite":
+        if (n.resolved) {
+          out.push(new d.InternalHyperlink({ anchor: bm(c, `ref-${n.keys[0]}`), children: [tr(n.label)] }));
+        } else out.push(tr(n.label, { bold: true, color: HEX.danger }));
+        break;
+      case "noteRef":
+        out.push(new d.InternalHyperlink({ anchor: bm(c, `note-${n.n}`), children: [tr(String(n.n), { superScript: true, color: HEX.link })] }));
+        break;
+    }
+  }
+  return out;
+}
+function captionParagraph(cap, c, keepNext) {
+  const { d } = c;
+  const word = cap.kind === "fig" ? "Figure" : "Table";
+  const labelRuns = [new d.TextRun({ text: `${word} `, bold: true }), new d.SimpleField(`SEQ ${word} \\* ARABIC`, String(cap.number))];
+  const children = cap.id ? [new d.Bookmark({ id: bm(c, `${cap.kind}:${cap.id}`), children: labelRuns })] : labelRuns;
+  if (cap.children.length) children.push(new d.TextRun({ text: ": " }), ...runs(cap.children, c));
+  return new d.Paragraph({
+    style: "Caption",
+    keepNext,
+    keepLines: true,
+    alignment: cap.kind === "fig" ? d.AlignmentType.CENTER : d.AlignmentType.LEFT,
+    children
+  });
+}
+function numberingRef(c, ordered, start) {
+  const ref = ordered ? `matrx-num-${start}` : "matrx-bullets";
+  if (!c.numbering.has(ref)) {
+    const { d } = c;
+    const bullets = ["\u2022", "\u25E6", "\u25AA"];
+    const formats = [d.LevelFormat.DECIMAL, d.LevelFormat.LOWER_LETTER, d.LevelFormat.LOWER_ROMAN];
+    c.numbering.set(
+      ref,
+      Array.from({ length: 6 }, (_, level) => ({
+        level,
+        format: ordered ? formats[level % 3] : d.LevelFormat.BULLET,
+        text: ordered ? `%${level + 1}.` : bullets[level % 3],
+        start: ordered && level === 0 ? start : 1,
+        alignment: d.AlignmentType.LEFT,
+        style: { paragraph: { indent: { left: 360 * (level + 1) + 60, hanging: 300 } } }
+      }))
+    );
+  }
+  return ref;
+}
+function blocks(list, c, o = {}) {
+  const out = [];
+  for (const b of list) out.push(...block(b, c, o));
+  return out;
+}
+function para(c, o, opts) {
+  const { d } = c;
+  return new d.Paragraph(
+    strip({
+      ...opts,
+      indent: o.indent ? { left: o.indent } : opts.indent,
+      border: o.quote ? { left: { style: d.BorderStyle.SINGLE, size: 18, color: HEX.rule, space: 8 } } : opts.border
+    })
+  );
+}
+function block(b, c, o) {
+  const { d } = c;
+  switch (b.type) {
+    case "heading": {
+      const level = Math.min(6, Math.max(1, b.level - c.minLevel + 1));
+      const heading = [d.HeadingLevel.HEADING_1, d.HeadingLevel.HEADING_2, d.HeadingLevel.HEADING_3, d.HeadingLevel.HEADING_4, d.HeadingLevel.HEADING_5, d.HeadingLevel.HEADING_6][level - 1];
+      const kids = [...b.number ? [new d.TextRun({ text: `${b.number}  `, color: HEX.muted })] : [], ...runs(b.children, c)];
+      return [
+        new d.Paragraph({
+          heading,
+          keepNext: true,
+          keepLines: true,
+          children: [new d.Bookmark({ id: bm(c, b.id), children: kids })]
+          // The bibliography/notes headings are not numbered and still in the TOC.
+        })
+      ];
+    }
+    case "paragraph":
+      return [para(c, o, { children: runs(b.children, c), widowControl: true })];
+    case "list": {
+      const level = o.listLevel ?? 0;
+      const ref = numberingRef(c, b.ordered, b.start);
+      const instance = ++c.listInstance;
+      const out = [];
+      for (const it of b.items) {
+        const [first, ...rest] = it.children;
+        const firstRuns = first?.type === "paragraph" ? runs(first.children, c) : [];
+        if (it.checked !== null) {
+          out.push(
+            para(c, { ...o, indent: (o.indent ?? 0) + 360 * (level + 1) }, {
+              children: [new d.TextRun({ text: it.checked ? "\u2612 " : "\u2610 ", font: "Segoe UI Symbol" }), ...firstRuns],
+              widowControl: true
+            })
+          );
+        } else {
+          out.push(new d.Paragraph({ numbering: { reference: ref, level, instance }, children: firstRuns, widowControl: true }));
+        }
+        const tail = first && first.type !== "paragraph" ? [first, ...rest] : rest;
+        for (const child of tail) {
+          if (child.type === "list") out.push(...block(child, c, { ...o, listLevel: level + 1 }));
+          else out.push(...block(child, c, { ...o, indent: (o.indent ?? 0) + 360 * (level + 1) + 60 }));
+        }
+      }
+      return out;
+    }
+    case "blockquote":
+      return blocks(b.children, c, { ...o, indent: (o.indent ?? 0) + 360, quote: true });
+    case "code": {
+      const lines = b.value.replace(/\n$/, "").split("\n");
+      const keep = lines.length <= 45;
+      return lines.map(
+        (l, i) => new d.Paragraph({
+          style: "SourceCode",
+          keepNext: keep && i < lines.length - 1,
+          keepLines: true,
+          ...o.indent ? { indent: { left: o.indent } } : {},
+          children: [new d.TextRun({ text: l.replace(/\t/g, "    ") || " ", font: MONO })]
+        })
+      );
+    }
+    case "table": {
+      const n = Math.max(b.header.length, ...b.rows.map((r) => r.length), 1);
+      const keep = b.rows.length <= 20;
+      const alignOf = (i) => b.align[i] === "center" ? d.AlignmentType.CENTER : b.align[i] === "right" ? d.AlignmentType.RIGHT : d.AlignmentType.LEFT;
+      const border = { style: d.BorderStyle.SINGLE, size: 4, color: "E5E7EB" };
+      const none = { style: d.BorderStyle.NONE, size: 0, color: "FFFFFF" };
+      const row = (cells, head, last) => new d.TableRow({
+        tableHeader: head,
+        cantSplit: true,
+        children: Array.from(
+          { length: n },
+          (_, i) => new d.TableCell({
+            ...head ? { shading: { type: d.ShadingType.CLEAR, fill: "F3F4F6", color: "auto" } } : {},
+            margins: { top: 60, bottom: 60, left: 100, right: 100 },
+            borders: { top: none, left: none, right: none, bottom: head ? { ...border, size: 10, color: HEX.heading } : border },
+            children: [
+              new d.Paragraph({
+                alignment: alignOf(i),
+                keepNext: keep && !last,
+                children: runs(cells[i] ?? [], c, head ? { bold: true } : {})
+              })
+            ]
+          })
+        )
+      });
+      const out = [];
+      if (b.caption) out.push(captionParagraph(b.caption, c, true));
+      out.push(
+        new d.Table({
+          width: { size: 100, type: d.WidthType.PERCENTAGE },
+          rows: [row(b.header, true, b.rows.length === 0), ...b.rows.map((r, i) => row(r, false, i === b.rows.length - 1))]
+        })
+      );
+      out.push(new d.Paragraph({ spacing: { after: 60 }, children: [] }));
+      return out;
+    }
+    case "figure": {
+      const img = c.images?.get(b.url);
+      const out = [];
+      if (img) {
+        const maxW = c.width;
+        const maxH = (c.s.page.height - c.s.page.margins.top - c.s.page.margins.bottom) * 0.6;
+        const scale = Math.min(1, maxW / img.width, maxH / img.height);
+        const px = (v) => Math.round(v * scale * (96 / 72));
+        out.push(
+          new d.Paragraph({
+            alignment: d.AlignmentType.CENTER,
+            keepNext: Boolean(b.caption),
+            keepLines: true,
+            children: [
+              new d.ImageRun({
+                type: img.mime === "image/png" ? "png" : img.mime === "image/gif" ? "gif" : "jpg",
+                data: img.bytes,
+                transformation: { width: px(img.width), height: px(img.height) },
+                altText: { name: b.alt || "image", description: b.alt, title: b.alt }
+              })
+            ]
+          })
+        );
+      } else {
+        out.push(
+          new d.Paragraph({
+            alignment: d.AlignmentType.CENTER,
+            keepNext: Boolean(b.caption),
+            children: [new d.TextRun({ text: `[Image unavailable: ${b.alt || b.url}]`, italics: true, color: HEX.muted })]
+          })
+        );
+      }
+      if (b.caption) out.push(captionParagraph(b.caption, c, false));
+      return out;
+    }
+    case "rule":
+      return [new d.Paragraph({ border: { bottom: { style: d.BorderStyle.SINGLE, size: 6, color: HEX.rule, space: 1 } }, children: [] })];
+    case "pageBreak":
+      return [new d.Paragraph({ children: [new d.PageBreak()] })];
+    case "toc":
+      return [
+        new d.Paragraph({ style: "TOCHeading", keepNext: true, children: [new d.TextRun(c.s.toc.title)] }),
+        new d.TableOfContents(c.s.toc.title, {
+          hyperlink: true,
+          headingStyleRange: `1-${c.s.toc.depth}`,
+          cachedEntries: c.tree.toc.map((e) => {
+            const page = pagesFor(c).get(e.id);
+            return { title: e.text, level: e.level, href: bm(c, e.id), ...page ? { page } : {} };
+          })
+        })
+      ];
+    case "notes":
+      return c.tree.notes.flatMap((n) => {
+        const [first, ...rest] = n.children;
+        const lead = new d.Paragraph({
+          indent: { left: 360, hanging: 360 },
+          children: [
+            new d.Bookmark({ id: bm(c, `note-${n.n}`), children: [new d.TextRun({ text: `${n.n}.	`, color: HEX.muted })] }),
+            ...first?.type === "paragraph" ? runs(first.children, c) : []
+          ]
+        });
+        const tail = first && first.type !== "paragraph" ? [first, ...rest] : rest;
+        return [lead, ...blocks(tail, c, { indent: 360 })];
+      });
+    case "bibliography":
+      return c.tree.bibliography.map(
+        (e) => new d.Paragraph({
+          indent: { left: 720, hanging: 720 },
+          spacing: { after: 120 },
+          children: [new d.Bookmark({ id: bm(c, `ref-${e.id}`), children: [] }), ...runs(e.children, c)]
+        })
+      );
+  }
+}
+var PAGES_KEY = /* @__PURE__ */ Symbol("pages");
+function pagesFor(c) {
+  return c[PAGES_KEY] ??= /* @__PURE__ */ new Map();
+}
+function runningParagraph(t2, c, widthPt) {
+  const { d } = c;
+  const slot = (v) => v ? templateParts(v, c.s).map(
+    (p) => "field" in p ? new d.TextRun({ children: [p.field === "page" ? d.PageNumber.CURRENT : d.PageNumber.TOTAL_PAGES], size: 18, color: HEX.muted }) : new d.TextRun({ text: p.text, size: 18, color: HEX.muted })
+  ) : [];
+  return new d.Paragraph({
+    tabStops: [
+      { type: d.TabStopType.CENTER, position: Math.round(widthPt / 2 * TW) },
+      { type: d.TabStopType.RIGHT, position: Math.round(widthPt * TW) }
+    ],
+    children: [...slot(t2.left), new d.TextRun({ children: [new d.Tab()] }), ...slot(t2.center), new d.TextRun({ children: [new d.Tab()] }), ...slot(t2.right)]
+  });
+}
+function coverChildren(c) {
+  const { d, s } = c;
+  const out = [];
+  const pageH = (s.page.orientation === "landscape" ? s.page.width : s.page.height) - s.page.margins.top - s.page.margins.bottom;
+  out.push(new d.Paragraph({ spacing: { before: Math.round(pageH * 0.28 * TW) }, children: [] }));
+  const logo = s.logo ? c.images?.get(s.logo) : void 0;
+  if (logo) {
+    const scale = Math.min(1, 160 / logo.width, 72 / logo.height);
+    out.push(
+      new d.Paragraph({
+        spacing: { after: 480 },
+        children: [
+          new d.ImageRun({
+            type: logo.mime === "image/png" ? "png" : logo.mime === "image/gif" ? "gif" : "jpg",
+            data: logo.bytes,
+            transformation: { width: Math.round(logo.width * scale * (96 / 72)), height: Math.round(logo.height * scale * (96 / 72)) }
+          })
+        ]
+      })
+    );
+  }
+  out.push(new d.Paragraph({ style: "Title", children: [new d.TextRun(s.title ?? "")] }));
+  if (s.subtitle) out.push(new d.Paragraph({ style: "Subtitle", children: [new d.TextRun(s.subtitle)] }));
+  if (s.author) out.push(new d.Paragraph({ spacing: { before: 720 }, children: [new d.TextRun({ text: s.author, size: 24, color: "4B5563" })] }));
+  if (s.date) out.push(new d.Paragraph({ children: [new d.TextRun({ text: s.date, size: 24, color: "4B5563" })] }));
+  out.push(new d.Paragraph({ children: [new d.PageBreak()] }));
+  return out;
+}
+async function documentToDocx(tree, options = {}) {
+  const d = await import("docx");
+  const s = tree.settings;
+  const levels = [];
+  for (const sec of tree.sections) for (const b of sec.blocks) if (b.type === "heading") levels.push(b.level);
+  const c = {
+    d,
+    tree,
+    s,
+    images: options.images,
+    bookmarks: /* @__PURE__ */ new Map(),
+    numbering: /* @__PURE__ */ new Map(),
+    listInstance: 0,
+    width: s.page.width - s.page.margins.left - s.page.margins.right,
+    tocIds: new Set(tree.toc.map((e) => e.id)),
+    minLevel: Math.min(7, ...levels)
+  };
+  if (options.headingPages) for (const [k, v] of options.headingPages) pagesFor(c).set(k, v);
+  const m = s.page.margins;
+  const sections = tree.sections.map((sec, idx) => {
+    const landscape = sec.orientation === "landscape";
+    const pageW = landscape ? s.page.height : s.page.width;
+    const full = pageW - m.left - m.right;
+    const gap = 18;
+    c.width = (full - gap * (sec.columns - 1)) / sec.columns;
+    const children = [];
+    if (idx === 0 && s.cover) children.push(...coverChildren(c));
+    children.push(...blocks(sec.blocks, c));
+    if (children.length === 0) children.push(new d.Paragraph({ children: [] }));
+    const header = s.header ? new d.Header({ children: [runningParagraph(s.header, c, full)] }) : void 0;
+    const footer = s.footer ? new d.Footer({ children: [runningParagraph(s.footer, c, full)] }) : void 0;
+    const firstPageOnly = idx === 0 && s.differentFirstPage;
+    return strip({
+      properties: strip({
+        type: d.SectionType.NEXT_PAGE,
+        titlePage: firstPageOnly,
+        page: {
+          size: { width: Math.round(s.page.width * TW), height: Math.round(s.page.height * TW), orientation: landscape ? d.PageOrientation.LANDSCAPE : d.PageOrientation.PORTRAIT },
+          margin: {
+            top: Math.round(m.top * TW),
+            right: Math.round(m.right * TW),
+            bottom: Math.round(m.bottom * TW),
+            left: Math.round(m.left * TW),
+            header: Math.round(Math.max(18, m.top / 2 - 6) * TW),
+            footer: Math.round(Math.max(18, m.bottom / 2 - 6) * TW)
+          }
+        },
+        column: sec.columns > 1 ? { count: sec.columns, space: gap * TW, equalWidth: true } : void 0
+      }),
+      headers: header ? { default: header, ...firstPageOnly ? { first: new d.Header({ children: [new d.Paragraph({ children: [] })] }) } : {} } : void 0,
+      footers: footer ? { default: footer, ...firstPageOnly ? { first: new d.Footer({ children: [new d.Paragraph({ children: [] })] }) } : {} } : void 0,
+      children
+    });
+  });
+  const size = s.fontSize * 2;
+  const heading = (id, name, pt2, level) => ({
+    id,
+    name,
+    basedOn: "Normal",
+    next: "Normal",
+    quickFormat: true,
+    run: { font: "Calibri", size: Math.round(pt2 * 2), bold: true, color: HEX.heading },
+    paragraph: { spacing: { before: Math.round(pt2 * 14), after: Math.round(pt2 * 5) }, keepNext: true, keepLines: true, outlineLevel: level }
+  });
+  const doc = new d.Document({
+    creator: s.author ?? "AI Matrx",
+    title: s.title ?? "Document",
+    ...s.subtitle ? { description: s.subtitle } : {},
+    features: { updateFields: true },
+    hyphenation: { autoHyphenation: s.hyphenate, doNotHyphenateCaps: true },
+    numbering: { config: [...c.numbering.entries()].map(([reference, levels2]) => ({ reference, levels: levels2 })) },
+    styles: {
+      default: {
+        document: { run: { font: "Cambria", size, color: HEX.text }, paragraph: { spacing: { after: 140, line: 300 } } }
+      },
+      paragraphStyles: [
+        heading("Heading1", "Heading 1", s.fontSize * 1.8, 0),
+        heading("Heading2", "Heading 2", s.fontSize * 1.45, 1),
+        heading("Heading3", "Heading 3", s.fontSize * 1.2, 2),
+        heading("Heading4", "Heading 4", s.fontSize * 1.05, 3),
+        heading("Heading5", "Heading 5", s.fontSize, 4),
+        heading("Heading6", "Heading 6", s.fontSize, 5),
+        { id: "Title", name: "Title", basedOn: "Normal", run: { font: "Calibri", size: 60, bold: true, color: HEX.heading }, paragraph: { spacing: { after: 200 } } },
+        { id: "Subtitle", name: "Subtitle", basedOn: "Normal", run: { font: "Calibri", size: 32, color: "4B5563" } },
+        { id: "Caption", name: "Caption", basedOn: "Normal", next: "Normal", run: { font: "Calibri", size: Math.round(s.fontSize * 1.8), color: HEX.muted }, paragraph: { spacing: { before: 60, after: 160 } } },
+        { id: "TOCHeading", name: "TOC Heading", basedOn: "Normal", next: "Normal", run: { font: "Calibri", size: Math.round(s.fontSize * 2.9), bold: true, color: HEX.heading }, paragraph: { spacing: { after: 200 } } },
+        { id: "SourceCode", name: "Source Code", basedOn: "Normal", run: { font: MONO, size: Math.round(s.fontSize * 1.6) }, paragraph: { spacing: { after: 0, line: 260 }, shading: { type: d.ShadingType.CLEAR, fill: HEX.codeBg, color: "auto" } } }
+      ]
+    },
+    sections
+  });
+  const buf = await d.Packer.toArrayBuffer(doc);
+  return renumberBookmarks(new Uint8Array(buf));
+}
+function renumberBookmarkXml(xml) {
+  let n = 0;
+  let open = null;
+  return xml.replace(/<w:bookmark(Start|End)\b([^>]*?)w:id="\d+"/g, (_m, kind, attrs) => {
+    if (kind === "Start") {
+      open = ++n;
+      return `<w:bookmarkStart${attrs}w:id="${open}"`;
+    }
+    const id = open ?? ++n;
+    open = null;
+    return `<w:bookmarkEnd${attrs}w:id="${id}"`;
+  });
+}
+async function renumberBookmarks(bytes) {
+  const JSZipMod = await import("jszip");
+  const JSZip = JSZipMod.default ?? JSZipMod;
+  const zip = await JSZip.loadAsync(bytes);
+  const entry = zip.file("word/document.xml");
+  if (!entry) return bytes;
+  const xml = await entry.async("string");
+  zip.file("word/document.xml", renumberBookmarkXml(xml));
+  return zip.generateAsync({ type: "uint8array", compression: "DEFLATE" });
+}
+
+// src/document/epub.ts
+var import_html_escape2 = require("@ai-matrx/kit/html-escape");
+
+// src/document/html.ts
+var import_html_escape = require("@ai-matrx/kit/html-escape");
+
+// src/directives.ts
+var PAGE_BREAK_CLASS = "matrx-page-break";
+var PAGE_BREAK_LABEL = "Page break";
+var COMMENT_FORM = /^<!--\s*(?:page[\s_-]?break|new[\s_-]?page)\s*-->$/i;
+var LATEX_FORM = /^\\(?:pagebreak|newpage|clearpage)\s*(?:\{\s*\})?$/i;
+var DIV_FORM = /^<div\b([^>]*)>\s*<\/div>$|^<div\b([^>]*)\/>$/i;
+var DIV_BREAK_ATTR = /(?:page-break-(?:after|before)\s*:\s*always|break-(?:after|before)\s*:\s*page|class\s*=\s*["'](?:[^"']*\s)?page-?break(?:\s[^"']*)?["'])/i;
+function indentColumns(line) {
+  let cols = 0;
+  for (const ch of line) {
+    if (ch === " " || ch === "\xA0") cols += 1;
+    else if (ch === "	") cols += 4;
+    else break;
+  }
+  return cols;
+}
+function isPageBreakLine(line) {
+  if (indentColumns(line) >= 4) return false;
+  const t2 = line.trim();
+  if (t2.length < 8 || t2.length > 200) return false;
+  if (COMMENT_FORM.test(t2) || LATEX_FORM.test(t2)) return true;
+  const div = DIV_FORM.exec(t2);
+  if (!div) return false;
+  return DIV_BREAK_ATTR.test(div[1] ?? div[2] ?? "");
+}
+var SECTION_FORM = /^<!--\s*section(?:[\s_-]?break)?\b\s*:?\s*([^>]*?)\s*-->$/i;
+function parseSectionBreakLine(line) {
+  if (indentColumns(line) >= 4) return null;
+  const m = SECTION_FORM.exec(line.trim());
+  if (!m) return null;
+  const words = (m[1] ?? "").toLowerCase();
+  const out = {};
+  if (/\blandscape\b/.test(words)) out.orientation = "landscape";
+  else if (/\bportrait\b/.test(words)) out.orientation = "portrait";
+  const cols = /\b(?:columns?|cols?)\s*[=:]\s*(\d)\b/.exec(words) ?? /\b(\d)\s*[-\s]?columns?\b/.exec(words);
+  if (cols) {
+    const n = Math.min(3, Math.max(1, Number(cols[1])));
+    out.columns = n;
+  }
+  return out;
+}
+var TOC_FORM = /^(?:\[\[\s*toc\s*\]\]|\[toc\]|\$\{toc\}|<!--\s*toc\s*-->|\\tableofcontents)$/i;
+var BIBLIOGRAPHY_FORM = /^(?:\[\[\s*(?:bibliography|references)\s*\]\]|<!--\s*(?:bibliography|references)\s*-->|\\printbibliography|\\bibliography\{[^}]*\})$/i;
+function isTocLine(line) {
+  return indentColumns(line) < 4 && TOC_FORM.test(line.trim());
+}
+function isBibliographyLine(line) {
+  return indentColumns(line) < 4 && BIBLIOGRAPHY_FORM.test(line.trim());
+}
+
+// src/document/html.ts
+var SAFE_URL = /^(?:https?:|mailto:|tel:|#|\/|\.{0,2}\/|data:image\/(?:png|jpe?g|gif|webp);)/i;
+function safeUrl(url) {
+  const u = url.trim();
+  if (!u) return null;
+  if (!/^[a-z][a-z0-9+.-]*:/i.test(u)) return u;
+  return SAFE_URL.test(u) ? u : null;
+}
+var br = (x) => x.xhtml ? "<br/>" : "<br>";
+function renderInlineHtml(nodes, x) {
+  return nodes.map((n) => {
+    switch (n.type) {
+      case "text":
+        return (0, import_html_escape.escapeHtml)(n.value);
+      case "strong":
+        return `<strong>${renderInlineHtml(n.children, x)}</strong>`;
+      case "emphasis":
+        return `<em>${renderInlineHtml(n.children, x)}</em>`;
+      case "delete":
+        return `<del>${renderInlineHtml(n.children, x)}</del>`;
+      case "code":
+        return `<code>${(0, import_html_escape.escapeHtml)(n.value)}</code>`;
+      case "break":
+        return br(x);
+      case "link": {
+        const href2 = safeUrl(n.url);
+        const inner = renderInlineHtml(n.children, x);
+        return href2 ? `<a href="${(0, import_html_escape.escapeHtml)(href2)}">${inner}</a>` : inner;
+      }
+      case "image": {
+        const src = imageSrc(n.url, x);
+        if (!src) return (0, import_html_escape.escapeHtml)(n.alt);
+        return `<img class="doc-inline-img" src="${(0, import_html_escape.escapeHtml)(src)}" alt="${(0, import_html_escape.escapeHtml)(n.alt)}"${x.xhtml ? "/" : ""}>`;
+      }
+      case "xref": {
+        if (!n.resolved) return `<span class="doc-xref-missing">${(0, import_html_escape.escapeHtml)(n.label)}</span>`;
+        const id = n.target.startsWith("sec:") ? n.target.slice(4) : n.target;
+        return `<a class="doc-xref" href="${(0, import_html_escape.escapeHtml)(href(id, x))}">${(0, import_html_escape.escapeHtml)(n.label)}</a>`;
+      }
+      case "cite":
+        return n.resolved ? `<a class="doc-cite" href="${(0, import_html_escape.escapeHtml)(href("ref-" + (n.keys[0] ?? ""), x))}">${(0, import_html_escape.escapeHtml)(n.label)}</a>` : `<span class="doc-cite doc-cite-missing">${(0, import_html_escape.escapeHtml)(n.label)}</span>`;
+      case "noteRef":
+        return `<sup class="doc-note-ref"><a href="${(0, import_html_escape.escapeHtml)(href(`note-${n.n}`, x))}" id="noteref-${n.n}">${n.n}</a></sup>`;
+      default:
+        return "";
+    }
+  }).join("");
+}
+var href = (id, x) => x.hrefFor ? x.hrefFor(id) : `#${id}`;
+function imageSrc(url, x) {
+  if (x.srcFor) return x.srcFor(url);
+  const resolved = x.images?.get(url);
+  if (resolved) return resolved.dataUrl;
+  return safeUrl(url);
+}
+function captionHtml(c, tag, x) {
+  const text = renderInlineHtml(c.children, x);
+  return `<${tag} class="doc-caption"><span class="doc-caption-label">${c.label}</span>${text ? `: ${text}` : ""}</${tag}>`;
+}
+function tocHtml(x) {
+  const { tree } = x;
+  const items = tree.toc.map(
+    (e) => `<li class="toc-l${e.level}"><a href="${(0, import_html_escape.escapeHtml)(href(e.id, x))}"><span class="toc-text">${(0, import_html_escape.escapeHtml)(e.text)}</span><span class="toc-page"></span></a></li>`
+  ).join("");
+  return `<nav class="doc-toc" role="doc-toc"><h2 class="doc-toc-title">${(0, import_html_escape.escapeHtml)(
+    tree.settings.toc.title
+  )}</h2><ol>${items}</ol></nav>`;
+}
+function renderBlocksHtml(blocks3, x) {
+  return blocks3.map((b) => renderBlockHtml(b, x)).join("\n");
+}
+function renderBlockHtml(b, x) {
+  switch (b.type) {
+    case "heading": {
+      const num = b.number ? `<span class="doc-heading-number">${b.number}</span> ` : "";
+      return `<h${b.level} id="${(0, import_html_escape.escapeHtml)(b.id)}">${num}${renderInlineHtml(b.children, x)}</h${b.level}>`;
+    }
+    case "paragraph":
+      return `<p>${renderInlineHtml(b.children, x)}</p>`;
+    case "list": {
+      const tag = b.ordered ? "ol" : "ul";
+      const start = b.ordered && b.start !== 1 ? ` start="${b.start}"` : "";
+      const task = b.items.some((i) => i.checked !== null);
+      const items = b.items.map((i) => {
+        const box = i.checked === null ? "" : `<span class="doc-task-box${i.checked ? " is-checked" : ""}" role="img" aria-label="${i.checked ? "done" : "not done"}"></span>`;
+        const inner = i.children.length === 1 && i.children[0]?.type === "paragraph" ? renderInlineHtml(i.children[0].children, x) : renderBlocksHtml(i.children, x);
+        return `<li${i.checked !== null ? ' class="doc-task"' : ""}>${box}${inner}</li>`;
+      }).join("");
+      return `<${tag}${start}${task ? ' class="doc-task-list"' : ""}>${items}</${tag}>`;
+    }
+    case "blockquote":
+      return `<blockquote>${renderBlocksHtml(b.children, x)}</blockquote>`;
+    case "code":
+      return `<pre class="doc-code"${b.lang ? ` data-language="${(0, import_html_escape.escapeHtml)(b.lang)}"` : ""}><code>${(0, import_html_escape.escapeHtml)(
+        b.value
+      )}</code></pre>`;
+    case "table": {
+      const al = (i) => {
+        const a = b.align[i];
+        return a ? ` style="text-align:${a}"` : "";
+      };
+      const head = `<thead><tr>${b.header.map((c, i) => `<th${al(i)}>${renderInlineHtml(c, x)}</th>`).join("")}</tr></thead>`;
+      const body = `<tbody>${b.rows.map((r) => `<tr>${r.map((c, i) => `<td${al(i)}>${renderInlineHtml(c, x)}</td>`).join("")}</tr>`).join("")}</tbody>`;
+      const id = b.caption?.id ? ` id="tbl:${(0, import_html_escape.escapeHtml)(b.caption.id)}"` : "";
+      return `<div class="doc-table-wrap"${id}><table>${b.caption ? captionHtml(b.caption, "caption", x) : ""}${head}${body}</table></div>`;
+    }
+    case "figure": {
+      const src = imageSrc(b.url, x);
+      const id = b.caption?.id ? ` id="fig:${(0, import_html_escape.escapeHtml)(b.caption.id)}"` : "";
+      const img = src ? `<img src="${(0, import_html_escape.escapeHtml)(src)}" alt="${(0, import_html_escape.escapeHtml)(b.alt)}"${x.xhtml ? "/" : ""}>` : `<div class="doc-image-missing">Image unavailable: ${(0, import_html_escape.escapeHtml)(b.alt || b.url)}</div>`;
+      return `<figure class="doc-figure"${id}>${img}${b.caption ? captionHtml(b.caption, "figcaption", x) : ""}</figure>`;
+    }
+    case "rule":
+      return `<hr${x.xhtml ? "/" : ""}>`;
+    case "pageBreak":
+      return `<div class="${PAGE_BREAK_CLASS}" role="separator" aria-label="Page break"></div>`;
+    case "toc":
+      return tocHtml(x);
+    case "notes":
+      return `<ol class="doc-notes">${x.tree.notes.map(
+        (n) => `<li id="note-${n.n}">${renderBlocksHtml(n.children, x)} <a class="doc-note-back" href="${(0, import_html_escape.escapeHtml)(
+          href(`noteref-${n.n}`, x)
+        )}" aria-label="Back to text">\u21A9</a></li>`
+      ).join("")}</ol>`;
+    case "bibliography":
+      return `<div class="doc-bibliography" role="doc-bibliography">${x.tree.bibliography.map((e) => `<p class="doc-ref" id="ref-${(0, import_html_escape.escapeHtml)(e.id)}">${renderInlineHtml(e.children, x)}</p>`).join("")}</div>`;
+  }
+}
+function coverHtml(s, x) {
+  const logo = s.logo ? imageSrc(s.logo, x) : null;
+  return `<section class="doc-cover">${logo ? `<img class="doc-cover-logo" src="${(0, import_html_escape.escapeHtml)(logo)}" alt=""${x.xhtml ? "/" : ""}>` : ""}<h1 class="doc-cover-title">${(0, import_html_escape.escapeHtml)(
+    s.title ?? ""
+  )}</h1>${s.subtitle ? `<p class="doc-cover-subtitle">${(0, import_html_escape.escapeHtml)(s.subtitle)}</p>` : ""}${s.author ? `<p class="doc-cover-author">${(0, import_html_escape.escapeHtml)(s.author)}</p>` : ""}${s.date ? `<p class="doc-cover-date">${(0, import_html_escape.escapeHtml)(s.date)}</p>` : ""}</section>`;
+}
+var cssString = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, " ")}"`;
+function marginContent(template, s) {
+  if (!template) return "none";
+  return templateParts(template, s).map((p) => "field" in p ? `counter(${p.field})` : cssString(p.text)).join(" ");
+}
+function runningBoxes(t2, where, s) {
+  if (!t2) return "";
+  const box = (slot) => t2[slot] ? `@${where}-${slot}{content:${marginContent(t2[slot], s)};font:9pt/1.2 var(--doc-font);color:var(--matrx-print-muted,#6b7280);}` : "";
+  return box("left") + box("center") + box("right");
+}
+var pt = (n) => `${Math.round(n * 100) / 100}pt`;
+function documentCss(s) {
+  const { width, height, margins: m } = s.page;
+  const portrait = `${pt(width)} ${pt(height)}`;
+  const landscape = `${pt(height)} ${pt(width)}`;
+  const base = s.page.orientation === "landscape" ? landscape : portrait;
+  const blankBoxes = ["top", "bottom"].flatMap((w) => ["left", "center", "right"].map((sl) => `@${w}-${sl}{content:none;}`)).join("");
+  return `
+:root{color-scheme:light;--doc-font:"Charter","Georgia","Cambria","Times New Roman",serif;--doc-sans:"Inter","Helvetica Neue","Arial",sans-serif;--doc-mono:"SFMono-Regular","Menlo","Consolas","Liberation Mono",monospace;}
+@page{size:${base};margin:${pt(m.top)} ${pt(m.right)} ${pt(m.bottom)} ${pt(m.left)};${runningBoxes(s.header, "top", s)}${runningBoxes(s.footer, "bottom", s)}}
+@page doc-portrait{size:${portrait};}
+@page doc-landscape{size:${landscape};}
+${s.differentFirstPage ? `@page:first{${blankBoxes}}` : ""}
+@page doc-cover{${blankBoxes}}
+html{background:var(--matrx-print-page,#ffffff);}
+body{margin:0;background:var(--matrx-print-page,#ffffff);color:var(--matrx-print-text,#1f2937);font:${pt(s.fontSize)}/1.5 var(--doc-font);-webkit-print-color-adjust:exact;print-color-adjust:exact;}
+.doc{max-width:${pt(width - m.left - m.right)};margin:0 auto;padding:48px 24px;}
+@media print{.doc{max-width:none;padding:0;}}
+.doc-section.doc-landscape{page:doc-landscape;}
+.doc-section.doc-portrait{page:doc-portrait;}
+@media screen{.doc-section.doc-landscape{max-width:none;}}
+.doc-section+.doc-section{break-before:page;}
+@media screen{.doc-section+.doc-section{border-top:1px dashed var(--matrx-print-rule,#d1d5db);margin-top:32px;padding-top:32px;}}
+.doc-cols-2{column-count:2;column-gap:0.3in;}
+.doc-cols-3{column-count:3;column-gap:0.25in;}
+.doc-cover{page:doc-cover;break-after:page;min-height:${pt(height - m.top - m.bottom)};display:flex;flex-direction:column;justify-content:center;align-items:flex-start;gap:10pt;}
+@media screen{.doc-cover{min-height:60vh;border-bottom:1px dashed var(--matrx-print-rule,#d1d5db);margin-bottom:32px;}}
+.doc-cover-logo{max-height:72pt;max-width:40%;margin-bottom:24pt;}
+.doc-cover-title{font:700 30pt/1.15 var(--doc-sans);margin:0;letter-spacing:-0.01em;}
+.doc-cover-subtitle{font:400 16pt/1.3 var(--doc-sans);color:var(--matrx-print-muted,#4b5563);margin:0;}
+.doc-cover-author,.doc-cover-date{font:12pt/1.4 var(--doc-sans);color:var(--matrx-print-muted,#4b5563);margin:0;}
+.doc-cover-author{margin-top:36pt;}
+p,li,dd{orphans:3;widows:3;}
+p{margin:0 0 0.7em;${s.hyphenate ? "hyphens:auto;-webkit-hyphens:auto;" : ""}}
+h1,h2,h3,h4,h5,h6{font-family:var(--doc-sans);color:var(--matrx-print-heading,#111827);line-height:1.25;break-after:avoid;page-break-after:avoid;break-inside:avoid;hyphens:manual;}
+h1{font-size:${pt(s.fontSize * 1.8)};margin:1.2em 0 0.5em;}
+h2{font-size:${pt(s.fontSize * 1.45)};margin:1.1em 0 0.45em;}
+h3{font-size:${pt(s.fontSize * 1.2)};margin:1em 0 0.4em;}
+h4,h5,h6{font-size:${pt(s.fontSize * 1.05)};margin:0.9em 0 0.35em;}
+.doc-heading-number{color:var(--matrx-print-muted,#6b7280);margin-right:0.35em;}
+a{color:var(--matrx-print-link,#1d4ed8);text-decoration:none;}
+code{font:0.88em var(--doc-mono);background:var(--matrx-print-code-bg,#f3f4f6);padding:0.05em 0.3em;border-radius:3px;}
+pre.doc-code{font:0.82em/1.45 var(--doc-mono);background:var(--matrx-print-code-bg,#f6f8fa);border:1px solid var(--matrx-print-rule,#e5e7eb);border-radius:4px;padding:8pt 10pt;white-space:pre-wrap;overflow-wrap:anywhere;break-inside:avoid;page-break-inside:avoid;}
+pre.doc-code code{background:none;padding:0;font:inherit;}
+blockquote{margin:0 0 0.8em;padding:0.1em 0 0.1em 1em;border-left:3px solid var(--matrx-print-rule,#d1d5db);color:var(--matrx-print-muted,#4b5563);break-inside:avoid;}
+hr{border:0;border-top:1px solid var(--matrx-print-rule,#d1d5db);margin:1.2em 0;}
+.doc-table-wrap{margin:0 0 1em;break-inside:avoid;page-break-inside:avoid;}
+table{border-collapse:collapse;width:100%;font-size:0.92em;}
+thead{display:table-header-group;}
+tr{break-inside:avoid;page-break-inside:avoid;}
+th,td{border-bottom:1px solid var(--matrx-print-rule,#e5e7eb);padding:4pt 6pt;text-align:left;vertical-align:top;}
+th{font-family:var(--doc-sans);font-weight:600;border-bottom:1.5px solid var(--matrx-print-heading,#111827);}
+table caption{caption-side:top;text-align:left;margin-bottom:4pt;}
+.doc-caption{font:0.9em/1.4 var(--doc-sans);color:var(--matrx-print-muted,#4b5563);break-after:avoid;}
+.doc-caption-label{font-weight:600;color:var(--matrx-print-heading,#111827);}
+.doc-figure{margin:0 0 1em;text-align:center;break-inside:avoid;page-break-inside:avoid;}
+.doc-figure img{max-width:100%;max-height:${pt((height - m.top - m.bottom) * 0.7)};}
+.doc-figure figcaption{margin-top:4pt;}
+.doc-image-missing{border:1px dashed var(--matrx-print-rule,#d1d5db);padding:16pt;color:var(--matrx-print-muted,#6b7280);}
+.doc-inline-img{max-height:1.2em;vertical-align:middle;}
+.doc-task-list{list-style:none;padding-left:0.2em;}
+.doc-task-box{display:inline-block;width:0.8em;height:0.8em;border:1.2px solid var(--matrx-print-heading,#374151);border-radius:2px;margin-right:0.45em;vertical-align:-0.05em;}
+.doc-task-box.is-checked{background:var(--matrx-print-heading,#374151);}
+.doc-xref-missing,.doc-cite-missing{color:var(--matrx-print-danger,#b91c1c);font-weight:600;}
+.doc-toc{break-after:auto;}
+.doc-toc-title{font-size:${pt(s.fontSize * 1.45)};}
+.doc-toc ol{list-style:none;padding:0;margin:0;}
+.doc-toc li{margin:0.2em 0;}
+.doc-toc a{display:flex;gap:0.5em;color:inherit;}
+.doc-toc .toc-text{flex:1;}
+.doc-toc a::after{content:target-counter(attr(href url),page);}
+${[2, 3, 4, 5, 6].map((l) => `.doc-toc .toc-l${l}{padding-left:${(l - 1) * 1.2}em;}`).join("")}
+.doc-toc .toc-l1{font-weight:600;}
+.doc-bibliography .doc-ref{padding-left:2em;text-indent:-2em;}
+.doc-notes{font-size:0.9em;}
+.doc-note-back{margin-left:0.3em;}
+.${PAGE_BREAK_CLASS}{break-after:page;page-break-after:always;height:0;}
+@media screen{.${PAGE_BREAK_CLASS}{height:auto;border-top:1px dashed var(--matrx-print-rule,#d1d5db);margin:24px 0;}}
+`.trim();
+}
+function documentToHtml(tree, options = {}) {
+  const s = tree.settings;
+  const x = { tree, images: options.images };
+  const sections = tree.sections.map((sec) => {
+    const cls = [
+      "doc-section",
+      sec.orientation === s.page.orientation ? "" : `doc-${sec.orientation}`,
+      sec.columns > 1 ? `doc-cols-${sec.columns}` : ""
+    ].filter(Boolean).join(" ");
+    return `<section class="${cls}">${renderBlocksHtml(sec.blocks, x)}</section>`;
+  }).join("\n");
+  const size = PAGE_SIZES[s.page.size].label;
+  return `<!DOCTYPE html>
+<html lang="${(0, import_html_escape.escapeHtml)(s.lang)}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light">
+<meta name="generator" content="@ai-matrx/print/document (${size}, ${s.page.orientation})">
+<title>${(0, import_html_escape.escapeHtml)(s.title ?? "Document")}</title>
+${s.author ? `<meta name="author" content="${(0, import_html_escape.escapeHtml)(s.author)}">` : ""}
+<style>${documentCss(s)}</style>
+</head>
+<body>
+<main class="doc">
+${s.cover ? coverHtml(s, x) : ""}
+${sections}
+</main>
+</body>
+</html>`;
+}
+
+// src/document/epub.ts
+var EPUB_CSS = `
+body{font-family:Georgia,"Times New Roman",serif;line-height:1.5;color:#1f2937;margin:0 5%;}
+h1,h2,h3,h4,h5,h6{font-family:"Helvetica Neue",Arial,sans-serif;line-height:1.25;page-break-after:avoid;break-after:avoid;color:#111827;}
+p{margin:0 0 0.7em;orphans:2;widows:2;hyphens:auto;-epub-hyphens:auto;}
+pre.doc-code{font-family:Menlo,Consolas,monospace;font-size:0.8em;white-space:pre-wrap;background:#f6f8fa;padding:0.6em;border:1px solid #e5e7eb;page-break-inside:avoid;}
+code{font-family:Menlo,Consolas,monospace;font-size:0.9em;}
+table{border-collapse:collapse;width:100%;font-size:0.9em;}
+th,td{border-bottom:1px solid #e5e7eb;padding:0.25em 0.4em;text-align:left;vertical-align:top;}
+th{border-bottom:1.5px solid #111827;}
+caption,figcaption,.doc-caption{font-size:0.9em;color:#4b5563;text-align:left;}
+.doc-caption-label{font-weight:bold;color:#111827;}
+figure{margin:1em 0;text-align:center;page-break-inside:avoid;}
+figure img{max-width:100%;}
+blockquote{margin:0 0 0.8em;padding-left:1em;border-left:3px solid #d1d5db;color:#4b5563;}
+.doc-task-list{list-style:none;padding-left:0.2em;}
+.doc-task-box{display:inline-block;width:0.8em;height:0.8em;border:1px solid #374151;margin-right:0.4em;}
+.doc-task-box.is-checked{background:#374151;}
+.doc-toc ol{list-style:none;padding-left:0;}
+.doc-bibliography .doc-ref{padding-left:2em;text-indent:-2em;}
+.doc-cover{text-align:center;margin-top:30%;}
+.doc-cover-logo{max-height:5em;}
+.doc-cover-title{font-size:2em;}
+.matrx-page-break{page-break-after:always;break-after:page;}
+`.trim();
+function extOf(mime) {
+  return mime === "image/png" ? "png" : mime === "image/gif" ? "gif" : "jpg";
+}
+function xhtml(title, lang, body) {
+  return `<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" lang="${(0, import_html_escape2.escapeHtml)(lang)}" xml:lang="${(0, import_html_escape2.escapeHtml)(lang)}">
+<head><meta charset="utf-8"/><title>${(0, import_html_escape2.escapeHtml)(title)}</title><link rel="stylesheet" type="text/css" href="style.css"/></head>
+<body>
+${body}
+</body>
+</html>`;
+}
+function uuid() {
+  const g = globalThis;
+  if (g.crypto?.randomUUID) return g.crypto.randomUUID();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (ch) => {
+    const r = Math.random() * 16 | 0;
+    return (ch === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+async function documentToEpub(tree, options = {}) {
+  const JSZipMod = await import("jszip");
+  const JSZip = JSZipMod.default ?? JSZipMod;
+  const s = tree.settings;
+  const lang = s.lang || "en";
+  const levels = [];
+  for (const sec of tree.sections) for (const b of sec.blocks) if (b.type === "heading") levels.push(b.level);
+  const top = Math.min(7, ...levels);
+  const chapters = [];
+  let current = null;
+  for (const sec of tree.sections) {
+    for (const b of sec.blocks) {
+      if (b.type === "pageBreak") continue;
+      if (b.type === "heading" && b.level === top && current && current.blocks.length) current = null;
+      if (!current) {
+        current = { file: `chapter-${chapters.length + 1}.xhtml`, title: b.type === "heading" ? b.plain : s.title ?? "Start", blocks: [] };
+        chapters.push(current);
+      }
+      current.blocks.push(b);
+    }
+  }
+  if (chapters.length === 0) chapters.push({ file: "chapter-1.xhtml", title: s.title ?? "Document", blocks: [] });
+  const home = /* @__PURE__ */ new Map();
+  const walk = (file, list) => {
+    for (const b of list) {
+      if (b.type === "heading") home.set(b.id, file);
+      if (b.type === "figure" && b.caption?.id) home.set(`fig:${b.caption.id}`, file);
+      if (b.type === "table" && b.caption?.id) home.set(`tbl:${b.caption.id}`, file);
+      if (b.type === "bibliography") for (const e of tree.bibliography) home.set(`ref-${e.id}`, file);
+      if (b.type === "notes") for (const n2 of tree.notes) home.set(`note-${n2.n}`, file);
+      if (b.type === "list") for (const it of b.items) walk(file, it.children);
+      if (b.type === "blockquote") walk(file, b.children);
+    }
+  };
+  for (const ch of chapters) walk(ch.file, ch.blocks);
+  const imagePaths = /* @__PURE__ */ new Map();
+  let imgN = 0;
+  for (const [url, img] of options.images ?? /* @__PURE__ */ new Map()) {
+    if (!img) continue;
+    imgN++;
+    imagePaths.set(url, { path: `images/img-${imgN}.${extOf(img.mime)}`, mime: img.mime, bytes: img.bytes });
+  }
+  const zip = new JSZip();
+  zip.file("mimetype", "application/epub+zip", { compression: "STORE" });
+  zip.file(
+    "META-INF/container.xml",
+    `<?xml version="1.0" encoding="UTF-8"?>
+<container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
+<rootfiles><rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/></rootfiles>
+</container>`
+  );
+  zip.file("OEBPS/style.css", EPUB_CSS);
+  for (const img of imagePaths.values()) zip.file(`OEBPS/${img.path}`, img.bytes);
+  const makeCtx = (file) => ({
+    tree,
+    xhtml: true,
+    hrefFor: (id2) => {
+      const target = home.get(id2) ?? file;
+      return target === file ? `#${id2}` : `${target}#${id2}`;
+    },
+    srcFor: (url) => imagePaths.get(url)?.path ?? url
+  });
+  const spine = [];
+  const manifest = [
+    `<item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav"/>`,
+    `<item id="css" href="style.css" media-type="text/css"/>`
+  ];
+  if (s.cover) {
+    zip.file("OEBPS/cover.xhtml", xhtml(s.title ?? "Cover", lang, coverHtml(s, makeCtx("cover.xhtml"))));
+    manifest.push(`<item id="cover" href="cover.xhtml" media-type="application/xhtml+xml"/>`);
+    spine.push(`<itemref idref="cover"/>`);
+  }
+  chapters.forEach((ch, i) => {
+    zip.file(`OEBPS/${ch.file}`, xhtml(ch.title, lang, renderBlocksHtml(ch.blocks, makeCtx(ch.file))));
+    manifest.push(`<item id="ch${i + 1}" href="${ch.file}" media-type="application/xhtml+xml"/>`);
+    spine.push(`<itemref idref="ch${i + 1}"/>`);
+  });
+  let n = 0;
+  for (const img of imagePaths.values()) {
+    n++;
+    manifest.push(
+      `<item id="img${n}" href="${img.path}" media-type="${img.mime}"${s.logo && imagePaths.get(s.logo)?.path === img.path ? ' properties="cover-image"' : ""}/>`
+    );
+  }
+  const entries = tree.toc.length ? tree.toc : chapters.map((ch) => ({ id: "", level: 1, text: ch.title, file: ch.file }));
+  const navItems = entries.map((e) => {
+    const file = "file" in e ? e.file : home.get(e.id) ?? chapters[0].file;
+    const hrefAttr = e.id ? `${file}#${e.id}` : file;
+    return `<li class="toc-l${e.level}"><a href="${(0, import_html_escape2.escapeHtml)(hrefAttr)}">${(0, import_html_escape2.escapeHtml)(e.text)}</a></li>`;
+  }).join("\n");
+  zip.file(
+    "OEBPS/nav.xhtml",
+    xhtml(
+      s.toc.title,
+      lang,
+      `<nav epub:type="toc" id="toc"><h1>${(0, import_html_escape2.escapeHtml)(s.toc.title)}</h1><ol>
+${navItems}
+</ol></nav>`
+    )
+  );
+  const modified = (options.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const id = options.identifier ?? `urn:uuid:${uuid()}`;
+  zip.file(
+    "OEBPS/content.opf",
+    `<?xml version="1.0" encoding="UTF-8"?>
+<package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="bookid" xml:lang="${(0, import_html_escape2.escapeHtml)(lang)}">
+<metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
+<dc:identifier id="bookid">${(0, import_html_escape2.escapeHtml)(id)}</dc:identifier>
+<dc:title>${(0, import_html_escape2.escapeHtml)(s.title ?? "Document")}</dc:title>
+<dc:language>${(0, import_html_escape2.escapeHtml)(lang)}</dc:language>
+${s.author ? `<dc:creator>${(0, import_html_escape2.escapeHtml)(s.author)}</dc:creator>` : ""}
+${s.date ? `<dc:date>${(0, import_html_escape2.escapeHtml)(s.date)}</dc:date>` : ""}
+<meta property="dcterms:modified">${modified}</meta>
+</metadata>
+<manifest>
+${manifest.join("\n")}
+</manifest>
+<spine>
+${spine.join("\n")}
+</spine>
+</package>`
+  );
+  return zip.generateAsync({ type: "uint8array", compression: "DEFLATE", mimeType: "application/epub+zip" });
+}
+
+// src/document/pdf.ts
+var COLOR = {
+  text: "#1f2937",
+  heading: "#111827",
+  muted: "#6b7280",
+  link: "#1d4ed8",
+  rule: "#d1d5db",
+  codeBg: "#f6f8fa",
+  danger: "#b91c1c"
+};
+var WIN_ANSI_EXTRA = new Set(
+  "\u20AC\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\u017D\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\u017E\u0178"
+);
+var courierCanDraw = (s) => {
+  for (const ch of s) {
+    const c = ch.codePointAt(0);
+    if (c >= 32 && c <= 126 || c >= 160 && c <= 255 || c === 9 || WIN_ANSI_EXTRA.has(ch)) continue;
+    return false;
+  }
+  return true;
+};
+var NO_GLYPH = /[\p{Extended_Pictographic}\u{1F1E6}-\u{1F1FF}\u200D\uFE0F\u20E3]/gu;
+function drawable(text, c) {
+  if (!NO_GLYPH.test(text)) return text;
+  NO_GLYPH.lastIndex = 0;
+  if (!c.glyphs.announced) {
+    c.glyphs.announced = true;
+    c.tree.notices.push({
+      code: "glyph-substituted",
+      message: "Emoji and pictographs were left out of the PDF: its fonts cannot draw them (Word, EPUB and HTML keep them).",
+      remedy: "Use words or plain symbols instead of emoji if they must appear in the PDF."
+    });
+  }
+  return text.replace(NO_GLYPH, "").replace(/ {2,}/g, " ");
+}
+function runs2(nodes, c, st = {}) {
+  const out = [];
+  const base = (raw) => {
+    const text = drawable(raw, c);
+    const r = { text };
+    if (st.bold) r.bold = true;
+    if (st.italics) r.italics = true;
+    if (st.strike) r.decoration = "lineThrough";
+    if (st.link) {
+      r.link = st.link;
+      r.color = COLOR.link;
+    }
+    if (st.dest) {
+      r.linkToDestination = st.dest;
+      r.color = COLOR.link;
+    }
+    return r;
+  };
+  for (const n of nodes) {
+    switch (n.type) {
+      case "text":
+        out.push(base(n.value));
+        break;
+      case "strong":
+        out.push(...runs2(n.children, c, { ...st, bold: true }));
+        break;
+      case "emphasis":
+        out.push(...runs2(n.children, c, { ...st, italics: true }));
+        break;
+      case "delete":
+        out.push(...runs2(n.children, c, { ...st, strike: true }));
+        break;
+      case "code": {
+        const r = base(n.value);
+        if (courierCanDraw(n.value)) r.font = "Courier";
+        r.fontSize = c.s.fontSize * 0.92;
+        r.background = "#f3f4f6";
+        out.push(r);
+        break;
+      }
+      case "break":
+        out.push(base("\n"));
+        break;
+      case "link":
+        out.push(...runs2(n.children, c, /^(https?:|mailto:|tel:)/i.test(n.url) ? { ...st, link: n.url } : st));
+        break;
+      case "image":
+        out.push(base(n.alt));
+        break;
+      case "xref": {
+        if (!n.resolved) {
+          out.push({ ...base(n.label), bold: true, color: COLOR.danger });
+          break;
+        }
+        const id = n.target.startsWith("sec:") ? n.target.slice(4) : n.target;
+        out.push({ ...base(n.label), linkToDestination: id, color: COLOR.link });
+        break;
+      }
+      case "cite": {
+        const r = base(n.label);
+        if (n.resolved) {
+          r.linkToDestination = `ref-${n.keys[0]}`;
+        } else {
+          r.bold = true;
+          r.color = COLOR.danger;
+        }
+        out.push(r);
+        break;
+      }
+      case "noteRef":
+        out.push({ text: String(n.n), sup: true, linkToDestination: `note-${n.n}`, color: COLOR.link });
+        break;
+    }
+  }
+  return out;
+}
+var capNode = (cap, c, where) => ({
+  text: [{ text: cap.label, bold: true, color: COLOR.heading }, ...cap.children.length ? [": ", ...runs2(cap.children, c)] : []],
+  style: "caption",
+  id: cap.id ? `${cap.kind}:${cap.id}` : void 0,
+  // A caption above its table is never the last line on a page.
+  ...where === "above" ? { headlineLevel: 9 } : {},
+  margin: where === "above" ? [0, 0, 0, 4] : [0, 4, 0, 0]
+});
+function estimateLines(text, c) {
+  const charsPerLine = Math.max(20, c.width / (c.s.fontSize * 0.5));
+  return Math.ceil(Math.max(1, text.length) / charsPerLine);
+}
+var plain = (nodes) => nodes.map((n) => "value" in n ? n.value : "label" in n ? n.label : "children" in n ? plain(n.children) : "").join("");
+function taskItem(checked, content, c) {
+  const size = c.s.fontSize * 0.75;
+  return {
+    columns: [
+      {
+        width: size + 6,
+        canvas: [
+          { type: "rect", x: 0, y: c.s.fontSize * 0.3, w: size, h: size, r: 1.5, lineWidth: 1, lineColor: COLOR.heading, ...checked ? { color: COLOR.heading } : {} }
+        ]
+      },
+      { width: "*", stack: content }
+    ],
+    columnGap: 2
+  };
+}
+function gluable(b, c) {
+  if (!b) return false;
+  if (b.type === "paragraph") return estimateLines(plain(b.children), c) <= 5;
+  if (b.type === "figure" || b.type === "rule") return true;
+  if (b.type === "list")
+    return b.items.length <= 4 && b.items.every((i) => i.children.length === 1 && i.children[0]?.type === "paragraph");
+  return false;
+}
+function blocks2(list, c) {
+  const out = [];
+  let breakNext = false;
+  for (let i = 0; i < list.length; i++) {
+    const b = list[i];
+    let node = block2(b, c);
+    if (node && b.type === "heading" && gluable(list[i + 1], c)) {
+      const next = block2(list[i + 1], c);
+      if (next) {
+        node = { stack: [node, next], unbreakable: true };
+        i++;
+      }
+    }
+    if (node === null) {
+      if (b.type === "pageBreak") breakNext = true;
+      continue;
+    }
+    if (breakNext && typeof node === "object") {
+      node.pageBreak = "before";
+      breakNext = false;
+    }
+    out.push(node);
+  }
+  return out;
+}
+function block2(b, c) {
+  switch (b.type) {
+    case "heading": {
+      const rel = Math.min(6, b.level - c.minLevel + 1);
+      const node = {
+        text: [...b.number ? [{ text: `${b.number}  `, color: COLOR.muted }] : [], ...runs2(b.children, c)],
+        style: `h${Math.min(6, b.level)}`,
+        headlineLevel: b.level,
+        id: b.id
+      };
+      if (c.tocIds.has(b.id)) {
+        node.tocItem = true;
+        node.tocMargin = [(rel - 1) * 14, rel === 1 ? 4 : 1, 0, 0];
+        node.tocStyle = rel === 1 ? "tocL1" : "toc";
+      }
+      return node;
+    }
+    case "paragraph": {
+      const text = runs2(b.children, c);
+      const p = { text, style: "p" };
+      return estimateLines(plain(b.children), c) <= 5 ? { stack: [p], unbreakable: true } : p;
+    }
+    case "list": {
+      const items = b.items.map((it) => {
+        const content = it.children.length === 1 && it.children[0]?.type === "paragraph" ? [{ text: runs2(it.children[0].children, c), margin: [0, 0, 0, 2] }] : blocks2(it.children, { ...c, width: c.width - 18 });
+        if (it.checked !== null) return { ...taskItem(it.checked, content, c), listType: "none" };
+        return content.length === 1 ? content[0] : { stack: content };
+      });
+      const node = b.ordered ? { ol: items, start: b.start } : { ul: items };
+      node.margin = [0, 0, 0, 6];
+      node.markerColor = COLOR.muted;
+      return node;
+    }
+    case "blockquote":
+      return {
+        table: { widths: ["*"], body: [[{ stack: blocks2(b.children, { ...c, width: c.width - 16 }), color: COLOR.muted }]] },
+        layout: {
+          hLineWidth: () => 0,
+          vLineWidth: (i) => i === 0 ? 3 : 0,
+          vLineColor: () => COLOR.rule,
+          paddingLeft: () => 10,
+          paddingRight: () => 0,
+          paddingTop: () => 2,
+          paddingBottom: () => 2
+        },
+        margin: [0, 0, 0, 8]
+      };
+    case "code": {
+      const lines = b.value.replace(/\n$/, "").split("\n");
+      const size = c.s.fontSize * 0.8;
+      const stack = lines.map((l) => {
+        const t2 = drawable(l.replace(/\t/g, "    "), c) || " ";
+        return courierCanDraw(t2) ? { text: t2, font: "Courier", fontSize: size, preserveLeadingSpaces: true } : { text: t2, fontSize: size, preserveLeadingSpaces: true };
+      });
+      return {
+        table: { widths: ["*"], body: [[{ stack, fillColor: COLOR.codeBg }]] },
+        layout: {
+          hLineWidth: () => 0.5,
+          vLineWidth: () => 0.5,
+          hLineColor: () => "#e5e7eb",
+          vLineColor: () => "#e5e7eb",
+          paddingLeft: () => 8,
+          paddingRight: () => 8,
+          paddingTop: () => 6,
+          paddingBottom: () => 6
+        },
+        margin: [0, 0, 0, 8],
+        // Keep a block that fits on one page together (30 lines fits even a
+        // landscape page; a taller unbreakable block would be dropped).
+        unbreakable: lines.length <= 30
+      };
+    }
+    case "table": {
+      const n = Math.max(b.header.length, ...b.rows.map((r) => r.length), 1);
+      const cell = (inl, i, head) => ({
+        text: runs2(inl ?? [], c),
+        bold: head,
+        alignment: b.align[i] ?? "left",
+        fontSize: c.s.fontSize * 0.92,
+        color: head ? COLOR.heading : COLOR.text
+      });
+      const row = (r, head) => Array.from({ length: n }, (_, i) => cell(r[i], i, head));
+      const table = {
+        table: {
+          headerRows: 1,
+          dontBreakRows: true,
+          keepWithHeaderRows: 1,
+          widths: Array.from({ length: n }, () => "*"),
+          body: [row(b.header, true), ...b.rows.map((r) => row(r, false))]
+        },
+        layout: {
+          hLineWidth: (i) => i === 1 ? 1.2 : i === 0 ? 0 : 0.5,
+          vLineWidth: () => 0,
+          hLineColor: (i) => i === 1 ? COLOR.heading : "#e5e7eb",
+          paddingLeft: () => 5,
+          paddingRight: () => 5,
+          paddingTop: () => 3,
+          paddingBottom: () => 3
+        }
+      };
+      const stack = [];
+      if (b.caption) stack.push(capNode(b.caption, c, "above"));
+      stack.push(table);
+      return { stack, margin: [0, 2, 0, 10] };
+    }
+    case "figure": {
+      const img = c.images?.get(b.url);
+      const maxH = (c.s.page.height - c.s.page.margins.top - c.s.page.margins.bottom) * 0.6;
+      const stack = [];
+      if (img) {
+        const scale = Math.min(1, c.width / img.width, maxH / img.height);
+        stack.push({ image: img.dataUrl, width: img.width * scale, height: img.height * scale, alignment: "center" });
+      } else {
+        stack.push({ text: `[Image unavailable: ${b.alt || b.url}]`, italics: true, color: COLOR.muted, alignment: "center" });
+      }
+      if (b.caption) stack.push({ ...capNode(b.caption, c, "below"), alignment: "center" });
+      return { stack, margin: [0, 4, 0, 10], unbreakable: true };
+    }
+    case "rule":
+      return {
+        canvas: [{ type: "line", x1: 0, y1: 0, x2: c.width, y2: 0, lineWidth: 0.75, lineColor: COLOR.rule }],
+        margin: [0, 6, 0, 10]
+      };
+    case "pageBreak":
+      return null;
+    case "toc":
+      return {
+        toc: {
+          title: { text: c.s.toc.title, style: "tocTitle" },
+          numberStyle: { color: COLOR.muted }
+        },
+        margin: [0, 0, 0, 12]
+      };
+    case "notes":
+      return {
+        stack: c.tree.notes.map((n) => ({
+          columns: [
+            { width: 18, text: `${n.n}.`, color: COLOR.muted, id: `note-${n.n}` },
+            { width: "*", stack: blocks2(n.children, { ...c, width: c.width - 18 }) }
+          ],
+          fontSize: c.s.fontSize * 0.9
+        }))
+      };
+    case "bibliography":
+      return {
+        stack: c.tree.bibliography.map((e) => ({
+          text: runs2(e.children, c),
+          id: `ref-${e.id}`,
+          margin: [0, 0, 0, 6],
+          leadingIndent: 0
+        }))
+      };
+  }
+}
+function running(t2, s, page, pages, margins) {
+  if (!t2) return null;
+  const slot = (v, alignment) => ({ text: v ? fillTemplate(v, s, page, pages) : "", alignment, width: "*" });
+  return {
+    columns: [slot(t2.left, "left"), slot(t2.center, "center"), slot(t2.right, "right")],
+    fontSize: 9,
+    color: COLOR.muted,
+    margin: [margins[0], 0, margins[1], 0]
+  };
+}
+function sectionContent(sec, c) {
+  const landscape = sec.orientation === "landscape";
+  const pageW = landscape ? c.s.page.height : c.s.page.width;
+  const full = pageW - c.s.page.margins.left - c.s.page.margins.right;
+  const gap = 18;
+  const colW = (full - gap * (sec.columns - 1)) / sec.columns;
+  const inner = blocks2(sec.blocks, { ...c, width: colW });
+  if (sec.columns === 1) return inner;
+  return [
+    {
+      columns: [
+        { width: colW, stack: inner },
+        ...Array.from({ length: sec.columns - 1 }, () => ({ width: colW, stack: [] }))
+      ],
+      columnGap: gap,
+      snakingColumns: true
+    }
+  ];
+}
+function buildPdfDefinition(tree, images, pageCountSink) {
+  const s = tree.settings;
+  const m = s.page.margins;
+  const headings = [];
+  for (const sec of tree.sections) for (const b of sec.blocks) if (b.type === "heading") headings.push(b.level);
+  const c = {
+    glyphs: { announced: false },
+    tree,
+    images,
+    s,
+    width: s.page.width - m.left - m.right,
+    tocIds: new Set(tree.toc.map((e) => e.id)),
+    minLevel: Math.min(7, ...headings)
+  };
+  const content = [];
+  if (s.cover) {
+    const logo = s.logo ? images?.get(s.logo) : void 0;
+    const pageH = (s.page.orientation === "landscape" ? s.page.width : s.page.height) - m.top - m.bottom;
+    const cover = [];
+    if (logo) {
+      const scale = Math.min(1, 160 / logo.width, 72 / logo.height);
+      cover.push({ image: logo.dataUrl, width: logo.width * scale, height: logo.height * scale, margin: [0, 0, 0, 24] });
+    }
+    cover.push({ text: s.title ?? "", style: "coverTitle" });
+    if (s.subtitle) cover.push({ text: s.subtitle, style: "coverSubtitle" });
+    if (s.author) cover.push({ text: s.author, style: "coverMeta", margin: [0, 36, 0, 0] });
+    if (s.date) cover.push({ text: s.date, style: "coverMeta" });
+    content.push({ stack: cover, margin: [0, pageH * 0.28, 0, 0] });
+  }
+  tree.sections.forEach((sec, idx) => {
+    const nodes = sectionContent(sec, c);
+    const first = nodes[0];
+    if (first && typeof first === "object" && (idx > 0 || s.cover)) {
+      first.pageBreak = "before";
+      first.pageOrientation = sec.orientation;
+    }
+    content.push(...nodes);
+  });
+  const hs = s.fontSize;
+  let pageCount = 0;
+  const hidden = (page) => s.differentFirstPage && page === 1;
+  return {
+    info: { title: s.title ?? "Document", author: s.author, subject: s.subtitle, creator: "AI Matrx", producer: "@ai-matrx/print" },
+    pageSize: { width: s.page.width, height: s.page.height },
+    pageOrientation: s.page.orientation,
+    pageMargins: [m.left, m.top, m.right, m.bottom],
+    language: s.lang,
+    header: (page, pages) => {
+      pageCount = pages;
+      pageCountSink?.(pageCount);
+      if (hidden(page)) return null;
+      const r = running(s.header, s, page, pages, [m.left, m.right]);
+      return r ? { stack: [r], margin: [0, Math.max(14, m.top / 2 - 6), 0, 0] } : null;
+    },
+    footer: (page, pages) => {
+      if (hidden(page)) return null;
+      const r = running(s.footer, s, page, pages, [m.left, m.right]);
+      return r ? { stack: [r], margin: [0, Math.max(10, m.bottom / 2 - 6), 0, 0] } : null;
+    },
+    // Keep-with-next: a heading never ends a page.
+    // (A container stack reports every page its children touch, so only real
+    // content nodes that START on the heading's page count as "following".)
+    pageBreakBefore: (node, q) => {
+      if (!node.headlineLevel) return false;
+      const page = node.startPosition?.pageNumber;
+      return !q.getFollowingNodesOnPage().some((n) => !n.stack && n.startPosition?.pageNumber === page);
+    },
+    content,
+    defaultStyle: { font: "Roboto", fontSize: hs, lineHeight: 1.3, color: COLOR.text },
+    styles: {
+      p: { margin: [0, 0, 0, 7] },
+      h1: { fontSize: hs * 1.8, bold: true, color: COLOR.heading, margin: [0, 14, 0, 6] },
+      h2: { fontSize: hs * 1.45, bold: true, color: COLOR.heading, margin: [0, 12, 0, 5] },
+      h3: { fontSize: hs * 1.2, bold: true, color: COLOR.heading, margin: [0, 10, 0, 4] },
+      h4: { fontSize: hs * 1.05, bold: true, color: COLOR.heading, margin: [0, 8, 0, 3] },
+      h5: { fontSize: hs, bold: true, color: COLOR.heading, margin: [0, 8, 0, 3] },
+      h6: { fontSize: hs, bold: true, italics: true, color: COLOR.heading, margin: [0, 8, 0, 3] },
+      caption: { fontSize: hs * 0.9, color: COLOR.muted },
+      tocTitle: { fontSize: hs * 1.45, bold: true, color: COLOR.heading, margin: [0, 0, 0, 10] },
+      toc: { fontSize: hs },
+      tocL1: { fontSize: hs, bold: true },
+      coverTitle: { fontSize: 30, bold: true, color: COLOR.heading, lineHeight: 1.1 },
+      coverSubtitle: { fontSize: 16, color: "#4b5563", margin: [0, 10, 0, 0] },
+      coverMeta: { fontSize: 12, color: "#4b5563", margin: [0, 4, 0, 0] }
+    }
+  };
+}
+var FONTS_READY = /* @__PURE__ */ Symbol.for("ai-matrx.print.document.pdfmake-fonts");
+async function loadPdfMake() {
+  const mod = await import("pdfmake");
+  const pdfMake = mod.default ?? mod;
+  if (!pdfMake[FONTS_READY]) {
+    const vfsMod = await import("pdfmake/build/vfs_fonts.js");
+    const vfs = vfsMod.default ?? vfsMod;
+    if (typeof pdfMake.addVirtualFileSystem === "function") {
+      pdfMake.addVirtualFileSystem(vfs);
+      const courier = await import("pdfmake/build/standard-fonts/Courier.js");
+      pdfMake.addFontContainer?.(courier.default ?? courier);
+    } else {
+      const B = globalThis.Buffer;
+      for (const [k, v] of Object.entries(vfs)) pdfMake.virtualfs?.writeFileSync(k, B.from(v, "base64"));
+    }
+    pdfMake.addFonts({
+      Roboto: {
+        normal: "Roboto-Regular.ttf",
+        bold: "Roboto-Medium.ttf",
+        italics: "Roboto-Italic.ttf",
+        bolditalics: "Roboto-MediumItalic.ttf"
+      },
+      Courier: { normal: "Courier", bold: "Courier-Bold", italics: "Courier-Oblique", bolditalics: "Courier-BoldOblique" }
+    });
+    pdfMake.setUrlAccessPolicy?.(() => false);
+    pdfMake.setLocalAccessPolicy?.((p) => /^Courier(-Bold|-Oblique|-BoldOblique)?$/.test(p));
+    pdfMake[FONTS_READY] = true;
+  }
+  return pdfMake;
+}
+async function documentToPdf(tree, images) {
+  const pdfMake = await loadPdfMake();
+  let pageCount = 0;
+  const def = buildPdfDefinition(tree, images, (n) => {
+    pageCount = n;
+  });
+  const buf = await pdfMake.createPdf(def).getBuffer();
+  return { bytes: buf instanceof Uint8Array ? new Uint8Array(buf) : new Uint8Array(buf), pageCount };
+}
+async function headingPages(tree, images) {
+  const pdfMake = await loadPdfMake();
+  const def = buildPdfDefinition({ ...tree, notices: [] }, images);
+  await pdfMake.createPdf(def).getBuffer();
+  const want = new Set(tree.toc.map((e) => e.id));
+  const pages = /* @__PURE__ */ new Map();
+  const walk = (n) => {
+    if (Array.isArray(n)) {
+      for (const x of n) walk(x);
+      return;
+    }
+    if (!n || typeof n !== "object") return;
+    const o = n;
+    const pos = o.positions?.[0];
+    if (typeof o.id === "string" && want.has(o.id) && pos?.pageNumber && !pages.has(o.id)) pages.set(o.id, pos.pageNumber);
+    for (const key of ["stack", "columns", "ul", "ol", "content"]) if (key in o) walk(o[key]);
+    const table = o.table;
+    if (table?.body) walk(table.body);
+  };
+  walk(def.content);
+  return pages;
+}
+
+// src/document/tree.ts
+var import_mdast_util_from_markdown = require("mdast-util-from-markdown");
+var import_mdast_util_gfm = require("mdast-util-gfm");
+var import_micromark_extension_gfm = require("micromark-extension-gfm");
+
+// src/markdown.ts
+var import_html_escape3 = require("@ai-matrx/kit/html-escape");
+function removeThinkingContent(content) {
+  if (!content) return "";
+  let result = content.replace(/\n*<thinking>[\s\S]*?<\/thinking>\n*/gi, "\n").replace(/\n*<think>[\s\S]*?<\/think>\n*/gi, "\n").replace(/\n*<reasoning>[\s\S]*?<\/reasoning>\n*/gi, "\n");
+  result = result.replace(/\n{3,}/g, "\n\n");
+  return result.trim();
+}
+var PAGE_BREAK_HTML = `<div class="${PAGE_BREAK_CLASS}" role="separator" aria-label="${PAGE_BREAK_LABEL}" data-label="${PAGE_BREAK_LABEL}"></div>`;
+var LINK_URL = String.raw`((?:[^()\s]|\([^()\s]*\))+)(?:\s+"[^"]*")?`;
+var IMAGE_RE = new RegExp(String.raw`!\[([^\]]*)\]\(` + LINK_URL + String.raw`\)`, "g");
+var LINK_RE = new RegExp(String.raw`\[([^\]]+)\]\(` + LINK_URL + String.raw`\)`, "g");
+
+// src/document/citations.ts
+var t = (value) => ({ type: "text", value });
+var em = (value) => ({ type: "emphasis", children: [t(value)] });
+function parseCitationGroup(inner) {
+  const parts = inner.split(";").map((p) => p.trim());
+  if (parts.length === 0) return null;
+  const refs = [];
+  for (const part of parts) {
+    const m = /^(-?)@([A-Za-z0-9_][\w:.#$%&+?<>~/-]*?)(?:\s*,\s*(.+))?$/.exec(part);
+    if (!m) return null;
+    if (/^(fig|tbl|sec|eq|lst):/i.test(m[2])) return null;
+    refs.push({ key: m[2], locator: m[3]?.trim(), suppressAuthor: m[1] === "-" });
+  }
+  return refs;
+}
+function year(item) {
+  const dp = item.issued?.["date-parts"]?.[0]?.[0];
+  if (dp !== void 0 && dp !== null && String(dp).trim()) return String(dp);
+  return item.issued?.literal ?? "n.d.";
+}
+var family = (n) => n.literal ?? n.family ?? n.given ?? "";
+function initials(given) {
+  if (!given) return "";
+  return given.split(/[\s]+/).filter(Boolean).map(
+    (g) => g.split("-").map((p) => `${p[0]?.toUpperCase() ?? ""}.`).join("-")
+  ).join(" ");
+}
+function authorsOf(item) {
+  return item.author?.length ? item.author : item.editor ?? [];
+}
+function shortAuthors(item, style, narrative = false) {
+  const a = authorsOf(item);
+  if (a.length === 0) return item.title ? `"${item.title}"` : item.id;
+  const and = style === "apa" && !narrative ? "&" : "and";
+  if (a.length === 1) return family(a[0]);
+  if (a.length === 2) return `${family(a[0])} ${and} ${family(a[1])}`;
+  if (style === "chicago" && a.length === 3)
+    return `${family(a[0])}, ${family(a[1])}, and ${family(a[2])}`;
+  return `${family(a[0])} et al.`;
+}
+function mlaLocator(locator) {
+  return locator.replace(/^(?:pp?\.|pages?)\s*/i, "");
+}
+function formatCitation(refs, lookup, style, narrative = false) {
+  let resolved = true;
+  const pieces = refs.map((r) => {
+    const item = lookup(r.key);
+    if (!item) {
+      resolved = false;
+      return `${r.key}?`;
+    }
+    const who = shortAuthors(item, style);
+    const when = year(item);
+    const loc = r.locator;
+    if (style === "mla") {
+      const l = loc ? mlaLocator(loc) : "";
+      if (r.suppressAuthor || narrative) return l;
+      return l ? `${who} ${l}` : who;
+    }
+    if (style === "chicago") {
+      const l = loc ? mlaLocator(loc) : "";
+      const core2 = r.suppressAuthor || narrative ? when : `${who} ${when}`;
+      return l ? `${core2}, ${l}` : core2;
+    }
+    const core = r.suppressAuthor || narrative ? when : `${who}, ${when}`;
+    return loc ? `${core}, ${loc}` : core;
+  });
+  if (narrative && refs.length === 1) {
+    const item = lookup(refs[0].key);
+    if (item) {
+      const inner = pieces[0];
+      const who = shortAuthors(item, style, true);
+      return { label: inner ? `${who} (${inner})` : who, resolved };
+    }
+  }
+  const body = pieces.filter(Boolean).join("; ");
+  return { label: body ? `(${body})` : "", resolved };
+}
+function apaNames(names) {
+  const fmt = (n) => n.literal ?? [n.family, initials(n.given)].filter(Boolean).join(", ");
+  if (names.length === 1) return fmt(names[0]);
+  if (names.length <= 20) {
+    return `${names.slice(0, -1).map(fmt).join(", ")}, & ${fmt(names[names.length - 1])}`;
+  }
+  return `${names.slice(0, 19).map(fmt).join(", ")}, \u2026 ${fmt(names[names.length - 1])}`;
+}
+function invertedFirst(names, and, etAlAt) {
+  const first = (n) => n.literal ?? [n.family, n.given].filter(Boolean).join(", ");
+  const rest = (n) => n.literal ?? [n.given, n.family].filter(Boolean).join(" ");
+  if (names.length === 1) return first(names[0]);
+  if (names.length >= etAlAt) return `${first(names[0])}, et al.`;
+  if (names.length === 2) return `${first(names[0])}, ${and} ${rest(names[1])}`;
+  return `${first(names[0])}, ${names.slice(1, -1).map(rest).join(", ")}, ${and} ${rest(names[names.length - 1])}`;
+}
+var endDot = (s) => /[.?!]$/.test(s) ? s : `${s}.`;
+var isArticle = (i) => /article|chapter|paper-conference|entry/.test(i.type ?? "") || Boolean(i["container-title"] && (i.volume || i.issue || i.page));
+var isWeb = (i) => /webpage|post|post-weblog/.test(i.type ?? "") || !i.publisher && !i["container-title"] && Boolean(i.URL);
+var link = (i) => i.DOI ? `https://doi.org/${i.DOI.replace(/^https?:\/\/doi\.org\//, "")}` : i.URL;
+function formatApa(i) {
+  const out = [];
+  const names = authorsOf(i);
+  const y = year(i);
+  if (names.length) out.push(t(`${endDot(apaNames(names))} (${y}). `));
+  if (isArticle(i)) {
+    if (i.title) out.push(t(`${endDot(i.title)} `));
+    if (!names.length) out.push(t(`(${y}). `));
+    if (i["container-title"]) {
+      out.push(em(i["container-title"]));
+      if (i.volume) {
+        out.push(t(", "), em(String(i.volume)));
+      }
+      if (i.issue) out.push(t(`(${i.issue})`));
+      if (i.page) out.push(t(`, ${i.page}`));
+      out.push(t(". "));
+    }
+  } else {
+    if (i.title) out.push(em(i.title));
+    if (i.edition) out.push(t(` (${i.edition} ed.)`));
+    out.push(t(". "));
+    if (!names.length) out.push(t(`(${y}). `));
+    if (isWeb(i) && i["container-title"]) out.push(t(`${endDot(i["container-title"])} `));
+    if (i.publisher) out.push(t(`${endDot(i.publisher)} `));
+  }
+  const l = link(i);
+  if (l) out.push({ type: "link", url: l, children: [t(l)] });
+  return trimTail(out);
+}
+function formatMla(i) {
+  const out = [];
+  const names = authorsOf(i);
+  if (names.length) out.push(t(`${endDot(invertedFirst(names, "and", 3))} `));
+  const y = year(i);
+  if (isArticle(i) || isWeb(i)) {
+    if (i.title) out.push(t(`\u201C${endDot(i.title)}\u201D `));
+    if (i["container-title"]) out.push(em(i["container-title"]));
+    const tail = [];
+    if (i.volume) tail.push(`vol. ${i.volume}`);
+    if (i.issue) tail.push(`no. ${i.issue}`);
+    if (i.publisher && isWeb(i)) tail.push(i.publisher);
+    if (y !== "n.d.") tail.push(y);
+    if (i.page) tail.push(`${/[-–]/.test(i.page) ? "pp." : "p."} ${i.page}`);
+    if (tail.length) out.push(t(`${i["container-title"] ? ", " : ""}${tail.join(", ")}`));
+    const l = link(i);
+    if (l) out.push(t(", "), { type: "link", url: l, children: [t(l.replace(/^https?:\/\//, ""))] });
+    out.push(t("."));
+  } else {
+    if (i.title) out.push(em(i.title), t(". "));
+    const tail = [i.publisher, y !== "n.d." ? y : void 0].filter(Boolean);
+    if (tail.length) out.push(t(`${tail.join(", ")}.`));
+  }
+  return trimTail(out);
+}
+function formatChicago(i) {
+  const out = [];
+  const names = authorsOf(i);
+  if (names.length) out.push(t(`${endDot(invertedFirst(names, "and", 11))} `));
+  out.push(t(`${year(i)}. `));
+  if (isArticle(i) || isWeb(i)) {
+    if (i.title) out.push(t(`\u201C${endDot(i.title)}\u201D `));
+    if (i["container-title"]) {
+      out.push(em(i["container-title"]));
+      if (i.volume) out.push(t(` ${i.volume}`));
+      if (i.issue) out.push(t(` (${i.issue})`));
+      if (i.page) out.push(t(`: ${i.page}`));
+      out.push(t(". "));
+    }
+  } else {
+    if (i.title) out.push(em(i.title), t(". "));
+    const pub = [i["publisher-place"], i.publisher].filter(Boolean).join(": ");
+    if (pub) out.push(t(`${endDot(pub)} `));
+  }
+  const l = link(i);
+  if (l) out.push({ type: "link", url: l, children: [t(l)] }, t("."));
+  return trimTail(out);
+}
+function trimTail(out) {
+  const last = out[out.length - 1];
+  if (last?.type === "text") last.value = last.value.replace(/\s+$/, "");
+  return out;
+}
+function formatBibliography(items, style) {
+  const sortKey = (i) => {
+    const a = authorsOf(i)[0];
+    return `${(a ? family(a) : i.title ?? i.id).toLowerCase()}\0${year(i)}\0${(i.title ?? "").toLowerCase()}`;
+  };
+  const fmt = style === "mla" ? formatMla : style === "chicago" ? formatChicago : formatApa;
+  return [...items].sort((a, b) => sortKey(a).localeCompare(sortKey(b))).map((i) => ({ id: i.id, children: fmt(i) }));
+}
+
+// src/document/tree.ts
+var MARK = "matrx:";
+var FENCE_RE = /^\s*(`{3,}|~{3,})/;
+var TABLE_CAPTION_RE = /^\s{0,3}(?:Table:|:)\s+\S/;
+function prepass(body) {
+  const lines = body.split(/\r?\n/);
+  const out = [];
+  let fence = null;
+  const isTableLine = (l) => l !== void 0 && /^\s{0,3}\|/.test(l);
+  const prevNonBlank = (i) => {
+    for (let j = i - 1; j >= 0; j--) if (lines[j].trim()) return lines[j];
+    return void 0;
+  };
+  const nextNonBlank = (i) => {
+    for (let j = i + 1; j < lines.length; j++) if (lines[j].trim()) return lines[j];
+    return void 0;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fm = FENCE_RE.exec(line);
+    if (fm) {
+      const marker = fm[1];
+      if (fence === null) fence = marker;
+      else if (marker[0] === fence[0] && marker.length >= fence.length) fence = null;
+      out.push(line);
+      continue;
+    }
+    if (fence !== null) {
+      out.push(line);
+      continue;
+    }
+    let directive = null;
+    const section = parseSectionBreakLine(line);
+    if (section) directive = `<!--${MARK}section ${JSON.stringify(section)}-->`;
+    else if (isPageBreakLine(line)) directive = `<!--${MARK}pagebreak-->`;
+    else if (isTocLine(line)) directive = `<!--${MARK}toc-->`;
+    else if (isBibliographyLine(line)) directive = `<!--${MARK}bibliography-->`;
+    if (directive) {
+      out.push("", directive, "");
+      continue;
+    }
+    if (TABLE_CAPTION_RE.test(line) && (isTableLine(prevNonBlank(i)) || isTableLine(nextNonBlank(i)))) {
+      out.push("", line.trim().replace(/^:\s+/, "Table: "), "");
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+var slugify = (s) => s.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-") || "section";
+function plainText(inlines2) {
+  return inlines2.map((n) => {
+    switch (n.type) {
+      case "text":
+      case "code":
+        return n.value;
+      case "strong":
+      case "emphasis":
+      case "delete":
+      case "link":
+        return plainText(n.children);
+      case "xref":
+      case "cite":
+        return n.label;
+      case "image":
+        return n.alt;
+      case "break":
+        return " ";
+      default:
+        return "";
+    }
+  }).join("");
+}
+function uniqueId(ctx, base) {
+  let id = base;
+  for (let n = 2; ctx.ids.has(id); n++) id = `${base}-${n}`;
+  ctx.ids.add(id);
+  return id;
+}
+var CITE_GROUP_RE = /\[(-?@[^[\]]+)\]/g;
+var BARE_RE = /(^|[^\w@.\\])@((?:fig|tbl|sec|eq):[\w-]+|[A-Za-z0-9_](?:[\w:.#$%&+?<>~/-]*\w)?)/g;
+function scanText(value, ctx) {
+  const out = [];
+  const pushText = (s) => {
+    if (!s) return;
+    const last2 = out[out.length - 1];
+    if (last2?.type === "text") last2.value += s;
+    else out.push({ type: "text", value: s });
+  };
+  const scanBare = (s) => {
+    let last2 = 0;
+    for (const m of s.matchAll(BARE_RE)) {
+      const key = m[2];
+      const start = m.index + m[1].length;
+      const xm = /^(fig|tbl|sec|eq):(.+)$/.exec(key);
+      if (xm) {
+        pushText(s.slice(last2, start));
+        out.push(makeXref(`${xm[1]}:${xm[2]}`, ctx));
+        last2 = start + key.length + 1;
+      } else if (ctx.refs.has(key)) {
+        pushText(s.slice(last2, start));
+        ctx.cited.add(key);
+        const { label, resolved } = formatCitation(
+          [{ key, suppressAuthor: false }],
+          (k) => ctx.refs.get(k),
+          ctx.settings.citationStyle,
+          true
+        );
+        out.push({ type: "cite", keys: [key], label, resolved });
+        last2 = start + key.length + 1;
+      }
+    }
+    pushText(s.slice(last2));
+  };
+  let last = 0;
+  for (const m of value.matchAll(CITE_GROUP_RE)) {
+    const inner = m[1];
+    const refs = parseCitationGroup(inner);
+    const single = /^@((?:fig|tbl|sec|eq):[\w-]+)$/.exec(inner.trim());
+    if (!refs && !single) continue;
+    scanBare(value.slice(last, m.index));
+    if (single) out.push(makeXref(single[1], ctx));
+    else if (refs) {
+      const { label, resolved } = formatCitation(refs, (k) => ctx.refs.get(k), ctx.settings.citationStyle);
+      for (const r of refs) if (ctx.refs.has(r.key)) ctx.cited.add(r.key);
+      if (!resolved) {
+        const missing = refs.filter((r) => !ctx.refs.has(r.key)).map((r) => r.key);
+        ctx.notify({
+          code: "citation-unresolved",
+          message: `No reference was found for ${missing.map((k) => `@${k}`).join(", ")}.`,
+          remedy: "Add it under `references:` in the settings at the top (id, title, author, issued), or fix the key's spelling."
+        });
+      }
+      out.push({ type: "cite", keys: refs.map((r) => r.key), label, resolved });
+    }
+    last = m.index + m[0].length;
+  }
+  scanBare(value.slice(last));
+  return out;
+}
+function makeXref(target, ctx) {
+  const x = { type: "xref", target, label: target, resolved: false };
+  ctx.xrefs.push(x);
+  return x;
+}
+function inlines(nodes, ctx) {
+  const out = [];
+  for (const n of nodes) {
+    switch (n.type) {
+      case "text":
+        out.push(...scanText(n.value, ctx));
+        break;
+      case "strong":
+        out.push({ type: "strong", children: inlines(n.children, ctx) });
+        break;
+      case "emphasis":
+        out.push({ type: "emphasis", children: inlines(n.children, ctx) });
+        break;
+      case "delete":
+        out.push({ type: "delete", children: inlines(n.children, ctx) });
+        break;
+      case "inlineCode":
+        out.push({ type: "code", value: n.value });
+        break;
+      case "break":
+        out.push({ type: "break" });
+        break;
+      case "link":
+        out.push({ type: "link", url: n.url, children: inlines(n.children, ctx) });
+        break;
+      case "image":
+        out.push({ type: "image", url: n.url, alt: n.alt ?? "" });
+        break;
+      case "linkReference": {
+        const def = ctx.defs.get(n.identifier);
+        const kids = inlines(n.children, ctx);
+        if (def) out.push({ type: "link", url: def.url, children: kids });
+        else out.push({ type: "text", value: "[" }, ...kids, { type: "text", value: "]" });
+        break;
+      }
+      case "imageReference": {
+        const def = ctx.defs.get(n.identifier);
+        if (def) out.push({ type: "image", url: def.url, alt: n.alt ?? "" });
+        break;
+      }
+      case "footnoteReference": {
+        let num = ctx.noteOrder.get(n.identifier);
+        if (num === void 0) {
+          num = ctx.noteOrder.size + 1;
+          ctx.noteOrder.set(n.identifier, num);
+        }
+        out.push({ type: "noteRef", n: num });
+        break;
+      }
+      case "html":
+        if (/^<br\s*\/?>$/i.test(n.value.trim())) out.push({ type: "break" });
+        else if (!/^<!--/.test(n.value)) announceHtml(ctx);
+        break;
+      default:
+        break;
+    }
+  }
+  return out;
+}
+function announceHtml(ctx) {
+  if (ctx.htmlAnnounced) return;
+  ctx.htmlAnnounced = true;
+  ctx.notify({
+    code: "html-stripped",
+    message: "Raw HTML tags in the document were left out of the printed/exported file (their text is kept).",
+    remedy: "Use markdown formatting instead of HTML tags; a page break is the line <!-- pagebreak -->."
+  });
+}
+function directiveOf(node) {
+  if (node.type !== "html") return null;
+  const m = /^<!--matrx:(section|pagebreak|toc|bibliography)\s*(.*?)-->$/.exec(node.value.trim());
+  if (!m) return null;
+  if (m[1] === "section") {
+    try {
+      return { type: "section", value: JSON.parse(m[2] || "{}") };
+    } catch {
+      return { type: "section", value: {} };
+    }
+  }
+  return { type: m[1] };
+}
+var ATTR_RE = /\s*\{([^{}]*)\}\s*$/;
+function takeAttributes(kids) {
+  const last = kids[kids.length - 1];
+  if (last?.type !== "text") return { unnumbered: false };
+  const m = ATTR_RE.exec(last.value);
+  if (!m) return { unnumbered: false };
+  const attrs = m[1].trim().split(/\s+/);
+  if (!attrs.every((a) => /^(#[\w:.-]+|\.[\w-]+|-|[\w-]+=\S+)$/.test(a))) return { unnumbered: false };
+  last.value = last.value.slice(0, m.index).replace(/\s+$/, "");
+  if (!last.value) kids.pop();
+  const id = attrs.find((a) => a.startsWith("#"))?.slice(1);
+  const unnumbered = attrs.includes("-") || attrs.includes(".unnumbered");
+  return { id, unnumbered };
+}
+function figureOf(node, ctx) {
+  if (node.type !== "paragraph") return null;
+  const kids = node.children.filter((c) => !(c.type === "text" && !c.value.trim()));
+  const img = kids[0];
+  if (!img || img.type !== "image" && img.type !== "imageReference") return null;
+  let url;
+  let alt = img.alt ?? "";
+  if (img.type === "image") {
+    url = img.url;
+    if (!alt && img.title) alt = img.title;
+  } else {
+    const def = ctx.defs.get(img.identifier);
+    if (!def) return null;
+    url = def.url;
+  }
+  let id;
+  if (kids.length === 2) {
+    const tail = kids[1];
+    const m = tail?.type === "text" ? /^\s*\{#fig:([\w-]+)[^}]*\}\s*$/.exec(tail.value) : null;
+    if (!m) return null;
+    id = m[1];
+  } else if (kids.length > 2) return null;
+  const figure = { type: "figure", url, alt };
+  if (alt.trim() || id) {
+    const number = ++ctx.figN;
+    const children = alt.trim() ? scanText(alt, ctx) : [];
+    const caption = { kind: "fig", id, number, label: `Figure ${number}`, children };
+    if (id) uniqueId(ctx, `fig:${id}`);
+    figure.caption = caption;
+    ctx.figures.push(caption);
+  }
+  return figure;
+}
+function tableCaptionText(node) {
+  if (!node || node.type !== "paragraph") return null;
+  const first = node.children[0];
+  if (first?.type !== "text" || !/^Table:\s+/.test(first.value)) return null;
+  const rest = [{ ...first, value: first.value.replace(/^Table:\s+/, "") }, ...node.children.slice(1)];
+  return rest;
+}
+function convertBlocks(nodes, ctx, out, allowDirectives = false) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const block3 = convertBlock(nodes, i, ctx, allowDirectives);
+    if (block3 === "skip-next") {
+      i++;
+      continue;
+    }
+    if (block3) out.push(block3);
+  }
+}
+function convertTable(node, captionNodes, ctx) {
+  const rows = node.children.map((row) => row.children.map((cell) => inlines(cell.children, ctx)));
+  const table = {
+    type: "table",
+    align: (node.align ?? []).map((a) => a ?? null),
+    header: rows[0] ?? [],
+    rows: rows.slice(1)
+  };
+  if (captionNodes) {
+    const kids = inlines(captionNodes, ctx);
+    const { id } = takeAttributes(kids);
+    const tid = id?.replace(/^tbl:/, "");
+    const number = ++ctx.tblN;
+    const caption = { kind: "tbl", id: tid, number, label: `Table ${number}`, children: kids };
+    if (tid) uniqueId(ctx, `tbl:${tid}`);
+    table.caption = caption;
+    ctx.tables.push(caption);
+  }
+  return table;
+}
+function convertBlock(nodes, i, ctx, allowDirectives) {
+  const node = nodes[i];
+  switch (node.type) {
+    case "heading": {
+      const children = inlines(node.children, ctx);
+      const { id, unnumbered } = takeAttributes(children);
+      const plain2 = plainText(children).trim();
+      const hid = uniqueId(ctx, id ?? slugify(plain2));
+      const h = {
+        type: "heading",
+        level: node.depth,
+        id: hid,
+        plain: plain2,
+        children,
+        numbered: !unnumbered
+      };
+      ctx.headingIndex.set(hid, h);
+      return h;
+    }
+    case "paragraph": {
+      const fig = figureOf(node, ctx);
+      if (fig) return fig;
+      const cap = tableCaptionText(node);
+      if (cap) {
+        const next = nodes[i + 1];
+        const prev = nodes[i - 1];
+        if (next?.type === "table") {
+          const t2 = convertTable(next, cap, ctx);
+          nodes[i + 1] = { type: "html", value: "<!--matrx:consumed-->" };
+          return t2;
+        }
+        if (prev?.type === "table") return null;
+      }
+      return { type: "paragraph", children: inlines(node.children, ctx) };
+    }
+    case "table": {
+      const next = nodes[i + 1];
+      const cap = tableCaptionText(next);
+      if (cap) {
+        const t2 = convertTable(node, cap, ctx);
+        nodes[i + 1] = { type: "html", value: "<!--matrx:consumed-->" };
+        return t2;
+      }
+      return convertTable(node, null, ctx);
+    }
+    case "list": {
+      const items = node.children.map((li) => {
+        const children = [];
+        convertBlocks(li.children, ctx, children);
+        return { checked: li.checked ?? null, children };
+      });
+      return { type: "list", ordered: Boolean(node.ordered), start: node.start ?? 1, items };
+    }
+    case "blockquote": {
+      const children = [];
+      convertBlocks(node.children, ctx, children);
+      return { type: "blockquote", children };
+    }
+    case "code":
+      return { type: "code", lang: node.lang ?? "", value: node.value };
+    case "thematicBreak":
+      return { type: "rule" };
+    case "html": {
+      if (/^<!--matrx:consumed-->$/.test(node.value)) return null;
+      if (/^\s*<!--[\s\S]*-->\s*$/.test(node.value)) return null;
+      if (/^\s*<br\s*\/?>\s*$/i.test(node.value)) return null;
+      const text = node.value.replace(/<(script|style)\b[\s\S]*?<\/\1>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+      if (/<(?!\/?(?:artifact|flashcards)\b)[a-z]/i.test(node.value)) announceHtml(ctx);
+      return text ? { type: "paragraph", children: [{ type: "text", value: text }] } : null;
+    }
+    case "math":
+      return { type: "code", lang: "math", value: node.value };
+    default:
+      void allowDirectives;
+      return null;
+  }
+}
+function resolveXrefs(ctx) {
+  const figs = new Map(ctx.figures.filter((c) => c.id).map((c) => [c.id, c]));
+  const tbls = new Map(ctx.tables.filter((c) => c.id).map((c) => [c.id, c]));
+  for (const x of ctx.xrefs) {
+    const [kind, id] = x.target.split(/:(.*)/s);
+    let label;
+    if (kind === "fig") label = figs.get(id)?.label;
+    else if (kind === "tbl") label = tbls.get(id)?.label;
+    else if (kind === "sec") {
+      const h = ctx.headingIndex.get(`sec:${id}`) ?? ctx.headingIndex.get(id);
+      if (h) {
+        label = h.number ? `Section ${h.number}` : `\u201C${h.plain}\u201D`;
+        x.target = `sec:${h.id}`;
+      }
+    }
+    if (label) {
+      x.label = label;
+      x.resolved = true;
+    } else {
+      x.label = "??";
+      ctx.notify({
+        code: "xref-unresolved",
+        message: `The cross-reference @${x.target} points at nothing in this document.`,
+        remedy: kind === "sec" ? `Give the heading an id: \`## Title {#sec:${id}}\`.` : kind === "fig" ? `Label the image: \`![Caption](url){#fig:${id}}\`.` : `Caption the table: a line \`Table: Caption {#tbl:${id}}\` right before or after it.`
+      });
+    }
+  }
+}
+function parseDocument(source, options = {}) {
+  const notices = [];
+  const notify = (n) => {
+    notices.push(n);
+    options.onNotice?.(n);
+  };
+  const sink = [];
+  const fm = splitFrontmatter(source ?? "", sink);
+  const settings = resolveSettings(fm.data, sink, options);
+  for (const n of sink) notify(n);
+  const body = removeThinkingContent(fm.body);
+  const root = (0, import_mdast_util_from_markdown.fromMarkdown)(prepass(body), {
+    extensions: [(0, import_micromark_extension_gfm.gfm)()],
+    mdastExtensions: [(0, import_mdast_util_gfm.gfmFromMarkdown)()]
+  });
+  const ctx = {
+    settings,
+    notices,
+    notify,
+    defs: /* @__PURE__ */ new Map(),
+    footnoteDefs: /* @__PURE__ */ new Map(),
+    noteOrder: /* @__PURE__ */ new Map(),
+    refs: new Map(settings.references.map((r) => [r.id, r])),
+    cited: /* @__PURE__ */ new Set(),
+    htmlAnnounced: false,
+    ids: /* @__PURE__ */ new Set(),
+    figN: 0,
+    tblN: 0,
+    figures: [],
+    tables: [],
+    xrefs: [],
+    headingIndex: /* @__PURE__ */ new Map()
+  };
+  const visit = (n) => {
+    if (n.type === "definition") ctx.defs.set(n.identifier, { url: n.url, title: n.title });
+    if (n.type === "footnoteDefinition") ctx.footnoteDefs.set(n.identifier, n.children);
+    if ("children" in n) for (const c of n.children) visit(c);
+  };
+  visit(root);
+  const sections = [
+    { orientation: settings.page.orientation, columns: settings.columns, blocks: [] }
+  ];
+  let hasTocBlock = false;
+  let hasBibBlock = false;
+  const top = root.children.filter((n) => n.type !== "definition" && n.type !== "footnoteDefinition");
+  for (let i = 0; i < top.length; i++) {
+    const node = top[i];
+    const d = directiveOf(node);
+    const current = sections[sections.length - 1];
+    if (d?.type === "section") {
+      sections.push({
+        orientation: d.value.orientation ?? settings.page.orientation,
+        columns: d.value.columns ?? settings.columns,
+        blocks: []
+      });
+      continue;
+    }
+    if (d?.type === "pagebreak") {
+      current.blocks.push({ type: "pageBreak" });
+      continue;
+    }
+    if (d?.type === "toc") {
+      if (!hasTocBlock) current.blocks.push({ type: "toc" });
+      hasTocBlock = true;
+      continue;
+    }
+    if (d?.type === "bibliography") {
+      current.blocks.push({ type: "bibliography" });
+      hasBibBlock = true;
+      continue;
+    }
+    const block3 = convertBlock(top, i, ctx, true);
+    if (block3 && block3 !== "skip-next") current.blocks.push(block3);
+  }
+  const nonEmpty = sections.filter((s, idx) => s.blocks.length > 0 || idx === 0);
+  sections.length = 0;
+  sections.push(...nonEmpty);
+  for (const s of sections) {
+    while (s.blocks[0]?.type === "pageBreak") s.blocks.shift();
+    while (s.blocks[s.blocks.length - 1]?.type === "pageBreak") s.blocks.pop();
+  }
+  const allHeadings = [];
+  const collect = (blocks3) => {
+    for (const b of blocks3) if (b.type === "heading") allHeadings.push(b);
+  };
+  for (const s of sections) collect(s.blocks);
+  const minLevel = Math.min(7, ...allHeadings.map((h) => h.level));
+  if (settings.numberSections) {
+    const counters = [0, 0, 0, 0, 0, 0];
+    for (const h of allHeadings) {
+      if (!h.numbered) continue;
+      const depth = h.level - minLevel;
+      counters[depth] = (counters[depth] ?? 0) + 1;
+      for (let d = depth + 1; d < 6; d++) counters[d] = 0;
+      h.number = counters.slice(0, depth + 1).map((c) => c || 1).join(".");
+    }
+  }
+  const notes = [];
+  for (const [identifier, n] of [...ctx.noteOrder.entries()].sort((a, b) => a[1] - b[1])) {
+    const children = [];
+    convertBlocks(ctx.footnoteDefs.get(identifier) ?? [], ctx, children);
+    notes.push({ n, children });
+  }
+  const last = sections[sections.length - 1];
+  const backLevel = minLevel <= 6 ? minLevel : 1;
+  const backHeading = (plain2, id) => {
+    const h = {
+      type: "heading",
+      level: backLevel,
+      id: uniqueId(ctx, id),
+      plain: plain2,
+      children: [{ type: "text", value: plain2 }],
+      numbered: false
+    };
+    allHeadings.push(h);
+    return h;
+  };
+  if (notes.length) last.blocks.push(backHeading("Notes", "notes"), { type: "notes" });
+  const citedItems = [...ctx.cited].map((k) => ctx.refs.get(k)).filter((x) => Boolean(x));
+  const bibliography = formatBibliography(citedItems, settings.citationStyle);
+  if (bibliography.length || hasBibBlock) {
+    const heading = backHeading(settings.bibliographyTitle, "references");
+    if (hasBibBlock) {
+      for (const s of sections) {
+        const idx = s.blocks.findIndex((b) => b.type === "bibliography");
+        if (idx >= 0) {
+          s.blocks.splice(idx, 0, heading);
+          break;
+        }
+      }
+    } else {
+      last.blocks.push(heading, { type: "bibliography" });
+    }
+  }
+  if (settings.toc.enabled && !hasTocBlock) {
+    sections[0].blocks.unshift({ type: "toc" }, { type: "pageBreak" });
+  }
+  const order = [];
+  for (const s of sections) for (const b of s.blocks) if (b.type === "heading") order.push(b);
+  const toc = order.filter((h) => h.level - minLevel + 1 <= settings.toc.depth).map((h) => ({ id: h.id, level: h.level - minLevel + 1, text: h.number ? `${h.number} ${h.plain}` : h.plain }));
+  resolveXrefs(ctx);
+  if (!sections.some((s) => s.blocks.length) && !settings.cover) {
+    notify({
+      code: "empty-document",
+      message: "The document has no content to print or export.",
+      remedy: "Write something below the settings block (or remove the --- lines if they are not settings)."
+    });
+  }
+  return {
+    settings,
+    body,
+    sections,
+    toc,
+    figures: ctx.figures,
+    tables: ctx.tables,
+    bibliography,
+    notes,
+    notices
+  };
+}
+
+// src/document.ts
+var DOCUMENT_FORMATS = [
+  { format: "pdf", label: "PDF", extension: "pdf", mime: "application/pdf" },
+  { format: "docx", label: "Word (.docx)", extension: "docx", mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
+  { format: "epub", label: "EPUB", extension: "epub", mime: "application/epub+zip" },
+  { format: "html", label: "Web page (.html)", extension: "html", mime: "text/html" },
+  { format: "markdown", label: "Markdown", extension: "md", mime: "text/markdown" }
+];
+function sniff(bytes) {
+  const b = bytes;
+  if (b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) {
+    const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+    return { mime: "image/png", width: dv.getUint32(16), height: dv.getUint32(20) };
+  }
+  if (b[0] === 71 && b[1] === 73 && b[2] === 70) {
+    return { mime: "image/gif", width: b[6] | b[7] << 8, height: b[8] | b[9] << 8 };
+  }
+  if (b[0] === 255 && b[1] === 216) {
+    let i = 2;
+    while (i + 9 < b.length) {
+      if (b[i] !== 255) {
+        i++;
+        continue;
+      }
+      const marker = b[i + 1];
+      const len = b[i + 2] << 8 | b[i + 3];
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+        return { mime: "image/jpeg", height: b[i + 5] << 8 | b[i + 6], width: b[i + 7] << 8 | b[i + 8] };
+      }
+      i += 2 + len;
+    }
+  }
+  return null;
+}
+function toBase64(bytes) {
+  const g = globalThis;
+  if (g.Buffer) return g.Buffer.from(bytes).toString("base64");
+  let s = "";
+  for (let i = 0; i < bytes.length; i += 32768) s += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(s);
+}
+function fromBase64(b64) {
+  const g = globalThis;
+  if (g.Buffer) return new Uint8Array(g.Buffer.from(b64, "base64"));
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+var defaultImageLoader = async (url) => {
+  const data = /^data:image\/[\w.+-]+;base64,(.*)$/i.exec(url);
+  if (data) return fromBase64(data[1]);
+  if (!/^https?:\/\//i.test(url) || typeof fetch !== "function") return null;
+  const res = await fetch(url, { credentials: "omit" });
+  if (!res.ok) return null;
+  return new Uint8Array(await res.arrayBuffer());
+};
+function imageUrls(tree) {
+  const urls = /* @__PURE__ */ new Set();
+  const walk = (blocks3) => {
+    for (const b of blocks3) {
+      if (b.type === "figure") urls.add(b.url);
+      if (b.type === "list") for (const it of b.items) walk(it.children);
+      if (b.type === "blockquote") walk(b.children);
+    }
+  };
+  for (const s of tree.sections) walk(s.blocks);
+  if (tree.settings.cover && tree.settings.logo) urls.add(tree.settings.logo);
+  return [...urls];
+}
+async function resolveDocumentImages(tree, loader = defaultImageLoader, onNotice) {
+  const map = /* @__PURE__ */ new Map();
+  await Promise.all(
+    imageUrls(tree).map(async (url) => {
+      let bytes = null;
+      try {
+        bytes = await loader(url);
+      } catch {
+        bytes = null;
+      }
+      const info = bytes ? sniff(bytes) : null;
+      if (!bytes || !info || !info.width || !info.height) {
+        map.set(url, null);
+        const n = {
+          code: "image-unavailable",
+          message: `An image could not be included: ${url.length > 90 ? `${url.slice(0, 87)}\u2026` : url}`,
+          remedy: bytes ? "Use a PNG, JPEG or GIF image." : "Use an image stored in AI Matrx (or any public https link that allows downloads); private or expired links cannot be printed."
+        };
+        tree.notices.push(n);
+        onNotice?.(n);
+        return;
+      }
+      map.set(url, { ...info, bytes, dataUrl: `data:${info.mime};base64,${toBase64(bytes)}` });
+    })
+  );
+  return map;
+}
+var safeName = (s) => s.replace(/[\\/:*?"<>|\u0000-\u001f]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 120) || "document";
+async function exportDocument(source, format, options = {}) {
+  const tree = parseDocument(source, options);
+  const meta = DOCUMENT_FORMATS.find((f) => f.format === format);
+  if (!meta) throw new Error(`Unknown document format "${format}". Use one of: ${DOCUMENT_FORMATS.map((f) => f.format).join(", ")}.`);
+  const fileName = `${safeName(options.fileName ?? tree.settings.title ?? "document")}.${meta.extension}`;
+  const enc = new TextEncoder();
+  let bytes;
+  let pageCount;
+  if (format === "markdown") {
+    bytes = enc.encode(source);
+  } else {
+    const images = await resolveDocumentImages(tree, options.imageLoader, options.onNotice);
+    if (format === "html") bytes = enc.encode(documentToHtml(tree, { images }));
+    else if (format === "pdf") {
+      const r = await documentToPdf(tree, images);
+      bytes = r.bytes;
+      pageCount = r.pageCount;
+    } else if (format === "docx") {
+      const pages = tree.toc.length ? await headingPages(tree, images) : void 0;
+      bytes = await documentToDocx(tree, { images, headingPages: pages });
+    } else bytes = await documentToEpub(tree, { images });
+  }
+  return { format, bytes, mime: meta.mime, fileName, pageCount, tree, notices: tree.notices };
+}
+function downloadDocumentExport(exp) {
+  const blob = new Blob([exp.bytes], { type: exp.mime });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = exp.fileName;
+  a.rel = "noopener";
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 3e4);
+}
+//# sourceMappingURL=document.cjs.map