printdown 1.0.0

package/dist/chunk-HX2CR2SJ.js

@@ -0,0 +1,1006 @@
+import {
+  defaultThemeCss,
+  getFontDir
+} from "./chunk-INBZBWSZ.js";
+
+// src/index.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/markdown/index.ts
+import MarkdownIt from "markdown-it";
+import {
+  createHighlighter
+} from "shiki";
+
+// src/markdown/plugins/highlight.ts
+function highlightPlugin(md) {
+  function tokenize(state, silent) {
+    const start = state.pos;
+    const marker = state.src.charCodeAt(start);
+    if (marker !== 61) {
+      return false;
+    }
+    const scanned = state.scanDelims(state.pos, true);
+    const len = scanned.length;
+    const ch = String.fromCharCode(marker);
+    if (len < 2) {
+      return false;
+    }
+    let isColor = false;
+    let color = "blue";
+    if (scanned.can_open) {
+      const match = state.src.slice(start + len).match(/^\{([a-zA-Z0-9_-]+)\}/);
+      if (match) {
+        isColor = true;
+        color = match[1];
+        state.pos += match[0].length;
+      }
+    }
+    if (silent) {
+      state.pos += len;
+      return true;
+    }
+    for (let i = 0; i < Math.floor(len / 2); i++) {
+      const token = state.push("text", "", 0);
+      token.content = ch + ch;
+      state.delimiters.push({
+        marker: 61,
+        length: 0,
+        jump: i,
+        token: state.tokens.length - 1,
+        level: state.level,
+        end: -1,
+        open: scanned.can_open,
+        close: scanned.can_close,
+        color: isColor ? color : "blue"
+      });
+    }
+    state.pos += len;
+    return true;
+  }
+  function postProcess(state) {
+    const delimiters = state.delimiters;
+    if (!delimiters) return;
+    for (let i = 0; i < delimiters.length; i++) {
+      const startDelim = delimiters[i];
+      if (startDelim.marker !== 61 || startDelim.end === -1) continue;
+      const endDelim = delimiters[startDelim.end];
+      const tokenStart = state.tokens[startDelim.token];
+      tokenStart.type = "mark_open";
+      tokenStart.tag = "mark";
+      tokenStart.nesting = 1;
+      tokenStart.markup = "==";
+      tokenStart.content = "";
+      tokenStart.attrs = [
+        ["class", `printdown-highlight printdown-highlight--${startDelim.color || "blue"}`]
+      ];
+      const tokenEnd = state.tokens[endDelim.token];
+      tokenEnd.type = "mark_close";
+      tokenEnd.tag = "mark";
+      tokenEnd.nesting = -1;
+      tokenEnd.markup = "==";
+      tokenEnd.content = "";
+    }
+  }
+  md.inline.ruler.before("emphasis", "highlight", tokenize);
+  md.inline.ruler2.before("emphasis", "highlight", (state) => {
+    const delimiters = state.delimiters;
+    if (!delimiters) return;
+    for (let i = 0; i < delimiters.length; i++) {
+      const startDelim = delimiters[i];
+      if (startDelim.marker !== 61) continue;
+      for (let j = i + 1; j < delimiters.length; j++) {
+        const endDelim = delimiters[j];
+        if (endDelim.marker !== 61) continue;
+        if (startDelim.open && endDelim.close && endDelim.end === -1 && startDelim.end === -1) {
+          startDelim.end = j;
+          endDelim.end = i;
+          break;
+        }
+      }
+    }
+    postProcess(state);
+  });
+}
+
+// src/markdown/plugins/task-list.ts
+var TASK_LIST_REGEX = /^\[([ xX])\][ \t]+/;
+function taskListPlugin(md) {
+  md.core.ruler.after("inline", "task_list", (state) => {
+    const tokens = state.tokens;
+    for (let i = 0; i < tokens.length; i++) {
+      if (tokens[i].type !== "bullet_list_open") {
+        continue;
+      }
+      let listEnd = i + 1;
+      let depth = 1;
+      let hasTaskItems = false;
+      while (listEnd < tokens.length && depth > 0) {
+        if (tokens[listEnd].type === "bullet_list_open") {
+          depth++;
+        } else if (tokens[listEnd].type === "bullet_list_close") {
+          depth--;
+        }
+        listEnd++;
+      }
+      for (let j = i + 1; j < listEnd; j++) {
+        if (tokens[j].type === "list_item_open") {
+          const inlineTokenIndex = findFirstInlineToken(tokens, j);
+          if (inlineTokenIndex !== -1) {
+            const inlineToken = tokens[inlineTokenIndex];
+            if (isTaskListItem(inlineToken)) {
+              hasTaskItems = true;
+              break;
+            }
+          }
+        }
+      }
+      if (!hasTaskItems) {
+        continue;
+      }
+      addClass(tokens[i], "printdown-task-list");
+      for (let j = i + 1; j < listEnd; j++) {
+        if (tokens[j].type === "list_item_open") {
+          const inlineTokenIndex = findFirstInlineToken(tokens, j);
+          if (inlineTokenIndex !== -1) {
+            const inlineToken = tokens[inlineTokenIndex];
+            const match = getTaskListMatch(inlineToken);
+            if (match) {
+              addClass(tokens[j], "printdown-task-list-item");
+              const isChecked = match[1].toLowerCase() === "x";
+              removeTaskListPrefix(inlineToken);
+              insertCheckboxToken(inlineToken, isChecked, state.Token);
+            }
+          }
+        }
+      }
+    }
+  });
+}
+function findFirstInlineToken(tokens, listItemIndex) {
+  for (let i = listItemIndex + 1; i < tokens.length; i++) {
+    if (tokens[i].type === "list_item_close" || tokens[i].type === "list_item_open") {
+      return -1;
+    }
+    if (tokens[i].type === "inline") {
+      return i;
+    }
+  }
+  return -1;
+}
+function isTaskListItem(inlineToken) {
+  if (!inlineToken.children || inlineToken.children.length === 0) {
+    return false;
+  }
+  const firstChild = inlineToken.children[0];
+  return firstChild.type === "text" && TASK_LIST_REGEX.test(firstChild.content);
+}
+function getTaskListMatch(inlineToken) {
+  if (!inlineToken.children || inlineToken.children.length === 0) {
+    return null;
+  }
+  const firstChild = inlineToken.children[0];
+  if (firstChild.type === "text") {
+    return firstChild.content.match(TASK_LIST_REGEX);
+  }
+  return null;
+}
+function removeTaskListPrefix(inlineToken) {
+  if (!inlineToken.children || inlineToken.children.length === 0) {
+    return;
+  }
+  const firstChild = inlineToken.children[0];
+  if (firstChild.type === "text") {
+    firstChild.content = firstChild.content.replace(TASK_LIST_REGEX, "");
+  }
+}
+function insertCheckboxToken(inlineToken, checked, TokenConstructor) {
+  const checkboxToken = new TokenConstructor("html_inline", "", 0);
+  checkboxToken.content = `<input class="printdown-task-list-checkbox" type="checkbox" disabled${checked ? ' checked=""' : ""} /> `;
+  if (!inlineToken.children) {
+    inlineToken.children = [];
+  }
+  inlineToken.children.unshift(checkboxToken);
+}
+function addClass(token, className) {
+  const classIndex = token.attrIndex("class");
+  if (classIndex < 0) {
+    token.attrPush(["class", className]);
+  } else if (token.attrs) {
+    const existing = token.attrs[classIndex][1];
+    if (typeof existing === "string" && !existing.split(" ").includes(className)) {
+      token.attrs[classIndex][1] = `${existing} ${className}`.trim();
+    }
+  }
+}
+
+// src/markdown/plugins/badge.ts
+var BADGE_MARKDOWN_REGEX = /^\[badge(?:\(([^)]+)\)|\{([^}]+)\})?:([\s\S]*?)\]/i;
+var BADGE_OPEN_TAG_REGEX = /^<badge(\s+[^>]*)?>$/i;
+var BADGE_CLOSE_TAG_REGEX = /^<\/badge>$/i;
+var BADGE_SELF_CLOSING_REGEX = /^<badge(\s+[^>]*)?\/>$/i;
+function parseBadgeOptions(optionsStr) {
+  let variant = "solid";
+  let color = "blue";
+  if (!optionsStr) {
+    return { variant, color };
+  }
+  const parts = optionsStr.split(/[\s,]+/).map((p) => p.trim().toLowerCase()).filter(Boolean);
+  for (const part of parts) {
+    if (part === "solid" || part === "soft" || part === "outline") {
+      variant = part;
+    } else if (/^[a-z0-9_-]+$/.test(part)) {
+      color = part;
+    }
+  }
+  return { variant, color };
+}
+function parseBadgeAttrs(attrsStr) {
+  let variant = "solid";
+  let color = "blue";
+  if (!attrsStr) {
+    return { variant, color };
+  }
+  const variantMatch = attrsStr.match(/variant=["']?([a-zA-Z0-9_-]+)["']?/i);
+  if (variantMatch) {
+    const v = variantMatch[1].toLowerCase();
+    if (v === "solid" || v === "soft" || v === "outline") {
+      variant = v;
+    }
+  }
+  const colorMatch = attrsStr.match(/color=["']?([a-zA-Z0-9_-]+)["']?/i);
+  if (colorMatch) {
+    color = colorMatch[1].toLowerCase();
+  }
+  return { variant, color };
+}
+function badgePlugin(md) {
+  function inlineBadgeRule(state, silent) {
+    const max = state.posMax;
+    const start = state.pos;
+    if (state.src.charCodeAt(start) !== 91) {
+      return false;
+    }
+    const match = state.src.slice(start).match(BADGE_MARKDOWN_REGEX);
+    if (!match) {
+      return false;
+    }
+    const matchedLength = match[0].length;
+    if (start + matchedLength > max) {
+      return false;
+    }
+    if (silent) {
+      state.pos += matchedLength;
+      return true;
+    }
+    const rawOptions = match[1] || match[2] || "";
+    const badgeText = match[3];
+    const { variant, color } = parseBadgeOptions(rawOptions);
+    const tokenOpen = state.push("badge_open", "span", 1);
+    tokenOpen.attrs = [
+      ["class", `printdown-badge printdown-badge--${variant} printdown-badge--${color}`]
+    ];
+    const nestedTokens = [];
+    state.md.inline.parse(badgeText, state.md, state.env, nestedTokens);
+    for (const nested of nestedTokens) {
+      state.tokens.push(nested);
+    }
+    state.push("badge_close", "span", -1);
+    state.pos += matchedLength;
+    return true;
+  }
+  md.inline.ruler.before("link", "badge", inlineBadgeRule);
+  md.core.ruler.after("inline", "badge_tags", (state) => {
+    const tokens = state.tokens;
+    function processToken(token) {
+      if (token.type === "html_inline") {
+        const trimmed = token.content.trim();
+        if (BADGE_SELF_CLOSING_REGEX.test(trimmed)) {
+          const match = trimmed.match(BADGE_SELF_CLOSING_REGEX);
+          const { variant, color } = parseBadgeAttrs(match?.[1]);
+          token.content = `<span class="printdown-badge printdown-badge--${variant} printdown-badge--${color}"></span>`;
+        } else if (BADGE_OPEN_TAG_REGEX.test(trimmed)) {
+          const match = trimmed.match(BADGE_OPEN_TAG_REGEX);
+          const { variant, color } = parseBadgeAttrs(match?.[1]);
+          token.content = `<span class="printdown-badge printdown-badge--${variant} printdown-badge--${color}">`;
+        } else if (BADGE_CLOSE_TAG_REGEX.test(trimmed)) {
+          token.content = `</span>`;
+        }
+      } else if (token.type === "html_block") {
+        token.content = token.content.replace(
+          /<badge(\s+[^>]*)?>([\s\S]*?)<\/badge>/gi,
+          (_, attrs, body) => {
+            const { variant, color } = parseBadgeAttrs(attrs);
+            return `<span class="printdown-badge printdown-badge--${variant} printdown-badge--${color}">${body}</span>`;
+          }
+        );
+      }
+    }
+    for (let i = 0; i < tokens.length; i++) {
+      processToken(tokens[i]);
+      if (tokens[i].children) {
+        for (let j = 0; j < tokens[i].children.length; j++) {
+          processToken(tokens[i].children[j]);
+        }
+      }
+    }
+  });
+}
+
+// src/markdown/plugins/kbd.ts
+var KBD_MARKDOWN_REGEX = /^\[kbd(?:\(([^)]+)\))?:([\s\S]*?)\]/i;
+var KBD_ICON_ONLY_REGEX = /^\[kbd\(([^)]+)\)\]/i;
+var KBD_OPEN_TAG_REGEX = /^<kbd(\s+[^>]*)?>$/i;
+var KBD_CLOSE_TAG_REGEX = /^<\/kbd>$/i;
+var KBD_SELF_CLOSING_REGEX = /^<kbd(\s+[^>]*)?\/>$/i;
+function parseKbdAttrs(attrsStr) {
+  if (!attrsStr) return {};
+  const iconMatch = attrsStr.match(/icon=["']?([a-zA-Z0-9_-]+)["']?/i);
+  if (iconMatch) {
+    return { icon: iconMatch[1].toLowerCase() };
+  }
+  return {};
+}
+function kbdPlugin(md) {
+  function inlineKbdRule(state, silent) {
+    const max = state.posMax;
+    const start = state.pos;
+    if (state.src.charCodeAt(start) !== 91) {
+      return false;
+    }
+    const rest = state.src.slice(start);
+    const matchWithText = rest.match(KBD_MARKDOWN_REGEX);
+    const matchIconOnly = !matchWithText ? rest.match(KBD_ICON_ONLY_REGEX) : null;
+    const match = matchWithText || matchIconOnly;
+    if (!match) {
+      return false;
+    }
+    const matchedLength = match[0].length;
+    if (start + matchedLength > max) {
+      return false;
+    }
+    if (silent) {
+      state.pos += matchedLength;
+      return true;
+    }
+    const icon = matchWithText ? matchWithText[1] : matchIconOnly ? matchIconOnly[1] : void 0;
+    const kbdText = matchWithText ? matchWithText[2] : "";
+    const tokenOpen = state.push("kbd_open", "kbd", 1);
+    tokenOpen.attrs = [["class", "printdown-kbd"]];
+    if (icon) {
+      const iconToken = state.push("html_inline", "", 0);
+      iconToken.content = `<span class="printdown-kbd-icon printdown-kbd-icon--${icon.toLowerCase()}"></span>`;
+    }
+    if (kbdText) {
+      const nestedTokens = [];
+      state.md.inline.parse(kbdText, state.md, state.env, nestedTokens);
+      for (const nested of nestedTokens) {
+        state.tokens.push(nested);
+      }
+    }
+    state.push("kbd_close", "kbd", -1);
+    state.pos += matchedLength;
+    return true;
+  }
+  md.inline.ruler.before("link", "kbd", inlineKbdRule);
+  md.core.ruler.after("inline", "kbd_tags", (state) => {
+    const tokens = state.tokens;
+    function processToken(token) {
+      if (token.type === "html_inline") {
+        const trimmed = token.content.trim();
+        if (KBD_SELF_CLOSING_REGEX.test(trimmed)) {
+          const match = trimmed.match(KBD_SELF_CLOSING_REGEX);
+          const { icon } = parseKbdAttrs(match?.[1]);
+          const iconHtml = icon ? `<span class="printdown-kbd-icon printdown-kbd-icon--${icon}"></span>` : "";
+          token.content = `<kbd class="printdown-kbd">${iconHtml}</kbd>`;
+        } else if (KBD_OPEN_TAG_REGEX.test(trimmed)) {
+          const match = trimmed.match(KBD_OPEN_TAG_REGEX);
+          const { icon } = parseKbdAttrs(match?.[1]);
+          const iconHtml = icon ? `<span class="printdown-kbd-icon printdown-kbd-icon--${icon}"></span>` : "";
+          token.content = `<kbd class="printdown-kbd">${iconHtml}`;
+        } else if (KBD_CLOSE_TAG_REGEX.test(trimmed)) {
+          token.content = `</kbd>`;
+        }
+      } else if (token.type === "html_block") {
+        token.content = token.content.replace(
+          /<kbd(\s+[^>]*)?>([\s\S]*?)<\/kbd>/gi,
+          (_, attrs, body) => {
+            const { icon } = parseKbdAttrs(attrs);
+            const iconHtml = icon ? `<span class="printdown-kbd-icon printdown-kbd-icon--${icon}"></span>` : "";
+            return `<kbd class="printdown-kbd">${iconHtml}${body}</kbd>`;
+          }
+        );
+      }
+    }
+    for (let i = 0; i < tokens.length; i++) {
+      processToken(tokens[i]);
+      if (tokens[i].children) {
+        for (let j = 0; j < tokens[i].children.length; j++) {
+          processToken(tokens[i].children[j]);
+        }
+      }
+    }
+  });
+}
+
+// src/markdown/index.ts
+var DEFAULT_LANGS = [
+  "javascript",
+  "typescript",
+  "jsx",
+  "tsx",
+  "html",
+  "css",
+  "json",
+  "markdown",
+  "mdx",
+  "bash",
+  "shell",
+  "yaml",
+  "toml",
+  "sql",
+  "python",
+  "rust",
+  "go",
+  "c",
+  "cpp",
+  "diff",
+  "dockerfile",
+  "graphql",
+  "ini",
+  "java",
+  "kotlin",
+  "ruby",
+  "php",
+  "swift",
+  "xml"
+];
+var DEFAULT_THEME = "github-dark";
+var cachedHighlighter = null;
+var cachedLangs = /* @__PURE__ */ new Set();
+var cachedThemes = /* @__PURE__ */ new Set();
+async function getHighlighter(options) {
+  const theme = options?.theme || DEFAULT_THEME;
+  const userLangs = options?.langs || [];
+  const requiredLangs = Array.from(/* @__PURE__ */ new Set([...DEFAULT_LANGS, ...userLangs]));
+  if (!cachedHighlighter) {
+    cachedHighlighter = await createHighlighter({
+      themes: [theme],
+      langs: requiredLangs
+    });
+    for (const lang of requiredLangs) {
+      cachedLangs.add(lang);
+    }
+    cachedThemes.add(theme);
+    return cachedHighlighter;
+  }
+  if (!cachedThemes.has(theme)) {
+    await cachedHighlighter.loadTheme(theme);
+    cachedThemes.add(theme);
+  }
+  const missingLangs = requiredLangs.filter((l) => !cachedLangs.has(l));
+  if (missingLangs.length > 0) {
+    await cachedHighlighter.loadLanguage(...missingLangs);
+    for (const lang of missingLangs) {
+      cachedLangs.add(lang);
+    }
+  }
+  return cachedHighlighter;
+}
+async function createMarkdownRenderer(options = {}) {
+  const md = new MarkdownIt({
+    html: options.html ?? true,
+    linkify: options.linkify ?? true,
+    typographer: options.typographer ?? true
+  });
+  md.use(highlightPlugin);
+  md.use(taskListPlugin);
+  md.use(badgePlugin);
+  md.use(kbdPlugin);
+  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 code = token.content;
+    try {
+      const loadedLangs = highlighter.getLoadedLanguages();
+      const targetLang = loadedLangs.includes(lang) ? lang : "text";
+      return highlighter.codeToHtml(code, {
+        lang: targetLang,
+        theme,
+        transformers: [
+          {
+            pre(node) {
+              const existingClass = node.properties.class || "";
+              node.properties.class = `printdown-code ${existingClass}`.trim();
+            }
+          }
+        ]
+      });
+    } catch {
+      if (defaultFence) {
+        return defaultFence(tokens, idx, fenceOptions, env, self);
+      }
+      return `<pre class="printdown-code"><code>${md.utils.escapeHtml(code)}</code></pre>
+`;
+    }
+  };
+  return md;
+}
+
+// src/renderer/index.ts
+import fs from "fs";
+import path from "path";
+import { chromium } from "playwright";
+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");
+  await context.route("https://printdown.local/fonts/**", async (route) => {
+    const reqUrl = route.request().url();
+    let filePath = "";
+    if (interDir && reqUrl.startsWith("https://printdown.local/fonts/inter/")) {
+      filePath = path.join(
+        interDir,
+        "files",
+        reqUrl.replace("https://printdown.local/fonts/inter/", "")
+      );
+    } else if (notoDir && reqUrl.startsWith("https://printdown.local/fonts/noto-sans-jp/")) {
+      filePath = path.join(
+        notoDir,
+        "files",
+        reqUrl.replace("https://printdown.local/fonts/noto-sans-jp/", "")
+      );
+    } else if (jbDir && reqUrl.startsWith("https://printdown.local/fonts/jetbrains-mono/")) {
+      filePath = path.join(
+        jbDir,
+        "files",
+        reqUrl.replace("https://printdown.local/fonts/jetbrains-mono/", "")
+      );
+    } else if (genDir && reqUrl.startsWith("https://printdown.local/fonts/gen-interface-jp/w/")) {
+      filePath = path.join(
+        genDir,
+        "w",
+        reqUrl.replace("https://printdown.local/fonts/gen-interface-jp/w/", "")
+      );
+    }
+    if (filePath && fs.existsSync(filePath)) {
+      try {
+        const body = fs.readFileSync(filePath);
+        await route.fulfill({
+          status: 200,
+          contentType: "font/woff2",
+          body
+        });
+        return;
+      } catch {
+      }
+    }
+    await route.abort();
+  });
+}
+var BrowserRenderer = class {
+  browser = null;
+  async init() {
+    if (!this.browser) {
+      this.browser = await chromium.launch({
+        headless: true,
+        args: [
+          "--disable-gpu",
+          "--no-sandbox",
+          "--disable-setuid-sandbox",
+          "--font-render-hinting=medium"
+        ]
+      });
+    }
+  }
+  async close() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+    }
+  }
+  async preparePage(html, width, height, deviceScaleFactor) {
+    let isLocalBrowser = false;
+    let browser = this.browser;
+    if (!browser) {
+      browser = await chromium.launch({
+        headless: true,
+        args: [
+          "--disable-gpu",
+          "--no-sandbox",
+          "--disable-setuid-sandbox",
+          "--font-render-hinting=medium"
+        ]
+      });
+      isLocalBrowser = true;
+    }
+    const context = await browser.newContext({
+      viewport: { width, height },
+      deviceScaleFactor
+    });
+    await setupFontRouting(context);
+    const page = await context.newPage();
+    await page.setContent(html, {
+      waitUntil: "networkidle"
+    });
+    await page.evaluate(async () => {
+      if (document.fonts) {
+        await document.fonts.ready;
+      }
+    });
+    await page.evaluate(async () => {
+      const images = Array.from(document.images);
+      const pendingImages = images.filter((img) => !img.complete);
+      if (pendingImages.length > 0) {
+        await Promise.all(
+          pendingImages.map(
+            (img) => new Promise((resolve) => {
+              img.onload = img.onerror = resolve;
+            })
+          )
+        );
+      }
+    });
+    return { browser, context, page, isLocalBrowser };
+  }
+  async renderToBuffer(html, format, options = {}) {
+    const width = options.width ?? (format === "pdf" ? 820 : 1200);
+    const height = options.height ?? 800;
+    const deviceScaleFactor = options.scale ?? options.deviceScaleFactor ?? 2;
+    const { browser, context, page, isLocalBrowser } = await this.preparePage(
+      html,
+      width,
+      height,
+      deviceScaleFactor
+    );
+    try {
+      if (format === "pdf") {
+        const pdfBuffer = await page.pdf({
+          printBackground: true,
+          preferCSSPageSize: true,
+          ...options.pdf
+        });
+        return Buffer.from(pdfBuffer);
+      } else if (format === "png") {
+        const screenshotBuffer = await page.screenshot({
+          type: "png",
+          fullPage: options.image?.fullPage ?? true,
+          ...options.image
+        });
+        return Buffer.from(screenshotBuffer);
+      } else if (format === "jpeg") {
+        const screenshotBuffer = await page.screenshot({
+          type: "jpeg",
+          quality: options.quality ?? 90,
+          fullPage: options.image?.fullPage ?? true,
+          ...options.image
+        });
+        return Buffer.from(screenshotBuffer);
+      } else if (format === "webp") {
+        const screenshotBuffer = await page.screenshot({
+          type: "webp",
+          quality: options.quality ?? 90,
+          fullPage: options.image?.fullPage ?? true,
+          ...options.image
+        });
+        return Buffer.from(screenshotBuffer);
+      } else {
+        throw new Error(`Unsupported output format: ${format}`);
+      }
+    } finally {
+      await page.close().catch(() => {
+      });
+      await context.close().catch(() => {
+      });
+      if (isLocalBrowser && browser) {
+        await browser.close().catch(() => {
+        });
+      }
+    }
+  }
+  async renderToPageBuffers(html, format, options = {}) {
+    if (format === "pdf") {
+      const singleBuffer = await this.renderToBuffer(html, format, options);
+      return [singleBuffer];
+    }
+    const width = options.width ?? 820;
+    const pageHeight = options.pageHeight ?? Math.round(width * 297 / 210);
+    const marginTop = options.pageMarginTop ?? Math.round(20 / 297 * pageHeight);
+    const marginBottom = options.pageMarginBottom ?? Math.round(20 / 297 * pageHeight);
+    const contentHeightPerPage = Math.max(100, pageHeight - marginTop - marginBottom);
+    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>";
+    const { browser, context, page, isLocalBrowser } = await this.preparePage(
+      pagesHtml,
+      width,
+      pageHeight,
+      deviceScaleFactor
+    );
+    let composePage = null;
+    try {
+      const totalContentHeight = await page.evaluate(
+        () => Math.max(document.documentElement.scrollHeight, document.body.scrollHeight)
+      );
+      const pageCount = Math.max(1, Math.ceil(totalContentHeight / contentHeightPerPage));
+      await page.setViewportSize({
+        width,
+        height: Math.max(totalContentHeight + 100, pageHeight)
+      });
+      const fullContentScreenshot = await page.screenshot({
+        type: "png",
+        fullPage: true
+      });
+      composePage = await context.newPage();
+      await composePage.setContent(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <style>
+            html, body { margin: 0; padding: 0; background: #ffffff; overflow: hidden; }
+            canvas { display: block; }
+          </style>
+        </head>
+        <body>
+          <canvas id="canvas" width="${width * deviceScaleFactor}" height="${pageHeight * deviceScaleFactor}" style="width:${width}px; height:${pageHeight}px;"></canvas>
+        </body>
+        </html>
+      `);
+      const base64Img = fullContentScreenshot.toString("base64");
+      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);
+        await composePage.evaluate(
+          async ({ base64, width: width2, marginTop: marginTop2, srcY: srcY2, srcH: srcH2, scale }) => {
+            const canvas = document.getElementById("canvas");
+            const ctx = canvas.getContext("2d");
+            if (!ctx) return;
+            ctx.fillStyle = "#ffffff";
+            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            const img = new Image();
+            await new Promise((resolve) => {
+              img.onload = resolve;
+              img.src = "data:image/png;base64," + base64;
+            });
+            ctx.drawImage(
+              img,
+              0,
+              srcY2 * scale,
+              width2 * scale,
+              srcH2 * scale,
+              0,
+              marginTop2 * scale,
+              width2 * scale,
+              srcH2 * scale
+            );
+          },
+          {
+            base64: base64Img,
+            width,
+            marginTop,
+            srcY,
+            srcH,
+            scale: deviceScaleFactor
+          }
+        );
+        const screenshotBuffer = await composePage.screenshot({
+          type: imageType,
+          quality: imageType !== "png" ? options.quality ?? 90 : void 0,
+          ...options.image
+        });
+        pageBuffers.push(Buffer.from(screenshotBuffer));
+      }
+      return pageBuffers;
+    } finally {
+      if (composePage) {
+        await composePage.close().catch(() => {
+        });
+      }
+      await page.close().catch(() => {
+      });
+      await context.close().catch(() => {
+      });
+      if (isLocalBrowser && browser) {
+        await browser.close().catch(() => {
+        });
+      }
+    }
+  }
+};
+async function renderHtmlToBuffer(html, format, options = {}) {
+  const renderer = new BrowserRenderer();
+  return renderer.renderToBuffer(html, format, options);
+}
+async function renderHtmlToPageBuffers(html, format, options = {}) {
+  const renderer = new BrowserRenderer();
+  return renderer.renderToPageBuffers(html, format, options);
+}
+
+// src/renderer/html.ts
+import fs2 from "fs";
+import path2 from "path";
+function resolveCss(cssInput, baseUrl) {
+  const inputs = Array.isArray(cssInput) ? cssInput : [cssInput];
+  const resolvedCssParts = [];
+  for (const input of inputs) {
+    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()) {
+        isFile = true;
+        filePath = candidate;
+      }
+    }
+    if (!isFile && (fs2.existsSync(input) || input.endsWith(".css"))) {
+      if (fs2.existsSync(input) && fs2.statSync(input).isFile()) {
+        isFile = true;
+        filePath = path2.resolve(input);
+      }
+    }
+    if (isFile) {
+      try {
+        const fileContent = fs2.readFileSync(filePath, "utf-8");
+        resolvedCssParts.push(fileContent);
+      } catch (err) {
+        console.warn(`[printdown] Failed to read CSS file "${filePath}":`, err);
+      }
+    } else {
+      resolvedCssParts.push(input);
+    }
+  }
+  return resolvedCssParts.join("\n\n");
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function buildHtmlDocument(bodyHtml, options = {}) {
+  const title = options.title || "Printdown Document";
+  let themeCss = "";
+  if (options.theme !== false) {
+    if (typeof options.theme === "object" && options.theme !== null && "css" in options.theme) {
+      themeCss = options.theme.css;
+    } else {
+      themeCss = defaultThemeCss;
+    }
+  }
+  const userCss = options.css ? resolveCss(options.css, options.baseUrl) : "";
+  const baseTag = options.baseUrl ? `<base href="${options.baseUrl.endsWith("/") ? options.baseUrl : options.baseUrl + "/"}">` : "";
+  return `<!DOCTYPE html>
+<html lang="ja">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHtml(title)}</title>
+  ${baseTag}
+  ${themeCss ? `<style id="printdown-theme">${themeCss}</style>` : ""}
+  ${userCss ? `<style id="printdown-user-css">${userCss}</style>` : ""}
+</head>
+<body>
+  <article class="printdown">
+${bodyHtml}
+  </article>
+</body>
+</html>`;
+}
+
+// src/index.ts
+function inferFormat(output, explicitFormat) {
+  if (explicitFormat) {
+    return explicitFormat;
+  }
+  if (output) {
+    const ext = path3.extname(output).toLowerCase();
+    if (ext === ".png") return "png";
+    if (ext === ".jpg" || ext === ".jpeg") return "jpeg";
+    if (ext === ".webp") return "webp";
+    if (ext === ".pdf") return "pdf";
+  }
+  return "pdf";
+}
+function resolvePageOutputFilePath(outputPath, pageIndex, totalPages) {
+  const pageNumber = pageIndex + 1;
+  if (outputPath.includes("%d")) {
+    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 parsed = path3.parse(outputPath);
+  return path3.join(parsed.dir, `${parsed.name}-${pageNumber}${parsed.ext}`);
+}
+async function renderToHtml(markdown, options = {}) {
+  const md = await createMarkdownRenderer(options.markdown);
+  const bodyHtml = md.render(markdown);
+  return buildHtmlDocument(bodyHtml, options);
+}
+async function renderPages(markdown, options = {}) {
+  const format = inferFormat(options.output, options.format);
+  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 });
+    }
+    if (format === "pdf" && buffers.length === 1) {
+      fs3.writeFileSync(resolvedPath, buffers[0]);
+    } else {
+      buffers.forEach((buf, idx) => {
+        const filePath = resolvePageOutputFilePath(resolvedPath, idx, buffers.length);
+        fs3.writeFileSync(filePath, buf);
+      });
+    }
+  }
+  return buffers;
+}
+async function renderFilePages(filePath, options = {}) {
+  const absolutePath = path3.resolve(filePath);
+  const encoding = options.encoding ?? "utf-8";
+  const markdown = fs3.readFileSync(absolutePath, encoding);
+  const fileDir = path3.dirname(absolutePath);
+  const baseUrl = options.baseUrl ?? fileDir;
+  return renderPages(markdown, {
+    baseUrl,
+    ...options
+  });
+}
+async function render(markdown, options = {}) {
+  if (options.pages) {
+    return renderPages(markdown, options);
+  }
+  const format = inferFormat(options.output, options.format);
+  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 });
+    }
+    fs3.writeFileSync(outputPath, buffer);
+  }
+  return buffer;
+}
+async function renderFile(filePath, options = {}) {
+  const absolutePath = path3.resolve(filePath);
+  const encoding = options.encoding ?? "utf-8";
+  const markdown = fs3.readFileSync(absolutePath, encoding);
+  const fileDir = path3.dirname(absolutePath);
+  const baseUrl = options.baseUrl ?? fileDir;
+  if (options.pages) {
+    return renderPages(markdown, {
+      baseUrl,
+      ...options
+    });
+  }
+  return render(markdown, {
+    baseUrl,
+    ...options
+  });
+}
+
+export {
+  createMarkdownRenderer,
+  BrowserRenderer,
+  renderHtmlToPageBuffers,
+  renderToHtml,
+  renderPages,
+  renderFilePages,
+  render,
+  renderFile
+};
+//# sourceMappingURL=chunk-HX2CR2SJ.js.map