gutterpress 0.0.0

package/dist/render.js

@@ -0,0 +1,682 @@
+// src/lib/markdown/markdown-it-paged.js
+function isBareToken(token) {
+  return token && !token.includes("=") && !token.startsWith(".") && !token.startsWith("#");
+}
+function escapeHtml(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function parseMarkerLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("@"))
+    return null;
+  const tokens = [];
+  let buf = "";
+  let quote = null;
+  for (let i = 0;i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (quote) {
+      if (ch === quote)
+        quote = null;
+      else
+        buf += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (buf)
+        tokens.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf)
+    tokens.push(buf);
+  const head = tokens[0];
+  const kind = head.slice(1);
+  if (!["chapter", "spread", "page", "section", "continue", "page-break", "column-break", "end-section"].includes(kind))
+    return null;
+  if (kind === "page-break" || kind === "column-break" || kind === "end-section" || kind === "continue") {
+    return { kind, name: null, attrs: {} };
+  }
+  const body = tokens.slice(1);
+  const hasExplicitAttrsOrShorthand = body.some((token) => token.includes("=") || token.startsWith(".") || token.startsWith("#"));
+  const bareTokens = body.filter(isBareToken);
+  let name = null;
+  let nameIndex = -1;
+  const firstBareTokenIndex = body.findIndex((token) => isBareToken(token));
+  if (hasExplicitAttrsOrShorthand && bareTokens.length) {
+    name = bareTokens[0];
+    nameIndex = firstBareTokenIndex;
+  } else if (bareTokens.length === 1) {
+    name = bareTokens[0];
+    nameIndex = firstBareTokenIndex;
+  }
+  const attrs = {};
+  const classes = [];
+  let sawExplicitAttr = false;
+  let hasAmbiguousBareToken = false;
+  for (let idx = 0;idx < body.length; idx++) {
+    if (idx === nameIndex) {
+      if (sawExplicitAttr && isBareToken(body[idx]))
+        hasAmbiguousBareToken = true;
+      continue;
+    }
+    const t = body[idx];
+    if (t.startsWith(".")) {
+      const c = t.slice(1).trim();
+      if (c)
+        classes.push(c);
+      continue;
+    }
+    if (t.startsWith("#")) {
+      const id = t.slice(1).trim();
+      if (id)
+        attrs.id = id;
+      continue;
+    }
+    const eq = t.indexOf("=");
+    if (eq > 0) {
+      sawExplicitAttr = true;
+      const key = t.slice(0, eq).trim();
+      const val = t.slice(eq + 1).trim();
+      if (!key)
+        continue;
+      if (key === "class") {
+        val.split(/[,\s]+/).filter(Boolean).forEach((c) => classes.push(c));
+      } else {
+        attrs[key] = val;
+      }
+      continue;
+    }
+    if (sawExplicitAttr && isBareToken(t))
+      hasAmbiguousBareToken = true;
+    classes.push(t);
+  }
+  if (classes.length)
+    attrs.class = classes.join(" ");
+  const marker = { kind, name, attrs };
+  if (hasAmbiguousBareToken)
+    marker.__ambiguousBareToken = true;
+  return marker;
+}
+function warn(env, line, type, message, marker) {
+  if (!env.layoutWarnings)
+    env.layoutWarnings = [];
+  env.layoutWarnings.push({ line, type, message, marker });
+}
+function addClasses(token, baseClass, extraClass) {
+  const cls = [];
+  if (baseClass)
+    cls.push(baseClass);
+  if (extraClass)
+    cls.push(extraClass);
+  const merged = cls.join(" ").trim();
+  if (merged)
+    token.attrSet("class", merged);
+}
+function attachDataAttrs(token, kind, name, attrs) {
+  if (name) {
+    if (kind === "chapter")
+      token.attrSet("data-chapter-label", name);
+    if (kind === "spread")
+      token.attrSet("data-spread", name);
+    if (kind === "page")
+      token.attrSet("data-page", name);
+    if (kind === "section")
+      token.attrSet("data-section", name);
+  }
+  if (attrs.template)
+    token.attrSet("data-template", attrs.template);
+  if (attrs.region)
+    token.attrSet("data-region", attrs.region);
+  if (attrs.id)
+    token.attrSet("id", attrs.id);
+  for (const [k, v] of Object.entries(attrs)) {
+    if (!v)
+      continue;
+    if (k === "class" || k === "id" || k === "template" || k === "region")
+      continue;
+    token.attrSet(`data-${k}`, v);
+  }
+}
+function plugin(md, pluginOptions = {}) {
+  const options = {
+    implicitPage: false,
+    preferPagesInSpreads: false,
+    ...pluginOptions
+  };
+  function markerBlock(state, startLine, endLine, silent) {
+    const pos = state.bMarks[startLine] + state.tShift[startLine];
+    const max = state.eMarks[startLine];
+    const line = state.src.slice(pos, max);
+    const parsed = parseMarkerLine(line);
+    if (!parsed)
+      return false;
+    if (silent)
+      return true;
+    state.env.__layoutMarkersUsed = true;
+    const token = state.push("layout_marker", "", 0);
+    token.meta = parsed;
+    token.meta.__line = startLine + 1;
+    if (parsed.__ambiguousBareToken) {
+      delete parsed.__ambiguousBareToken;
+      warn(state.env, startLine + 1, "ambiguous_marker_token", "A bare marker token after a key=value attribute is being interpreted as the marker name (or an extra class). Use comma-separated classes (class=a,b) or .class shorthand instead.", parsed);
+    }
+    state.line = startLine + 1;
+    return true;
+  }
+  md.block.ruler.before("paragraph", "layout_marker", markerBlock, {
+    alt: ["paragraph", "reference", "blockquote", "list"]
+  });
+  const SCOPE_CLOSE_ORDER = ["section", "page", "spread", "chapter"];
+  md.core.ruler.after("block", "layout_transform", function(state) {
+    if (!state.env.__layoutMarkersUsed)
+      return;
+    const out = [];
+    setDepth(state.env, 0);
+    const stack = {
+      frames: [],
+      get(kind) {
+        return this.frames.find((f) => f.kind === kind) || null;
+      },
+      has(kind) {
+        return this.frames.some((f) => f.kind === kind);
+      },
+      open(frame, openToken) {
+        out.push(openToken);
+        this.frames.push(frame);
+      },
+      _pop(kind) {
+        const at = this.frames.findIndex((f) => f.kind === kind);
+        if (at === -1)
+          return;
+        this.frames.splice(at, 1);
+        out.push(new state.Token(`layout_${kind}_close`, "div", -1));
+      },
+      close(kind) {
+        if (!this.has(kind))
+          return;
+        for (const inner of SCOPE_CLOSE_ORDER) {
+          if (inner === kind)
+            break;
+          this._pop(inner);
+        }
+        this._pop(kind);
+      },
+      closeAll() {
+        for (const kind of SCOPE_CLOSE_ORDER)
+          this._pop(kind);
+      }
+    };
+    function openChapter(meta) {
+      const t = new state.Token("layout_chapter_open", "div", 1);
+      const classes = meta.attrs?.class || "";
+      addClasses(t, "chapter", classes);
+      attachDataAttrs(t, "chapter", meta.name, meta.attrs || {});
+      const explicit = (classes.match(/(?:^|\s)(chapter-\d+)(?=\s|$)/) || [])[1] || "";
+      const fromAttr = meta.attrs?.ch ? `chapter-${meta.attrs.ch}` : "";
+      stack.open({
+        kind: "chapter",
+        label: meta.name || "",
+        counterClass: explicit || fromAttr,
+        openerEmitted: false
+      }, t);
+    }
+    function openSpread(meta) {
+      const t = new state.Token("layout_spread_open", "div", 1);
+      addClasses(t, "spread", meta.attrs && meta.attrs.class ? meta.attrs.class : "");
+      attachDataAttrs(t, "spread", meta.name, meta.attrs || {});
+      stack.open({ kind: "spread", noPagesYet: true, sawAnyPage: false }, t);
+    }
+    function openPage(meta) {
+      const chapter = stack.get("chapter");
+      const t = new state.Token("layout_page_open", "div", 1);
+      const explicit = meta.attrs && meta.attrs.class ? meta.attrs.class : "";
+      const counterClass = chapter ? chapter.counterClass : "";
+      const tokens = explicit ? explicit.split(/\s+/) : [];
+      const merged = counterClass && !tokens.includes(counterClass) ? explicit ? `${explicit} ${counterClass}` : counterClass : explicit;
+      addClasses(t, "page", merged);
+      attachDataAttrs(t, "page", meta.name, meta.attrs || {});
+      const label = chapter ? chapter.label : "";
+      if (label)
+        t.attrSet("data-chapter-label", label);
+      stack.open({ kind: "page" }, t);
+      if (label && !chapter.openerEmitted) {
+        const opener = new state.Token("html_block", "", 0);
+        opener.content = `<div class="chapter-opener" data-chapter-label="${escapeAttr(label)}">${escapeHtml(label)}</div>
+`;
+        out.push(opener);
+        chapter.openerEmitted = true;
+      }
+      const spread = stack.get("spread");
+      if (spread) {
+        spread.sawAnyPage = true;
+        spread.noPagesYet = false;
+      } else if (options.preferPagesInSpreads) {
+        warn(state.env, meta.__line || 0, "page_outside_spread", "@page used outside of a spread; allowed, but spreads are recommended for deliberate grouping.", meta);
+      }
+    }
+    function openSection(meta) {
+      const t = new state.Token("layout_section_open", "div", 1);
+      addClasses(t, "section", meta.attrs && meta.attrs.class ? meta.attrs.class : "");
+      attachDataAttrs(t, "section", meta.name, meta.attrs || {});
+      t.meta = { hasColumnBreak: false };
+      stack.open({
+        kind: "section",
+        meta: { name: meta.name || null, attrs: { ...meta.attrs || {} } },
+        openToken: t
+      }, t);
+    }
+    for (let i = 0;i < state.tokens.length; i++) {
+      const tok = state.tokens[i];
+      if (tok.type !== "layout_marker") {
+        out.push(tok);
+        continue;
+      }
+      const meta = tok.meta || {};
+      const kind = meta.kind;
+      const line = meta.__line || 0;
+      if (kind === "chapter") {
+        stack.close("chapter");
+        openChapter(meta);
+        continue;
+      }
+      if (kind === "spread") {
+        if (stack.has("spread")) {
+          warn(state.env, line, "nested_spread", "@spread encountered while another spread is open; closing the previous spread automatically.", meta);
+        }
+        stack.close("spread");
+        openSpread(meta);
+        continue;
+      }
+      if (kind === "page") {
+        stack.close("page");
+        openPage(meta);
+        continue;
+      }
+      if (kind === "section") {
+        stack.close("section");
+        if (!stack.has("page")) {
+          if (options.implicitPage) {
+            warn(state.env, line, "implicit_page", '@section used without an open @page; creating an implicit page wrapper (data-page="auto").', meta);
+            openPage({ name: "auto", attrs: {}, __line: line });
+          } else {
+            warn(state.env, line, "section_without_page", "@section used without an open @page; region will render but will not be wrapped in a page.", meta);
+          }
+        }
+        const spread = stack.get("spread");
+        if (spread && spread.noPagesYet) {
+          warn(state.env, line, "spread_without_pages", "@section inside a spread without an explicit @page. Allowed (adhoc spread), but explicit @page markers give stronger control.", meta);
+        }
+        openSection(meta);
+        continue;
+      }
+      if (kind === "continue") {
+        const section = stack.get("section");
+        if (!section || !section.meta) {
+          warn(state.env, line, "continue_without_section", "@continue used without an open @section; ignoring marker.", meta);
+          continue;
+        }
+        const contMeta = {
+          name: section.meta.name,
+          attrs: { ...section.meta.attrs || {} }
+        };
+        const cls = (contMeta.attrs.class || "").split(/\s+/).filter(Boolean);
+        if (!cls.includes("gutterpress-continued"))
+          cls.push("gutterpress-continued");
+        contMeta.attrs.class = cls.join(" ");
+        stack.close("section");
+        openSection(contMeta);
+        continue;
+      }
+      if (kind === "page-break") {
+        const t = new state.Token("layout_page_break", "div", 0);
+        t.attrSet("class", "md-page-break");
+        t.attrSet("aria-hidden", "true");
+        out.push(t);
+        continue;
+      }
+      if (kind === "column-break") {
+        const openSectionFrame = stack.get("section");
+        if (openSectionFrame && openSectionFrame.openToken && !openSectionFrame.openToken.meta.hasColumnBreak) {
+          const sectionCls = openSectionFrame.openToken.attrGet("class") || "";
+          if (sectionCls.includes("col-split")) {
+            openSectionFrame.openToken.meta.hasColumnBreak = true;
+          }
+        }
+        const t = new state.Token("layout_column_break", "div", 0);
+        t.attrSet("class", "md-column-break");
+        t.attrSet("aria-hidden", "true");
+        out.push(t);
+        continue;
+      }
+      if (kind === "end-section") {
+        stack.close("section");
+        continue;
+      }
+    }
+    const eofSpread = stack.get("spread");
+    if (eofSpread && !eofSpread.sawAnyPage) {
+      warn(state.env, 0, "spread_eof_close", "An open @spread reached end-of-document; closing it automatically.", null);
+    }
+    stack.closeAll();
+    state.tokens = out;
+  });
+  function getDepth(env) {
+    return env && env.__colSplitDepth || 0;
+  }
+  function setDepth(env, n) {
+    if (env)
+      env.__colSplitDepth = n;
+  }
+  md.renderer.rules.layout_chapter_open = (tokens, idx, opts, env, self) => {
+    setDepth(env, 0);
+    return self.renderToken(tokens, idx, opts);
+  };
+  md.renderer.rules.layout_page_open = (tokens, idx, opts, env, self) => {
+    setDepth(env, 0);
+    return self.renderToken(tokens, idx, opts);
+  };
+  md.renderer.rules.layout_section_open = (tokens, idx, opts, env, self) => {
+    const token = tokens[idx];
+    const cls = token.attrGet("class") || "";
+    if (cls.includes("col-split") && token.meta && token.meta.hasColumnBreak) {
+      setDepth(env, getDepth(env) + 1);
+      return `<div class="${escapeAttr(cls)}"><div class="col">
+`;
+    }
+    return self.renderToken(tokens, idx, opts);
+  };
+  md.renderer.rules.layout_section_close = (tokens, idx, opts, env, self) => {
+    if (getDepth(env) > 0) {
+      setDepth(env, getDepth(env) - 1);
+      return `</div></div>
+`;
+    }
+    return self.renderToken(tokens, idx, opts);
+  };
+  md.renderer.rules.layout_page_break = (tokens, idx) => {
+    const cls = tokens[idx].attrGet("class") || "md-page-break";
+    return `<div class="${escapeAttr(cls)}" aria-hidden="true"></div>
+`;
+  };
+  md.renderer.rules.layout_column_break = (tokens, idx, opts, env) => {
+    if (getDepth(env) > 0) {
+      return `</div><div class="col">
+`;
+    }
+    const cls = tokens[idx].attrGet("class") || "md-column-break";
+    return `<div class="${escapeAttr(cls)}" aria-hidden="true"></div>
+`;
+  };
+  md.renderer.rules.layout_marker = () => "";
+}
+var PAGED_CSS = `
+.md-page-break { break-before: page; }
+.page { break-before: page; }
+.spread { break-before: page; }
+.section { break-inside: avoid; }
+.section.col-split { break-inside: auto; }
+.md-column-break { break-after: column; height: 0; font-size: 0; line-height: 0; visibility: hidden; }
+
+.center { display: block; margin-left: auto; margin-right: auto; max-width: 100%; }
+.float-left { float: left; margin: 0 1em 1em 0; max-width: 50%; }
+.float-right { float: right; margin: 0 0 1em 1em; max-width: 50%; }
+.full-width { display: block; width: 100%; max-width: 100%; }
+.full-bleed {
+  display: block;
+  break-before: page;
+  max-width: none;
+  width: calc(100% + var(--pagedjs-margin-left, 0px) + var(--pagedjs-margin-right, 0px));
+  margin-left: calc(-1 * var(--pagedjs-margin-left, 0px));
+  margin-right: calc(-1 * var(--pagedjs-margin-right, 0px));
+}
+`;
+
+// src/lib/markdown/chapter-id.ts
+function canonicalChapterId(p) {
+  let s = String(p).replace(/\\/g, "/");
+  s = s.replace(/\/{2,}/g, "/");
+  while (s.startsWith("./"))
+    s = s.slice(2);
+  return s;
+}
+
+// src/lib/markdown/renderer.ts
+import MarkdownIt from "markdown-it";
+
+// src/utils/logger.ts
+var currentLevel = "INFO";
+var LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+function emit(level, message, ...args) {
+  if (LEVELS[level] < LEVELS[currentLevel])
+    return;
+  const colors = {
+    DEBUG: "\x1B[36m",
+    INFO: "\x1B[32m",
+    WARN: "\x1B[33m",
+    ERROR: "\x1B[31m"
+  };
+  const reset = "\x1B[0m";
+  const timestamp = new Date().toISOString().slice(11, 19);
+  const prefix = `${colors[level]}[${timestamp}] ${level}${reset}:`;
+  if (level === "ERROR") {
+    console.error(prefix, message, ...args);
+  } else {
+    console.log(prefix, message, ...args);
+  }
+}
+function debug(message, ...args) {
+  emit("DEBUG", message, ...args);
+}
+
+// src/lib/markdown/renderer.ts
+import markdownItAttrs from "markdown-it-attrs";
+import markdownItFootnote from "markdown-it-footnote";
+import markdownItSourceMap from "markdown-it-source-map";
+import markdownItDeflist from "markdown-it-deflist";
+import markdownItMark from "markdown-it-mark";
+import markdownItSub from "markdown-it-sub";
+import markdownItSup from "markdown-it-sup";
+import markdownItAbbr from "markdown-it-abbr";
+
+// src/lib/markdown/images.ts
+function registerImageRule(md) {
+  const defaultRender = md.renderer.rules.image ?? ((tokens, idx, options, _env, self) => self.renderToken(tokens, idx, options));
+  md.renderer.rules.image = (tokens, idx, options, env, self) => {
+    const token = tokens[idx];
+    const srcIdx = token.attrIndex("src");
+    if (srcIdx >= 0 && token.attrs) {
+      const src = token.attrs[srcIdx][1];
+      if (src) {
+        const bucket = env ?? {};
+        (bucket.imageRefs ??= []).push(src);
+      }
+    }
+    return defaultRender(tokens, idx, options, env, self);
+  };
+}
+function collectHtmlImageRefs(html) {
+  const refs = [];
+  const srcRe = /<img\b[^>]*?\bsrc\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi;
+  let m;
+  while (m = srcRe.exec(html)) {
+    const src = m[1] ?? m[2] ?? m[3];
+    if (src)
+      refs.push(src);
+  }
+  const srcsetRe = /<(?:img|source)\b[^>]*?\bsrcset\s*=\s*(?:"([^"]*)"|'([^']*)')/gi;
+  while (m = srcsetRe.exec(html)) {
+    const list = m[1] ?? m[2] ?? "";
+    for (const candidate of list.split(",")) {
+      const url = candidate.trim().split(/\s+/)[0];
+      if (url)
+        refs.push(url);
+    }
+  }
+  return refs;
+}
+
+// src/lib/markdown/renderer.ts
+function hasDefaultExport(plugin2) {
+  return !!plugin2 && typeof plugin2 === "object" && "default" in plugin2;
+}
+function unwrapPlugin(plugin2) {
+  return hasDefaultExport(plugin2) ? plugin2.default : plugin2;
+}
+var BUILTIN_OPTIONAL_PLUGINS = {
+  "markdown-it-mark": unwrapPlugin(markdownItMark),
+  "markdown-it-sub": unwrapPlugin(markdownItSub),
+  "markdown-it-sup": unwrapPlugin(markdownItSup),
+  "markdown-it-abbr": unwrapPlugin(markdownItAbbr)
+};
+function createMarkdownRenderer(customPlugins) {
+  const md = new MarkdownIt({
+    html: true,
+    linkify: true,
+    typographer: true
+  });
+  md.use(unwrapPlugin(markdownItAttrs));
+  md.use(unwrapPlugin(markdownItFootnote));
+  md.use(unwrapPlugin(markdownItDeflist));
+  md.use(unwrapPlugin(markdownItSourceMap));
+  md.use(plugin);
+  registerImageRule(md);
+  if (customPlugins && customPlugins.length > 0) {
+    applyPlugins(md, customPlugins);
+  }
+  return md;
+}
+function applyPlugins(md, plugins) {
+  for (const { name, plugin: plugin2, options, metadata } of plugins) {
+    try {
+      md.use(plugin2, options);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to apply plugin "${name}": ${errorMsg}`);
+    }
+    if (metadata?.name) {
+      debug(`Loaded plugin: ${metadata.name} v${metadata.version ?? "?"}`);
+    } else {
+      debug(`Loaded plugin: ${name}`);
+    }
+  }
+}
+function collectPluginCss(plugins) {
+  return plugins.map((p) => p.css).filter((css) => typeof css === "string" && css.length > 0).join(`
+
+`);
+}
+
+// src/lib/pagedjs-marker.ts
+var PAGEDJS_VERSION = "0.4.3";
+var PAGEDJS_POLYFILL_MARKER = "data-pagedjs-polyfill";
+function pagedjsPolyfillTag(version = PAGEDJS_VERSION) {
+  return `<script ${PAGEDJS_POLYFILL_MARKER}="${version}"></script>`;
+}
+function pagedjsPolyfillTagRegex() {
+  return /<script\b[^>]*(?:\bdata-pagedjs-polyfill\b|\bsrc=["'][^"']*paged\.polyfill[^"']*["'])[^>]*>\s*<\/script>/gi;
+}
+
+// src/lib/markdown/assemble.ts
+async function assembleBookHtml(opts) {
+  const title = opts.title ?? "Document";
+  const projectCss = opts.projectCss ?? "";
+  const pluginCss = opts.pluginCss ?? "";
+  const files = opts.files;
+  if (files.length === 0) {
+    throw new Error("No markdown files to render");
+  }
+  const md = createMarkdownRenderer(opts.plugins);
+  let sourceChapter = null;
+  if (opts.wrapChapters) {
+    const renderToken = md.renderer.renderToken.bind(md.renderer);
+    md.renderer.renderToken = (tokens, idx, options) => {
+      const token = tokens[idx];
+      if (sourceChapter !== null && token.level === 0 && token.map !== null && token.type.endsWith("_open")) {
+        token.attrSet("data-chapter-src", sourceChapter);
+      }
+      return renderToken(tokens, idx, options);
+    };
+  }
+  let bodyContent = "";
+  const imageRefs = new Set;
+  for (const file of files) {
+    const chapterId = canonicalChapterId(file);
+    let content;
+    try {
+      content = await opts.readText(chapterId);
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to read file ${file}: ${errorMsg}`);
+    }
+    const env = {};
+    sourceChapter = opts.wrapChapters ? chapterId : null;
+    let rendered;
+    try {
+      rendered = md.render(content, env);
+    } finally {
+      sourceChapter = null;
+    }
+    if (env.layoutWarnings && env.layoutWarnings.length > 0) {
+      opts.onChapterWarnings?.(chapterId, env.layoutWarnings);
+    }
+    for (const ref of env.imageRefs ?? [])
+      imageRefs.add(ref);
+    bodyContent += rendered + `
+`;
+  }
+  if (opts.onImageRefs) {
+    for (const ref of collectHtmlImageRefs(bodyContent))
+      imageRefs.add(ref);
+    opts.onImageRefs([...imageRefs]);
+  }
+  const inlineCss = [
+    `/* markdown-it-paged */
+${PAGED_CSS.trim()}`,
+    pluginCss ? `/* user plugin css */
+${pluginCss.trim()}` : null,
+    projectCss ? `/* project css */
+${projectCss.trim()}` : null
+  ].filter(Boolean).join(`
+
+`);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <style data-project-css>
+${inlineCss}
+</style>
+  ${pagedjsPolyfillTag()}
+</head>
+<body>
+${bodyContent}
+</body>
+</html>`;
+}
+export {
+  pagedjsPolyfillTagRegex,
+  pagedjsPolyfillTag,
+  createMarkdownRenderer,
+  collectPluginCss,
+  assembleBookHtml,
+  applyPlugins,
+  PAGED_CSS,
+  PAGEDJS_VERSION,
+  PAGEDJS_POLYFILL_MARKER
+};