printdown 1.1.1 → 1.2.0

package/dist/{chunk-ZB6NLLOD.js → chunk-BLKOSAAA.js}

@@ -1,11 +1,11 @@
 import {
   defaultThemeCss,
   getFontDir
-} from "./chunk-GEQQR3U7.js";
+} from "./chunk-QYKBYAYW.js";
 
 // src/index.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 
 // src/markdown/index.ts
 import MarkdownIt from "markdown-it";
@@ -595,7 +595,7 @@ function centerPlugin(md) {
 }
 
 // src/markdown/plugins/heading.ts
-var NO_BORDER_ATTR_REGEX = /\s*(?:\{(?:\.|\s)*(?:no-border|no-underline|no-bottom-border|plain|-)\s*\}|\[(?:no-border|no-underline)\]|<!--\s*(?:no-border|no-underline)\s*-->)\s*$/i;
+var HEADING_ATTR_REGEX = /\s*(?:\{(?:\.|\s)*(?:no-border|no-underline|no-bottom-border|plain|-|page-break|pagebreak|break-before)(?:\s+(?:\.|\s)*(?:no-border|no-underline|no-bottom-border|plain|-|page-break|pagebreak|break-before))*\s*\}|\[(?:no-border|no-underline|page-break|pagebreak|break-before)\]|<!--\s*(?:no-border|no-underline|page-break|pagebreak|break-before)\s*-->)\s*$/i;
 function addClass2(token, className) {
   const classIndex = token.attrIndex("class");
   if (classIndex < 0) {
@@ -615,28 +615,35 @@ function addClass2(token, className) {
   }
 }
 function headingPlugin(md) {
-  md.core.ruler.after("inline", "heading_no_border", (state) => {
+  md.core.ruler.after("inline", "heading_attributes", (state) => {
     const tokens = state.tokens;
     for (let i = 0; i < tokens.length; i++) {
       if (tokens[i].type === "heading_open") {
         const inlineToken = tokens[i + 1];
         if (inlineToken && inlineToken.type === "inline") {
-          if (NO_BORDER_ATTR_REGEX.test(inlineToken.content)) {
-            addClass2(tokens[i], "printdown-no-border printdown-no-underline");
-            inlineToken.content = inlineToken.content.replace(NO_BORDER_ATTR_REGEX, "");
+          const match = inlineToken.content.match(HEADING_ATTR_REGEX);
+          if (match) {
+            const attrStr = match[0].toLowerCase();
+            if (attrStr.includes("no-border") || attrStr.includes("no-underline") || attrStr.includes("plain") || attrStr.includes("{-}")) {
+              addClass2(tokens[i], "printdown-no-border printdown-no-underline");
+            }
+            if (attrStr.includes("page-break") || attrStr.includes("pagebreak") || attrStr.includes("break-before")) {
+              addClass2(tokens[i], "printdown-page-break");
+            }
+            inlineToken.content = inlineToken.content.replace(HEADING_ATTR_REGEX, "");
             if (inlineToken.children && inlineToken.children.length > 0) {
               for (let j = inlineToken.children.length - 1; j >= 0; j--) {
                 const child = inlineToken.children[j];
                 if (child.type === "text") {
-                  if (NO_BORDER_ATTR_REGEX.test(child.content)) {
-                    child.content = child.content.replace(NO_BORDER_ATTR_REGEX, "");
+                  if (HEADING_ATTR_REGEX.test(child.content)) {
+                    child.content = child.content.replace(HEADING_ATTR_REGEX, "");
                     if (child.content === "") {
                       inlineToken.children.splice(j, 1);
                     }
                     break;
                   }
                 } else if (child.type === "html_inline") {
-                  if (child.content.includes("no-border") || child.content.includes("no-underline")) {
+                  if (child.content.includes("no-border") || child.content.includes("no-underline") || child.content.includes("page-break") || child.content.includes("pagebreak") || child.content.includes("break-before")) {
                     inlineToken.children.splice(j, 1);
                     break;
                   }
@@ -647,26 +654,441 @@ function headingPlugin(md) {
         }
       } else if (tokens[i].type === "html_block") {
         tokens[i].content = tokens[i].content.replace(
-          /<(h[1-6])(\s+[^>]*)?(?:\s+(?:no-border|no-underline))\s*([^>]*)>/gi,
+          /<(h[1-6])(\s+[^>]*)?(?:\s+(?:no-border|no-underline|page-break|pagebreak|break-before))\s*([^>]*)>/gi,
           (match, tag, before, after) => {
             const combinedAttrs = `${before || ""} ${after || ""}`.trim();
+            const classesToAdd = [];
+            if (match.includes("no-border") || match.includes("no-underline")) {
+              classesToAdd.push("printdown-no-border printdown-no-underline");
+            }
+            if (match.includes("page-break") || match.includes("pagebreak") || match.includes("break-before")) {
+              classesToAdd.push("printdown-page-break");
+            }
+            const classString = classesToAdd.join(" ");
             if (combinedAttrs.includes('class="') || combinedAttrs.includes("class='")) {
               return `<${tag} ${combinedAttrs.replace(
                 /class=(["'])(.*?)\1/,
-                "class=$1$2 printdown-no-border printdown-no-underline$1"
+                `class=$1$2 ${classString}$1`
               )}>`;
             }
-            return `<${tag} class="printdown-no-border printdown-no-underline" ${combinedAttrs}>`.replace(
-              /\s+>/,
-              ">"
-            );
+            return `<${tag} class="${classString}" ${combinedAttrs}>`.replace(/\s+>/, ">");
+          }
+        );
+      }
+    }
+  });
+}
+
+// src/markdown/plugins/page-break.ts
+var PAGE_BREAK_LINE_REGEX = /^(?:<!--\s*(?:pagebreak|page-break|newpage|break)\s*-->|\\(?:pagebreak|newpage)|\[(?:pagebreak|page-break|newpage)\]|<(?:pagebreak|page-break|newpage)(?:\s*\/?)>)$/i;
+var PAGE_BREAK_MATCH_REGEX = /(?:<!--\s*(?:pagebreak|page-break|newpage|break)\s*-->|\\(?:pagebreak|newpage)|\[(?:pagebreak|page-break|newpage)\]|<(?:pagebreak|page-break|newpage)(?:\s*\/?)>)/gi;
+function pageBreakPlugin(md) {
+  function blockPageBreakRule(state, startLine, endLine, silent) {
+    const startPos = state.bMarks[startLine] + state.tShift[startLine];
+    const maxPos = state.eMarks[startLine];
+    const lineText = state.src.slice(startPos, maxPos).trim();
+    if (PAGE_BREAK_LINE_REGEX.test(lineText)) {
+      if (silent) return true;
+      const token = state.push("html_block", "", 0);
+      token.content = '<div class="printdown-page-break"></div>\n';
+      token.map = [startLine, startLine + 1];
+      state.line = startLine + 1;
+      return true;
+    }
+    if (/^:::\s*(?:pagebreak|page-break|newpage)\s*$/i.test(lineText)) {
+      if (silent) return true;
+      let nextLine = startLine + 1;
+      while (nextLine < endLine) {
+        const pos = state.bMarks[nextLine] + state.tShift[nextLine];
+        const max = state.eMarks[nextLine];
+        const curLine = state.src.slice(pos, max).trim();
+        if (/^:::\s*$/.test(curLine)) {
+          break;
+        }
+        nextLine++;
+      }
+      const token = state.push("html_block", "", 0);
+      token.content = '<div class="printdown-page-break"></div>\n';
+      token.map = [startLine, nextLine + 1];
+      state.line = nextLine < endLine ? nextLine + 1 : nextLine;
+      return true;
+    }
+    return false;
+  }
+  md.block.ruler.before("hr", "page_break", blockPageBreakRule);
+  md.core.ruler.after("inline", "page_break_tags", (state) => {
+    const tokens = state.tokens;
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token.type === "html_block") {
+        if (PAGE_BREAK_MATCH_REGEX.test(token.content)) {
+          token.content = token.content.replace(
+            PAGE_BREAK_MATCH_REGEX,
+            '<div class="printdown-page-break"></div>'
+          );
+        }
+      } else if (token.type === "paragraph_open") {
+        const inlineToken = tokens[i + 1];
+        if (inlineToken && inlineToken.type === "inline") {
+          const content = inlineToken.content.trim();
+          if (PAGE_BREAK_LINE_REGEX.test(content)) {
+            tokens[i].type = "html_block";
+            tokens[i].tag = "";
+            tokens[i].content = '<div class="printdown-page-break"></div>\n';
+            tokens[i].children = null;
+            tokens.splice(i + 1, 2);
+          }
+        }
+      } else if (token.type === "inline" && token.children) {
+        for (let j = 0; j < token.children.length; j++) {
+          const child = token.children[j];
+          if (child.type === "html_inline" || child.type === "text") {
+            if (PAGE_BREAK_MATCH_REGEX.test(child.content)) {
+              child.type = "html_inline";
+              child.content = child.content.replace(
+                PAGE_BREAK_MATCH_REGEX,
+                '<div class="printdown-page-break"></div>'
+              );
+            }
+          }
+        }
+      }
+    }
+  });
+}
+
+// src/markdown/plugins/cover.ts
+var COVER_CONTAINER_START_REGEX = /^:::\s*cover(?:\s+([a-zA-Z0-9_-]+))?\s*$/i;
+var COVER_TAG_OPEN_REGEX = /^<cover(?:\s+variant=["']?([a-zA-Z0-9_-]+)["']?)?(?:\s+class=["']?([^"'>]*)["']?)?[^>]*>$/i;
+var COVER_TAG_CLOSE_REGEX = /^<\/cover>$/i;
+function coverPlugin(md) {
+  function blockCoverRule(state, startLine, endLine, silent) {
+    const startPos = state.bMarks[startLine] + state.tShift[startLine];
+    const maxPos = state.eMarks[startLine];
+    const lineText = state.src.slice(startPos, maxPos).trim();
+    if (/^:::\s*(?:cover-meta|cover-footer)\s*$/i.test(lineText)) {
+      if (silent) return true;
+      let nextLine = startLine + 1;
+      let foundEnd = false;
+      while (nextLine < endLine) {
+        const pos = state.bMarks[nextLine] + state.tShift[nextLine];
+        const max = state.eMarks[nextLine];
+        const curLine = state.src.slice(pos, max).trim();
+        if (/^:::\s*$/.test(curLine) || /^:::\s*(?:cover-meta|cover-footer)\s*$/i.test(curLine)) {
+          foundEnd = true;
+          break;
+        }
+        nextLine++;
+      }
+      const tokenOpen = state.push("cover_meta_open", "div", 1);
+      tokenOpen.attrs = [["class", "printdown-cover-meta"]];
+      tokenOpen.block = true;
+      const oldParentType = state.parentType;
+      state.parentType = "root";
+      state.md.block.tokenize(state, startLine + 1, nextLine);
+      state.parentType = oldParentType;
+      const tokenClose = state.push("cover_meta_close", "div", -1);
+      tokenClose.block = true;
+      state.line = foundEnd ? nextLine + 1 : nextLine;
+      return true;
+    }
+    const coverMatch = lineText.match(COVER_CONTAINER_START_REGEX);
+    if (coverMatch) {
+      if (silent) return true;
+      const variant = coverMatch[1] ? coverMatch[1].toLowerCase() : "default";
+      let nextLine = startLine + 1;
+      let foundEnd = false;
+      let depth = 1;
+      while (nextLine < endLine) {
+        const pos = state.bMarks[nextLine] + state.tShift[nextLine];
+        const max = state.eMarks[nextLine];
+        const curLine = state.src.slice(pos, max).trim();
+        if (/^:::\s*[a-zA-Z0-9_-]+\s*$/i.test(curLine)) {
+          depth++;
+        } else if (/^:::\s*$/i.test(curLine)) {
+          depth--;
+          if (depth === 0) {
+            foundEnd = true;
+            break;
+          }
+        } else if (/^:::\s*cover\s*$/i.test(curLine)) {
+          depth--;
+          if (depth <= 0) {
+            foundEnd = true;
+            break;
+          }
+        }
+        nextLine++;
+      }
+      const tokenOpen = state.push("cover_open", "div", 1);
+      const classNames = ["printdown-cover", `printdown-cover-${variant}`];
+      tokenOpen.attrs = [["class", classNames.join(" ")]];
+      tokenOpen.block = true;
+      const oldParentType = state.parentType;
+      state.parentType = "root";
+      state.md.block.tokenize(state, startLine + 1, nextLine);
+      state.parentType = oldParentType;
+      const tokenClose = state.push("cover_close", "div", -1);
+      tokenClose.block = true;
+      state.line = foundEnd ? nextLine + 1 : nextLine;
+      return true;
+    }
+    return false;
+  }
+  md.block.ruler.before("fence", "cover_block", blockCoverRule);
+  md.core.ruler.after("inline", "cover_tags", (state) => {
+    const tokens = state.tokens;
+    function processToken(token) {
+      if (token.type === "html_inline") {
+        const trimmed = token.content.trim();
+        const openMatch = trimmed.match(COVER_TAG_OPEN_REGEX);
+        if (openMatch) {
+          const variant = openMatch[1] ? openMatch[1].toLowerCase() : "default";
+          const extraClass = openMatch[2] ? ` ${openMatch[2]}` : "";
+          token.content = `<div class="printdown-cover printdown-cover-${variant}${extraClass}">`;
+        } else if (COVER_TAG_CLOSE_REGEX.test(trimmed)) {
+          token.content = "</div>";
+        }
+      } else if (token.type === "html_block") {
+        token.content = token.content.replace(
+          /<cover(?:\s+variant=["']?([a-zA-Z0-9_-]+)["']?)?(?:\s+class=["']?([^"'>]*)["']?)?[^>]*>([\s\S]*?)<\/cover>/gi,
+          (_, variant, customClass, body) => {
+            const v = variant ? variant.toLowerCase() : "default";
+            const extra = customClass ? ` ${customClass}` : "";
+            const rendered = md.render(body.trim()).trim();
+            return `<div class="printdown-cover printdown-cover-${v}${extra}">
+${rendered}
+</div>`;
           }
         );
       }
     }
+    for (let i = 0; i < tokens.length; i++) {
+      processToken(tokens[i]);
+      if (tokens[i].children) {
+        for (const child of tokens[i].children) {
+          processToken(child);
+        }
+      }
+    }
   });
 }
 
+// src/markdown/plugins/math.ts
+import katex from "katex";
+function mathPlugin(md, options = {}) {
+  const defaultKatexOptions = {
+    throwOnError: false,
+    output: "htmlAndMathml",
+    ...options.katexOptions
+  };
+  function inlineMathRule(state, silent) {
+    const start = state.pos;
+    const max = state.posMax;
+    const src = state.src;
+    if (start > 0 && src.charCodeAt(start - 1) === 92) {
+      return false;
+    }
+    const firstChar = src.charCodeAt(start);
+    if (firstChar === 92 && src.charCodeAt(start + 1) === 40) {
+      let matchEnd = -1;
+      let pos = start + 2;
+      while (pos < max - 1) {
+        if (src.charCodeAt(pos) === 92 && src.charCodeAt(pos + 1) === 41) {
+          matchEnd = pos;
+          break;
+        }
+        pos++;
+      }
+      if (matchEnd === -1) return false;
+      if (!silent) {
+        const content = src.slice(start + 2, matchEnd).trim();
+        const token = state.push("math_inline", "math", 0);
+        token.content = content;
+        token.meta = { displayMode: false };
+      }
+      state.pos = matchEnd + 2;
+      return true;
+    }
+    if (firstChar === 36) {
+      const isDouble = src.charCodeAt(start + 1) === 36;
+      const delimiterLength = isDouble ? 2 : 1;
+      if (!isDouble) {
+        const nextChar = src.charCodeAt(start + 1);
+        if (nextChar === 32 || nextChar === 9 || nextChar === 10 || nextChar === 13 || isNaN(nextChar)) {
+          return false;
+        }
+      }
+      let matchEnd = -1;
+      let pos = start + delimiterLength;
+      while (pos < max) {
+        if (src.charCodeAt(pos) === 92) {
+          pos += 2;
+          continue;
+        }
+        if (isDouble) {
+          if (src.charCodeAt(pos) === 36 && src.charCodeAt(pos + 1) === 36) {
+            matchEnd = pos;
+            break;
+          }
+        } else {
+          if (src.charCodeAt(pos) === 36) {
+            const prevChar = src.charCodeAt(pos - 1);
+            if (prevChar !== 32 && prevChar !== 9 && prevChar !== 10 && prevChar !== 13) {
+              const nextChar = src.charCodeAt(pos + 1);
+              if (isNaN(nextChar) || nextChar < 48 || nextChar > 57) {
+                matchEnd = pos;
+                break;
+              }
+            }
+          }
+        }
+        pos++;
+      }
+      if (matchEnd === -1) return false;
+      const content = src.slice(start + delimiterLength, matchEnd).trim();
+      if (content.length === 0) return false;
+      if (!silent) {
+        const token = state.push(isDouble ? "math_block" : "math_inline", "math", 0);
+        token.content = content;
+        token.meta = { displayMode: isDouble };
+      }
+      state.pos = matchEnd + delimiterLength;
+      return true;
+    }
+    return false;
+  }
+  function blockMathRule(state, startLine, endLine, silent) {
+    const startPos = state.bMarks[startLine] + state.tShift[startLine];
+    const maxPos = state.eMarks[startLine];
+    const lineText = state.src.slice(startPos, maxPos).trim();
+    const containerMatch = lineText.match(/^:::\s*(math|latex|tex|katex)\s*$/i);
+    if (containerMatch) {
+      if (silent) return true;
+      let nextLine = startLine + 1;
+      let foundEnd = false;
+      while (nextLine < endLine) {
+        const pos = state.bMarks[nextLine] + state.tShift[nextLine];
+        const max = state.eMarks[nextLine];
+        const curLine = state.src.slice(pos, max).trim();
+        if (/^:::\s*$/.test(curLine) || /^:::\s*(math|latex|tex|katex)\s*$/i.test(curLine)) {
+          foundEnd = true;
+          break;
+        }
+        nextLine++;
+      }
+      const contentLines = [];
+      for (let l = startLine + 1; l < nextLine; l++) {
+        const pos = state.bMarks[l] + state.tShift[l];
+        const max = state.eMarks[l];
+        contentLines.push(state.src.slice(pos, max));
+      }
+      const token = state.push("math_block", "math", 0);
+      token.block = true;
+      token.content = contentLines.join("\n").trim();
+      token.meta = { displayMode: true };
+      state.line = foundEnd ? nextLine + 1 : nextLine;
+      return true;
+    }
+    if (lineText.startsWith("$$")) {
+      if (lineText.length > 2 && lineText.endsWith("$$")) {
+        if (silent) return true;
+        const mathContent = lineText.slice(2, -2).trim();
+        const token2 = state.push("math_block", "math", 0);
+        token2.block = true;
+        token2.content = mathContent;
+        token2.meta = { displayMode: true };
+        state.line = startLine + 1;
+        return true;
+      }
+      if (silent) return true;
+      const firstLineContent = lineText.slice(2).trim();
+      const contentLines = [];
+      if (firstLineContent) {
+        contentLines.push(firstLineContent);
+      }
+      let nextLine = startLine + 1;
+      let foundEnd = false;
+      while (nextLine < endLine) {
+        const pos = state.bMarks[nextLine] + state.tShift[nextLine];
+        const max = state.eMarks[nextLine];
+        const curLine = state.src.slice(pos, max).trim();
+        if (curLine.endsWith("$$")) {
+          foundEnd = true;
+          const lastLineContent = curLine.slice(0, -2).trim();
+          if (lastLineContent) {
+            contentLines.push(lastLineContent);
+          }
+          break;
+        }
+        contentLines.push(state.src.slice(pos, max));
+        nextLine++;
+      }
+      const token = state.push("math_block", "math", 0);
+      token.block = true;
+      token.content = contentLines.join("\n").trim();
+      token.meta = { displayMode: true };
+      state.line = foundEnd ? nextLine + 1 : nextLine;
+      return true;
+    }
+    return false;
+  }
+  md.inline.ruler.before("escape", "math_inline", inlineMathRule);
+  md.block.ruler.before("fence", "math_block", blockMathRule);
+  const originalFence = md.renderer.rules.fence;
+  md.renderer.rules.fence = (tokens, idx, opt, env, self) => {
+    const token = tokens[idx];
+    const info = token.info ? token.info.trim().toLowerCase() : "";
+    if (info === "math" || info === "latex" || info === "tex" || info === "katex") {
+      try {
+        const rendered = katex.renderToString(token.content.trim(), {
+          ...defaultKatexOptions,
+          displayMode: true
+        });
+        return `<div class="printdown-math-block katex-display">${rendered}</div>
+`;
+      } catch (err) {
+        const errMessage = err instanceof Error ? err.message : String(err);
+        return `<div class="printdown-math-block katex-display"><span class="katex-error">${errMessage}</span></div>
+`;
+      }
+    }
+    if (originalFence) {
+      return originalFence(tokens, idx, opt, env, self);
+    }
+    return self.renderToken(tokens, idx, opt);
+  };
+  md.renderer.rules.math_inline = (tokens, idx) => {
+    const token = tokens[idx];
+    try {
+      const rendered = katex.renderToString(token.content, {
+        ...defaultKatexOptions,
+        displayMode: false
+      });
+      return `<span class="printdown-math-inline">${rendered}</span>`;
+    } catch (err) {
+      const errMessage = err instanceof Error ? err.message : String(err);
+      return `<span class="printdown-math-inline katex-error">${errMessage}</span>`;
+    }
+  };
+  md.renderer.rules.math_block = (tokens, idx) => {
+    const token = tokens[idx];
+    const displayMode = token.meta?.displayMode !== false;
+    try {
+      const rendered = katex.renderToString(token.content, {
+        ...defaultKatexOptions,
+        displayMode
+      });
+      return `<div class="printdown-math-block katex-display">${rendered}</div>
+`;
+    } catch (err) {
+      const errMessage = err instanceof Error ? err.message : String(err);
+      return `<div class="printdown-math-block katex-display"><span class="katex-error">${errMessage}</span></div>
+`;
+    }
+  };
+}
+
 // src/markdown/index.ts
 var DEFAULT_LANGS = [
   "javascript",
@@ -743,14 +1165,22 @@ async function createMarkdownRenderer(options = {}) {
   md.use(kbdPlugin);
   md.use(centerPlugin);
   md.use(headingPlugin);
+  md.use(pageBreakPlugin);
+  md.use(coverPlugin);
+  md.use(mathPlugin, { katexOptions: options.katex });
   const highlighter = await getHighlighter(options.shiki);
   const theme = options.shiki?.theme || DEFAULT_THEME;
   const defaultFence = md.renderer.rules.fence;
   md.renderer.rules.fence = (tokens, idx, fenceOptions, env, self) => {
     const token = tokens[idx];
     const info = token.info ? token.info.trim() : "";
-    const lang = info ? info.split(/\s+/)[0] : "text";
+    const lang = info ? info.split(/\s+/)[0].toLowerCase() : "text";
     const code = token.content;
+    if (lang === "math" || lang === "latex" || lang === "tex" || lang === "katex") {
+      if (defaultFence) {
+        return defaultFence(tokens, idx, fenceOptions, env, self);
+      }
+    }
     try {
       const loadedLangs = highlighter.getLoadedLanguages();
       const targetLang = loadedLangs.includes(lang) ? lang : "text";
@@ -781,11 +1211,79 @@ async function createMarkdownRenderer(options = {}) {
 import fs from "fs";
 import path from "path";
 import { chromium } from "playwright";
+
+// src/renderer/header-footer.ts
+var DEFAULT_FONT_STYLE = 'font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; font-size: 8pt; color: #64748b; width: 100%; padding: 0 18mm; box-sizing: border-box; -webkit-print-color-adjust: exact;';
+function replacePlaceholdersWithHtml(str) {
+  return str.replace(/\{page\}/gi, '<span class="pageNumber"></span>').replace(/\{(?:total|totalPages)\}/gi, '<span class="totalPages"></span>').replace(/\{date\}/gi, '<span class="date"></span>').replace(/\{title\}/gi, '<span class="title"></span>');
+}
+function buildHeaderFooterHtml(content, type) {
+  const text = typeof content === "boolean" ? type === "header" ? "{title}" : "{page} / {total}" : content.trim();
+  const parts = text.split("|").map((p) => replacePlaceholdersWithHtml(p.trim()));
+  let innerHtml;
+  if (parts.length === 1) {
+    const isCentered = type === "footer" || text.includes("{page}") || text.includes("{total}") || text.includes('<span class="pageNumber">');
+    innerHtml = `<div style="display: flex; justify-content: ${isCentered ? "center" : "space-between"}; width: 100%; align-items: center;"><span>${parts[0]}</span></div>`;
+  } else if (parts.length === 2) {
+    innerHtml = `<div style="display: flex; justify-content: space-between; width: 100%; align-items: center;"><span>${parts[0]}</span><span>${parts[1]}</span></div>`;
+  } else {
+    innerHtml = `<div style="display: flex; justify-content: space-between; width: 100%; align-items: center;"><span style="flex: 1; text-align: left;">${parts[0]}</span><span style="flex: 1; text-align: center;">${parts[1]}</span><span style="flex: 1; text-align: right;">${parts[2]}</span></div>`;
+  }
+  return `<div style="${DEFAULT_FONT_STYLE}">${innerHtml}</div>`;
+}
+function resolveHeaderFooterPdfOptions(options) {
+  const hasHeader = Boolean(options.header || options.headerTemplate);
+  const hasPageNumber = Boolean(options.pageNumber);
+  const hasFooter = Boolean(options.footer || options.footerTemplate || hasPageNumber);
+  const shouldDisplay = options.displayHeaderFooter ?? (hasHeader || hasFooter);
+  if (!shouldDisplay) {
+    return {};
+  }
+  let headerTemplate = options.headerTemplate;
+  if (!headerTemplate && options.header) {
+    headerTemplate = buildHeaderFooterHtml(options.header, "header");
+  }
+  if (!headerTemplate) {
+    headerTemplate = '<span style="font-size: 0px;"></span>';
+  }
+  let footerTemplate = options.footerTemplate;
+  if (!footerTemplate) {
+    if (options.footer) {
+      footerTemplate = buildHeaderFooterHtml(options.footer, "footer");
+    } else if (options.pageNumber) {
+      const pageFormat = typeof options.pageNumber === "string" ? options.pageNumber : "{page} / {total}";
+      footerTemplate = buildHeaderFooterHtml(pageFormat, "footer");
+    }
+  }
+  if (!footerTemplate) {
+    footerTemplate = '<span style="font-size: 0px;"></span>';
+  }
+  return {
+    displayHeaderFooter: true,
+    headerTemplate,
+    footerTemplate,
+    margin: {
+      top: "20mm",
+      bottom: "20mm",
+      left: "18mm",
+      right: "18mm"
+    }
+  };
+}
+function formatHeaderFooterCanvasText(content, pageIndex, totalPages, docTitle) {
+  const text = typeof content === "boolean" ? "{page} / {total}" : content;
+  const today = (/* @__PURE__ */ new Date()).toLocaleDateString();
+  const title = docTitle || "";
+  return text.replace(/\{page\}/gi, String(pageIndex)).replace(/\{(?:total|totalPages)\}/gi, String(totalPages)).replace(/\{date\}/gi, today).replace(/\{title\}/gi, title);
+}
+
+// src/renderer/index.ts
 async function setupFontRouting(context) {
   const interDir = getFontDir("@fontsource-variable/inter/index.css");
   const notoDir = getFontDir("@fontsource-variable/noto-sans-jp/index.css");
   const jbDir = getFontDir("@fontsource-variable/jetbrains-mono/index.css");
   const genDir = getFontDir("gen-interface-jp/500.css");
+  const katexDir = getFontDir("katex/dist/katex.min.css");
   await context.route("https://printdown.local/fonts/**", async (route) => {
     const reqUrl = route.request().url();
     let filePath = "";
@@ -813,13 +1311,20 @@ async function setupFontRouting(context) {
         "w",
         reqUrl.replace("https://printdown.local/fonts/gen-interface-jp/w/", "")
       );
+    } else if (katexDir && reqUrl.startsWith("https://printdown.local/fonts/katex/")) {
+      filePath = path.join(
+        katexDir,
+        "fonts",
+        reqUrl.replace("https://printdown.local/fonts/katex/", "")
+      );
     }
     if (filePath && fs.existsSync(filePath)) {
       try {
         const body = fs.readFileSync(filePath);
+        const contentType = filePath.endsWith(".woff2") ? "font/woff2" : filePath.endsWith(".woff") ? "font/woff" : filePath.endsWith(".ttf") ? "font/ttf" : "font/woff2";
         await route.fulfill({
           status: 200,
-          contentType: "font/woff2",
+          contentType,
           body
         });
         return;
@@ -906,9 +1411,11 @@ var BrowserRenderer = class {
     );
     try {
       if (format === "pdf") {
+        const headerFooterOptions = resolveHeaderFooterPdfOptions(options);
         const pdfBuffer = await page.pdf({
           printBackground: true,
           preferCSSPageSize: true,
+          ...headerFooterOptions,
           ...options.pdf
         });
         return Buffer.from(pdfBuffer);
@@ -962,8 +1469,14 @@ var BrowserRenderer = class {
     const deviceScaleFactor = options.scale ?? options.deviceScaleFactor ?? 2;
     const pagesHtml = html.includes("</head>") ? html.replace(
       "</head>",
-      "<style>.printdown { padding-top: 0 !important; padding-bottom: 0 !important; }</style></head>"
-    ) : html + "<style>.printdown { padding-top: 0 !important; padding-bottom: 0 !important; }</style>";
+      `<style>
+            .printdown { padding-top: 0 !important; padding-bottom: 0 !important; }
+            .printdown .printdown-cover, .printdown cover { min-height: ${contentHeightPerPage}px !important; height: ${contentHeightPerPage}px !important; margin: 0 !important; }
+          </style></head>`
+    ) : html + `<style>
+          .printdown { padding-top: 0 !important; padding-bottom: 0 !important; }
+          .printdown .printdown-cover, .printdown cover { min-height: ${contentHeightPerPage}px !important; height: ${contentHeightPerPage}px !important; margin: 0 !important; }
+        </style>`;
     const { browser, context, page, isLocalBrowser } = await this.preparePage(
       pagesHtml,
       width,
@@ -972,10 +1485,112 @@ var BrowserRenderer = class {
     );
     let composePage = null;
     try {
+      const pageSlices = await page.evaluate((maxPageH) => {
+        const totalH = Math.max(document.documentElement.scrollHeight, document.body.scrollHeight);
+        const selectors = [
+          "h1",
+          "h2",
+          "h3",
+          "h4",
+          "h5",
+          "h6",
+          "p",
+          "ul > li",
+          "ol > li",
+          ".printdown-task-list-item",
+          "blockquote",
+          "table",
+          "tr",
+          "pre",
+          ".printdown-cover",
+          "cover",
+          ".printdown-page-break",
+          ".page-break",
+          ".break-before",
+          ".break-after"
+        ];
+        const elements = Array.from(document.querySelectorAll(selectors.join(",")));
+        const items = [];
+        for (const el of elements) {
+          const rect = el.getBoundingClientRect();
+          const top = rect.top + window.scrollY;
+          const bottom = rect.bottom + window.scrollY;
+          const isForcedBreak = el.classList.contains("printdown-page-break") || el.classList.contains("page-break") || el.classList.contains("break-before") || window.getComputedStyle(el).breakBefore === "page" || window.getComputedStyle(el).pageBreakBefore === "always";
+          const isForcedAfterBreak = el.classList.contains("printdown-cover") || el.tagName.toLowerCase() === "cover" || el.classList.contains("break-after") || el.classList.contains("printdown-break-after") || window.getComputedStyle(el).breakAfter === "page" || window.getComputedStyle(el).pageBreakAfter === "always";
+          if (rect.height > 0 || isForcedBreak || isForcedAfterBreak) {
+            items.push({ top, bottom, isForcedBreak, isForcedAfterBreak });
+          }
+        }
+        items.sort((a, b) => a.top - b.top);
+        const headings = Array.from(
+          document.querySelectorAll("h1, h2, h3, h4, h5, h6")
+        ).map((h) => {
+          const rect = h.getBoundingClientRect();
+          return {
+            top: rect.top + window.scrollY,
+            bottom: rect.bottom + window.scrollY
+          };
+        });
+        const slices = [];
+        let currentY = 0;
+        while (currentY < totalH - 5) {
+          const idealBottom = currentY + maxPageH;
+          if (idealBottom >= totalH) {
+            slices.push({ y: currentY, h: totalH - currentY });
+            break;
+          }
+          const forcedAfterBreak = items.find(
+            (item) => item.isForcedAfterBreak && item.bottom > currentY && item.top >= currentY - 5
+          );
+          if (forcedAfterBreak && forcedAfterBreak.bottom > currentY) {
+            slices.push({ y: currentY, h: Math.max(20, forcedAfterBreak.bottom - currentY) });
+            currentY = forcedAfterBreak.bottom;
+            continue;
+          }
+          const forcedBreak = items.find(
+            (item) => item.isForcedBreak && item.top > currentY + 10 && item.top <= idealBottom
+          );
+          if (forcedBreak) {
+            slices.push({ y: currentY, h: Math.max(20, forcedBreak.top - currentY) });
+            currentY = forcedBreak.top;
+            continue;
+          }
+          let bestBreakY = idealBottom;
+          let foundGoodBreak = false;
+          const orphanHeading = headings.find(
+            (h) => h.top > currentY + 50 && h.top <= idealBottom && idealBottom - h.top < 80
+          );
+          if (orphanHeading) {
+            bestBreakY = orphanHeading.top;
+            foundGoodBreak = true;
+          } else {
+            for (let i = items.length - 1; i >= 0; i--) {
+              const item = items[i];
+              if (item.top > currentY + 40 && item.top <= idealBottom) {
+                if (item.bottom > idealBottom) {
+                  bestBreakY = item.top;
+                  foundGoodBreak = true;
+                  break;
+                } else if (idealBottom - item.bottom <= 50) {
+                  bestBreakY = item.bottom;
+                  foundGoodBreak = true;
+                  break;
+                }
+              }
+            }
+          }
+          if (!foundGoodBreak || bestBreakY <= currentY + 50) {
+            bestBreakY = idealBottom;
+          }
+          slices.push({ y: currentY, h: bestBreakY - currentY });
+          currentY = bestBreakY;
+        }
+        return slices.length > 0 ? slices : [{ y: 0, h: totalH }];
+      }, contentHeightPerPage);
       const totalContentHeight = await page.evaluate(
         () => Math.max(document.documentElement.scrollHeight, document.body.scrollHeight)
       );
-      const pageCount = Math.max(1, Math.ceil(totalContentHeight / contentHeightPerPage));
+      const pageCount = pageSlices.length;
       await page.setViewportSize({
         width,
         height: Math.max(totalContentHeight + 100, pageHeight)
@@ -1003,10 +1618,35 @@ var BrowserRenderer = class {
       const pageBuffers = [];
       const imageType = format === "jpeg" ? "jpeg" : format === "webp" ? "webp" : "png";
       for (let i = 0; i < pageCount; i++) {
-        const srcY = i * contentHeightPerPage;
-        const srcH = Math.min(contentHeightPerPage, totalContentHeight - srcY);
+        const slice = pageSlices[i];
+        const srcY = slice.y;
+        const srcH = slice.h;
+        const headerText = options.header ? formatHeaderFooterCanvasText(
+          options.header === true ? options.title || "" : options.header,
+          i + 1,
+          pageCount,
+          options.title
+        ) : "";
+        const footerContent = options.footer || options.pageNumber;
+        const footerText = footerContent ? formatHeaderFooterCanvasText(
+          typeof footerContent === "boolean" ? "{page} / {total}" : footerContent,
+          i + 1,
+          pageCount,
+          options.title
+        ) : "";
         await composePage.evaluate(
-          async ({ base64, width: width2, marginTop: marginTop2, srcY: srcY2, srcH: srcH2, scale }) => {
+          async ({
+            base64,
+            width: width2,
+            pageHeight: pageHeight2,
+            marginTop: marginTop2,
+            marginBottom: marginBottom2,
+            srcY: srcY2,
+            srcH: srcH2,
+            scale,
+            headerText: headerText2,
+            footerText: footerText2
+          }) => {
             const canvas = document.getElementById("canvas");
             const ctx = canvas.getContext("2d");
             if (!ctx) return;
@@ -1028,14 +1668,66 @@ var BrowserRenderer = class {
               width2 * scale,
               srcH2 * scale
             );
+            if (headerText2) {
+              ctx.font = `${9 * scale}px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif`;
+              ctx.fillStyle = "#64748b";
+              ctx.textBaseline = "middle";
+              const parts = headerText2.split("|").map((s) => s.trim());
+              const paddingX = 18 / 210 * width2 * scale;
+              const y = marginTop2 * scale / 2;
+              if (parts.length === 1) {
+                ctx.textAlign = "center";
+                ctx.fillText(parts[0], width2 * scale / 2, y);
+              } else if (parts.length === 2) {
+                ctx.textAlign = "left";
+                ctx.fillText(parts[0], paddingX, y);
+                ctx.textAlign = "right";
+                ctx.fillText(parts[1], width2 * scale - paddingX, y);
+              } else {
+                ctx.textAlign = "left";
+                ctx.fillText(parts[0], paddingX, y);
+                ctx.textAlign = "center";
+                ctx.fillText(parts[1], width2 * scale / 2, y);
+                ctx.textAlign = "right";
+                ctx.fillText(parts[2], width2 * scale - paddingX, y);
+              }
+            }
+            if (footerText2) {
+              ctx.font = `${9 * scale}px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif`;
+              ctx.fillStyle = "#64748b";
+              ctx.textBaseline = "middle";
+              const parts = footerText2.split("|").map((s) => s.trim());
+              const paddingX = 18 / 210 * width2 * scale;
+              const y = (pageHeight2 - marginBottom2 / 2) * scale;
+              if (parts.length === 1) {
+                ctx.textAlign = "center";
+                ctx.fillText(parts[0], width2 * scale / 2, y);
+              } else if (parts.length === 2) {
+                ctx.textAlign = "left";
+                ctx.fillText(parts[0], paddingX, y);
+                ctx.textAlign = "right";
+                ctx.fillText(parts[1], width2 * scale - paddingX, y);
+              } else {
+                ctx.textAlign = "left";
+                ctx.fillText(parts[0], paddingX, y);
+                ctx.textAlign = "center";
+                ctx.fillText(parts[1], width2 * scale / 2, y);
+                ctx.textAlign = "right";
+                ctx.fillText(parts[2], width2 * scale - paddingX, y);
+              }
+            }
           },
           {
             base64: base64Img,
             width,
+            pageHeight,
             marginTop,
+            marginBottom,
             srcY,
             srcH,
-            scale: deviceScaleFactor
+            scale: deviceScaleFactor,
+            headerText,
+            footerText
           }
         );
         const screenshotBuffer = await composePage.screenshot({
@@ -1072,8 +1764,106 @@ async function renderHtmlToPageBuffers(html, format, options = {}) {
 }
 
 // src/renderer/html.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/renderer/images.ts
 import fs2 from "fs";
 import path2 from "path";
+import url from "url";
+var MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff"
+};
+function resolveLocalImageToDataUri(src, baseUrl) {
+  if (!src || typeof src !== "string") return null;
+  const trimmed = src.trim();
+  if (trimmed.startsWith("data:") || trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("//") || trimmed.startsWith("blob:")) {
+    return null;
+  }
+  let rawPath = trimmed;
+  if (rawPath.startsWith("file://")) {
+    try {
+      rawPath = url.fileURLToPath(rawPath);
+    } catch {
+      rawPath = rawPath.replace(/^file:\/\//, "");
+    }
+  }
+  const [cleanPath] = rawPath.split(/[?#]/);
+  let decodedPath;
+  try {
+    decodedPath = decodeURIComponent(cleanPath);
+  } catch {
+    decodedPath = cleanPath;
+  }
+  const candidates = [];
+  if (path2.isAbsolute(decodedPath)) {
+    candidates.push(decodedPath);
+  } else {
+    if (baseUrl) {
+      const baseDir = fs2.existsSync(baseUrl) && fs2.statSync(baseUrl).isFile() ? path2.dirname(baseUrl) : baseUrl;
+      candidates.push(path2.resolve(baseDir, decodedPath));
+    }
+    candidates.push(path2.resolve(process.cwd(), decodedPath));
+  }
+  for (const candidate of candidates) {
+    try {
+      if (fs2.existsSync(candidate) && fs2.statSync(candidate).isFile()) {
+        const fileBuffer = fs2.readFileSync(candidate);
+        const ext = path2.extname(candidate).toLowerCase();
+        const mimeType = MIME_TYPES[ext] || "image/png";
+        return `data:${mimeType};base64,${fileBuffer.toString("base64")}`;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function inlineLocalImagesInHtml(html, baseUrl) {
+  if (!html) return html;
+  let result = html.replace(
+    /(<img\b[^>]*?\bsrc\s*=\s*)(["']?)([^"'\s>]+)\2([^>]*>)/gi,
+    (match, prefix, _quote, src, suffix) => {
+      const dataUri = resolveLocalImageToDataUri(src, baseUrl);
+      if (dataUri) {
+        return `${prefix}"${dataUri}"${suffix}`;
+      }
+      return match;
+    }
+  );
+  result = result.replace(
+    /(<image\b[^>]*?\b(?:href|xlink:href)\s*=\s*)(["']?)([^"'\s>]+)\2([^>]*>)/gi,
+    (match, prefix, _quote, src, suffix) => {
+      const dataUri = resolveLocalImageToDataUri(src, baseUrl);
+      if (dataUri) {
+        return `${prefix}"${dataUri}"${suffix}`;
+      }
+      return match;
+    }
+  );
+  result = result.replace(/url\(\s*(["']?)([^"')]+)\1\s*\)/gi, (match, _quote, urlStr) => {
+    if (urlStr.startsWith("https://printdown.local/fonts/") || urlStr.startsWith("data:") || urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
+      return match;
+    }
+    const dataUri = resolveLocalImageToDataUri(urlStr, baseUrl);
+    if (dataUri) {
+      return `url("${dataUri}")`;
+    }
+    return match;
+  });
+  return result;
+}
+
+// src/renderer/html.ts
 function resolveCss(cssInput, baseUrl) {
   const inputs = Array.isArray(cssInput) ? cssInput : [cssInput];
   const resolvedCssParts = [];
@@ -1081,22 +1871,22 @@ function resolveCss(cssInput, baseUrl) {
     if (!input || typeof input !== "string") continue;
     let isFile = false;
     let filePath = input;
-    if (baseUrl && !path2.isAbsolute(input)) {
-      const candidate = path2.resolve(baseUrl, input);
-      if (fs2.existsSync(candidate) && fs2.statSync(candidate).isFile()) {
+    if (baseUrl && !path3.isAbsolute(input)) {
+      const candidate = path3.resolve(baseUrl, input);
+      if (fs3.existsSync(candidate) && fs3.statSync(candidate).isFile()) {
         isFile = true;
         filePath = candidate;
       }
     }
-    if (!isFile && (fs2.existsSync(input) || input.endsWith(".css"))) {
-      if (fs2.existsSync(input) && fs2.statSync(input).isFile()) {
+    if (!isFile && (fs3.existsSync(input) || input.endsWith(".css"))) {
+      if (fs3.existsSync(input) && fs3.statSync(input).isFile()) {
         isFile = true;
-        filePath = path2.resolve(input);
+        filePath = path3.resolve(input);
       }
     }
     if (isFile) {
       try {
-        const fileContent = fs2.readFileSync(filePath, "utf-8");
+        const fileContent = fs3.readFileSync(filePath, "utf-8");
         resolvedCssParts.push(fileContent);
       } catch (err) {
         console.warn(`[printdown] Failed to read CSS file "${filePath}":`, err);
@@ -1120,7 +1910,9 @@ function buildHtmlDocument(bodyHtml, options = {}) {
       themeCss = defaultThemeCss;
     }
   }
-  const userCss = options.css ? resolveCss(options.css, options.baseUrl) : "";
+  const userCssRaw = options.css ? resolveCss(options.css, options.baseUrl) : "";
+  const userCss = userCssRaw ? inlineLocalImagesInHtml(userCssRaw, options.baseUrl) : "";
+  const processedBodyHtml = inlineLocalImagesInHtml(bodyHtml, options.baseUrl);
   const baseTag = options.baseUrl ? `<base href="${options.baseUrl.endsWith("/") ? options.baseUrl : options.baseUrl + "/"}">` : "";
   return `<!DOCTYPE html>
 <html lang="ja">
@@ -1134,7 +1926,7 @@ function buildHtmlDocument(bodyHtml, options = {}) {
 </head>
 <body>
   <article class="printdown">
-${bodyHtml}
+${processedBodyHtml}
   </article>
 </body>
 </html>`;
@@ -1146,7 +1938,7 @@ function inferFormat(output, explicitFormat) {
     return explicitFormat;
   }
   if (output) {
-    const ext = path3.extname(output).toLowerCase();
+    const ext = path4.extname(output).toLowerCase();
     if (ext === ".png") return "png";
     if (ext === ".jpg" || ext === ".jpeg") return "jpeg";
     if (ext === ".webp") return "webp";
@@ -1160,14 +1952,18 @@ function resolvePageOutputFilePath(outputPath, pageIndex, totalPages) {
     return outputPath.replace(/%d/g, String(pageNumber));
   }
   if (totalPages === 1 && !outputPath.includes("-1")) {
-    const parsed2 = path3.parse(outputPath);
-    return path3.join(parsed2.dir, `${parsed2.name}-${pageNumber}${parsed2.ext}`);
+    const parsed2 = path4.parse(outputPath);
+    return path4.join(parsed2.dir, `${parsed2.name}-${pageNumber}${parsed2.ext}`);
   }
-  const parsed = path3.parse(outputPath);
-  return path3.join(parsed.dir, `${parsed.name}-${pageNumber}${parsed.ext}`);
+  const parsed = path4.parse(outputPath);
+  return path4.join(parsed.dir, `${parsed.name}-${pageNumber}${parsed.ext}`);
 }
 async function renderToHtml(markdown, options = {}) {
-  const md = await createMarkdownRenderer(options.markdown);
+  const markdownOptions = {
+    ...options.markdown,
+    ...options.katex ? { katex: options.katex } : {}
+  };
+  const md = await createMarkdownRenderer(markdownOptions);
   const bodyHtml = md.render(markdown);
   return buildHtmlDocument(bodyHtml, options);
 }
@@ -1176,27 +1972,27 @@ async function renderPages(markdown, options = {}) {
   const html = await renderToHtml(markdown, options);
   const buffers = await renderHtmlToPageBuffers(html, format, options);
   if (options.output) {
-    const resolvedPath = path3.resolve(options.output);
-    const outputDir = path3.dirname(resolvedPath);
-    if (!fs3.existsSync(outputDir)) {
-      fs3.mkdirSync(outputDir, { recursive: true });
+    const resolvedPath = path4.resolve(options.output);
+    const outputDir = path4.dirname(resolvedPath);
+    if (!fs4.existsSync(outputDir)) {
+      fs4.mkdirSync(outputDir, { recursive: true });
     }
     if (format === "pdf" && buffers.length === 1) {
-      fs3.writeFileSync(resolvedPath, buffers[0]);
+      fs4.writeFileSync(resolvedPath, buffers[0]);
     } else {
       buffers.forEach((buf, idx) => {
         const filePath = resolvePageOutputFilePath(resolvedPath, idx, buffers.length);
-        fs3.writeFileSync(filePath, buf);
+        fs4.writeFileSync(filePath, buf);
       });
     }
   }
   return buffers;
 }
 async function renderFilePages(filePath, options = {}) {
-  const absolutePath = path3.resolve(filePath);
+  const absolutePath = path4.resolve(filePath);
   const encoding = options.encoding ?? "utf-8";
-  const markdown = fs3.readFileSync(absolutePath, encoding);
-  const fileDir = path3.dirname(absolutePath);
+  const markdown = fs4.readFileSync(absolutePath, encoding);
+  const fileDir = path4.dirname(absolutePath);
   const baseUrl = options.baseUrl ?? fileDir;
   return renderPages(markdown, {
     baseUrl,
@@ -1211,20 +2007,20 @@ async function render(markdown, options = {}) {
   const html = await renderToHtml(markdown, options);
   const buffer = await renderHtmlToBuffer(html, format, options);
   if (options.output) {
-    const outputPath = path3.resolve(options.output);
-    const outputDir = path3.dirname(outputPath);
-    if (!fs3.existsSync(outputDir)) {
-      fs3.mkdirSync(outputDir, { recursive: true });
+    const outputPath = path4.resolve(options.output);
+    const outputDir = path4.dirname(outputPath);
+    if (!fs4.existsSync(outputDir)) {
+      fs4.mkdirSync(outputDir, { recursive: true });
     }
-    fs3.writeFileSync(outputPath, buffer);
+    fs4.writeFileSync(outputPath, buffer);
   }
   return buffer;
 }
 async function renderFile(filePath, options = {}) {
-  const absolutePath = path3.resolve(filePath);
+  const absolutePath = path4.resolve(filePath);
   const encoding = options.encoding ?? "utf-8";
-  const markdown = fs3.readFileSync(absolutePath, encoding);
-  const fileDir = path3.dirname(absolutePath);
+  const markdown = fs4.readFileSync(absolutePath, encoding);
+  const fileDir = path4.dirname(absolutePath);
   const baseUrl = options.baseUrl ?? fileDir;
   if (options.pages) {
     return renderPages(markdown, {
@@ -1239,13 +2035,19 @@ async function renderFile(filePath, options = {}) {
 }
 
 export {
+  mathPlugin,
   createMarkdownRenderer,
+  buildHeaderFooterHtml,
+  resolveHeaderFooterPdfOptions,
+  formatHeaderFooterCanvasText,
   BrowserRenderer,
   renderHtmlToPageBuffers,
+  resolveLocalImageToDataUri,
+  inlineLocalImagesInHtml,
   renderToHtml,
   renderPages,
   renderFilePages,
   render,
   renderFile
 };
-//# sourceMappingURL=chunk-ZB6NLLOD.js.map
+//# sourceMappingURL=chunk-BLKOSAAA.js.map