hono-decks 0.2.0 → 0.2.1

package/dist/bin.js

@@ -1,974 +1,920 @@
 #!/usr/bin/env node
-
-// src/node/cli.ts
-import { existsSync as existsSync4, watch as watch2 } from "fs";
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { join as join4, relative as relative3 } from "path";
-
-// src/node/compile-decks.ts
-import { mkdir, readFile as readFile3, writeFile } from "fs/promises";
-import { join as join3 } from "path";
-
-// src/routing/file-routing.ts
+import { existsSync, watch } from "node:fs";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { unified } from "unified";
+import remarkGfm from "remark-gfm";
+import remarkMdx from "remark-mdx";
+import remarkParse from "remark-parse";
+import { compile } from "@mdx-js/mdx";
+import remarkDirective from "remark-directive";
+import { codeToHtml } from "shiki";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+//#region src/routing/file-routing.ts
 function resolveDeckFiles(paths, root = "decks") {
-  const normalizedRoot = normalizePath(root).replace(/\/$/, "");
-  const decks = /* @__PURE__ */ new Map();
-  const assetsBySlug = /* @__PURE__ */ new Map();
-  for (const inputPath of paths.map(normalizePath).sort()) {
-    assertInsideRoot(inputPath, normalizedRoot);
-    const relative4 = inputPath.slice(normalizedRoot.length + 1);
-    const segments = relative4.split("/");
-    if (segments.length === 1 && segments[0].endsWith(".mdx")) {
-      const slug = segments[0].replace(/\.mdx$/, "");
-      addDeck(decks, {
-        slug,
-        sourcePath: inputPath,
-        kind: "single-file",
-        assetPaths: []
-      });
-      continue;
-    }
-    if (segments.length === 2 && segments[1] === "deck.mdx") {
-      addDeck(decks, {
-        slug: segments[0],
-        sourcePath: inputPath,
-        kind: "directory",
-        assetPaths: assetsBySlug.get(segments[0]) ?? []
-      });
-      continue;
-    }
-    if (segments.length >= 3 && segments[1] === "assets") {
-      const slug = segments[0];
-      const assetPaths = assetsBySlug.get(slug) ?? [];
-      assetPaths.push(inputPath);
-      assetsBySlug.set(slug, assetPaths);
-      const deck = decks.get(slug);
-      if (deck?.kind === "directory") deck.assetPaths = assetPaths;
-      continue;
-    }
-    if (inputPath.endsWith(".mdx")) {
-      throw new Error(`Nested deck slugs are not supported in this slice: ${inputPath}`);
-    }
-  }
-  return [...decks.values()].map((deck) => ({
-    ...deck,
-    assetPaths: [...deck.assetPaths].sort()
-  }));
+	const normalizedRoot = normalizePath$4(root).replace(/\/$/, "");
+	const decks = /* @__PURE__ */ new Map();
+	const assetsBySlug = /* @__PURE__ */ new Map();
+	for (const inputPath of paths.map(normalizePath$4).sort()) {
+		assertInsideRoot(inputPath, normalizedRoot);
+		const segments = inputPath.slice(normalizedRoot.length + 1).split("/");
+		if (segments.length === 1 && segments[0].endsWith(".mdx")) {
+			addDeck(decks, {
+				slug: segments[0].replace(/\.mdx$/, ""),
+				sourcePath: inputPath,
+				kind: "single-file",
+				assetPaths: []
+			});
+			continue;
+		}
+		if (segments.length === 2 && segments[1] === "deck.mdx") {
+			addDeck(decks, {
+				slug: segments[0],
+				sourcePath: inputPath,
+				kind: "directory",
+				assetPaths: assetsBySlug.get(segments[0]) ?? []
+			});
+			continue;
+		}
+		if (segments.length >= 3 && segments[1] === "assets") {
+			const slug = segments[0];
+			const assetPaths = assetsBySlug.get(slug) ?? [];
+			assetPaths.push(inputPath);
+			assetsBySlug.set(slug, assetPaths);
+			const deck = decks.get(slug);
+			if (deck?.kind === "directory") deck.assetPaths = assetPaths;
+			continue;
+		}
+		if (inputPath.endsWith(".mdx")) throw new Error(`Nested deck slugs are not supported in this slice: ${inputPath}`);
+	}
+	return [...decks.values()].map((deck) => ({
+		...deck,
+		assetPaths: [...deck.assetPaths].sort()
+	}));
 }
 function addDeck(decks, next) {
-  const current = decks.get(next.slug);
-  if (current) {
-    throw new Error(`Deck slug conflict for "${next.slug}": ${current.sourcePath} and ${next.sourcePath}`);
-  }
-  decks.set(next.slug, next);
+	const current = decks.get(next.slug);
+	if (current) throw new Error(`Deck slug conflict for "${next.slug}": ${current.sourcePath} and ${next.sourcePath}`);
+	decks.set(next.slug, next);
 }
 function assertInsideRoot(path, root) {
-  if (path.includes("/../") || path.endsWith("/..") || path.startsWith("../")) {
-    throw new Error(`Deck path escapes the root: ${path}`);
-  }
-  if (path !== root && !path.startsWith(`${root}/`)) {
-    throw new Error(`Deck path is outside ${root}: ${path}`);
-  }
-}
-function normalizePath(path) {
-  return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
-}
-
-// src/deck/model.ts
-var SLIDE_TRANSITIONS = [
-  "none",
-  "fade",
-  "fade-out",
-  "slide-left",
-  "slide-right",
-  "slide-up",
-  "slide-down",
-  "view-transition"
+	if (path.includes("/../") || path.endsWith("/..") || path.startsWith("../")) throw new Error(`Deck path escapes the root: ${path}`);
+	if (path !== root && !path.startsWith(`${root}/`)) throw new Error(`Deck path is outside ${root}: ${path}`);
+}
+function normalizePath$4(path) {
+	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+}
+//#endregion
+//#region src/deck/model.ts
+const SLIDE_TRANSITIONS = [
+	"none",
+	"fade",
+	"fade-out",
+	"slide-left",
+	"slide-right",
+	"slide-up",
+	"slide-down",
+	"view-transition"
 ];
 var CompileError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "CompileError";
-  }
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "CompileError";
+	}
 };
-
-// src/deck/frontmatter.ts
+//#endregion
+//#region src/deck/frontmatter.ts
 function readFrontmatter(source) {
-  const normalized = source.replace(/\r\n/g, "\n").trimStart();
-  if (!normalized.startsWith("---\n")) return { attrs: {}, body: source.trim() };
-  const end = normalized.indexOf("\n---", 4);
-  if (end === -1) throw new CompileError("Frontmatter block is not closed.", "frontmatter-unclosed");
-  const rawAttrs = normalized.slice(4, end).trim();
-  const body = normalized.slice(end + 4).replace(/^\n/, "").trim();
-  return { attrs: parseFrontmatterAttrs(rawAttrs), body };
+	const normalized = source.replace(/\r\n/g, "\n").trimStart();
+	if (!normalized.startsWith("---\n")) return {
+		attrs: {},
+		body: source.trim()
+	};
+	const end = normalized.indexOf("\n---", 4);
+	if (end === -1) throw new CompileError("Frontmatter block is not closed.", "frontmatter-unclosed");
+	const rawAttrs = normalized.slice(4, end).trim();
+	const body = normalized.slice(end + 4).replace(/^\n/, "").trim();
+	return {
+		attrs: parseFrontmatterAttrs(rawAttrs),
+		body
+	};
 }
 function toDeckFrontmatter(attrs, warnings) {
-  const meta = { ...attrs };
-  const deck = { meta };
-  deck.title = takeString(meta, "title");
-  deck.description = takeString(meta, "description");
-  deck.author = takeString(meta, "author");
-  deck.date = takeString(meta, "date");
-  deck.theme = takeString(meta, "theme");
-  deck.transition = takeKnownStringWithWarning(meta, "transition", SLIDE_TRANSITIONS, "none", warnings, "unknown-transition");
-  deck.transitionDuration = takeTransitionDuration(meta, warnings);
-  deck.transitionEasing = takeTransitionEasing(meta, warnings);
-  deck.assets = takeStringOrStringArray(meta, "assets");
-  deck.draft = takeBoolean(meta, "draft");
-  deck.presenter = takeBoolean(meta, "presenter");
-  const tags = meta.tags;
-  if (Array.isArray(tags)) {
-    deck.tags = tags.map(String);
-    delete meta.tags;
-  }
-  return deck;
+	const meta = { ...attrs };
+	const deck = { meta };
+	deck.title = takeString(meta, "title");
+	deck.description = takeString(meta, "description");
+	deck.author = takeString(meta, "author");
+	deck.date = takeString(meta, "date");
+	deck.theme = takeString(meta, "theme");
+	deck.transition = takeKnownStringWithWarning(meta, "transition", SLIDE_TRANSITIONS, "none", warnings, "unknown-transition");
+	deck.transitionDuration = takeTransitionDuration(meta, warnings);
+	deck.transitionEasing = takeTransitionEasing(meta, warnings);
+	deck.assets = takeStringOrStringArray(meta, "assets");
+	deck.draft = takeBoolean(meta, "draft");
+	deck.presenter = takeBoolean(meta, "presenter");
+	const tags = meta.tags;
+	if (Array.isArray(tags)) {
+		deck.tags = tags.map(String);
+		delete meta.tags;
+	}
+	return deck;
 }
 function toSlideFrontmatter(attrs, warnings, input) {
-  const meta = { ...attrs };
-  const slide = {
-    title: takeString(meta, "title") ?? input.fallbackTitle,
-    layout: takeString(meta, "layout") ?? input.fallbackLayout,
-    className: takeString(meta, "class") ?? input.fallbackClassName,
-    notes: takeString(meta, "notes"),
-    background: takeString(meta, "background"),
-    transition: takeKnownStringWithWarning(
-      meta,
-      "transition",
-      SLIDE_TRANSITIONS,
-      "none",
-      warnings,
-      "unknown-transition",
-      input.slideIndex
-    ) ?? input.fallbackTransition,
-    transitionDuration: takeTransitionDuration(meta, warnings, input.slideIndex) ?? input.fallbackTransitionDuration,
-    transitionEasing: takeTransitionEasing(meta, warnings, input.slideIndex) ?? input.fallbackTransitionEasing,
-    meta
-  };
-  return slide;
+	const meta = { ...attrs };
+	return {
+		title: takeString(meta, "title") ?? input.fallbackTitle,
+		layout: takeString(meta, "layout") ?? input.fallbackLayout,
+		className: takeString(meta, "class") ?? input.fallbackClassName,
+		notes: takeString(meta, "notes"),
+		background: takeString(meta, "background"),
+		transition: takeKnownStringWithWarning(meta, "transition", SLIDE_TRANSITIONS, "none", warnings, "unknown-transition", input.slideIndex) ?? input.fallbackTransition,
+		transitionDuration: takeTransitionDuration(meta, warnings, input.slideIndex) ?? input.fallbackTransitionDuration,
+		transitionEasing: takeTransitionEasing(meta, warnings, input.slideIndex) ?? input.fallbackTransitionEasing,
+		meta
+	};
 }
 function addUnknownFrontmatterWarnings(warnings, meta, scope, slideIndex) {
-  for (const key of Object.keys(meta)) {
-    warnings.push({
-      code: "unknown-frontmatter-key",
-      message: `Unknown ${scope} frontmatter key "${key}" is preserved in meta.`,
-      ...slideIndex !== void 0 ? { slideIndex } : {}
-    });
-  }
+	for (const key of Object.keys(meta)) warnings.push({
+		code: "unknown-frontmatter-key",
+		message: `Unknown ${scope} frontmatter key "${key}" is preserved in meta.`,
+		...slideIndex !== void 0 ? { slideIndex } : {}
+	});
 }
 function splitSlideSources(source) {
-  const lines = source.replace(/\r\n/g, "\n").trim().split("\n");
-  const slides = [];
-  let current = [];
-  let cursor = 0;
-  while (cursor < lines.length) {
-    if (isFence(lines[cursor])) {
-      if (looksLikeFrontmatterFence(lines, cursor) && findFrontmatterEnd(lines, cursor) === -1) {
-        throw new CompileError("Frontmatter block is not closed.", "frontmatter-unclosed");
-      }
-      if (isFrontmatterStart(lines, cursor)) {
-        if (hasMeaningfulLines(current)) {
-          slides.push(current.join("\n").trim());
-        }
-        current = [];
-        const frontmatterEnd = findFrontmatterEnd(lines, cursor);
-        current.push(...lines.slice(cursor, frontmatterEnd + 1));
-        cursor = frontmatterEnd + 1;
-        continue;
-      }
-      if (hasMeaningfulLines(current)) {
-        slides.push(current.join("\n").trim());
-        current = [];
-      }
-      cursor += 1;
-      continue;
-    }
-    current.push(lines[cursor]);
-    cursor += 1;
-  }
-  if (hasMeaningfulLines(current)) {
-    slides.push(current.join("\n").trim());
-  }
-  return slides;
+	const lines = source.replace(/\r\n/g, "\n").trim().split("\n");
+	const slides = [];
+	let current = [];
+	let cursor = 0;
+	while (cursor < lines.length) {
+		if (isFence(lines[cursor])) {
+			if (looksLikeFrontmatterFence(lines, cursor) && findFrontmatterEnd(lines, cursor) === -1) throw new CompileError("Frontmatter block is not closed.", "frontmatter-unclosed");
+			if (isFrontmatterStart(lines, cursor)) {
+				if (hasMeaningfulLines(current)) slides.push(current.join("\n").trim());
+				current = [];
+				const frontmatterEnd = findFrontmatterEnd(lines, cursor);
+				current.push(...lines.slice(cursor, frontmatterEnd + 1));
+				cursor = frontmatterEnd + 1;
+				continue;
+			}
+			if (hasMeaningfulLines(current)) {
+				slides.push(current.join("\n").trim());
+				current = [];
+			}
+			cursor += 1;
+			continue;
+		}
+		current.push(lines[cursor]);
+		cursor += 1;
+	}
+	if (hasMeaningfulLines(current)) slides.push(current.join("\n").trim());
+	return slides;
 }
 function parseFrontmatterAttrs(source) {
-  const attrs = {};
-  const lines = source.split("\n");
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = lines[index];
-    const match = /^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
-    if (!match) {
-      if (line.trim()) {
-        throw new CompileError(`Invalid frontmatter line ${index + 1}: "${line.trim()}"`, "frontmatter-invalid-line");
-      }
-      continue;
-    }
-    const key = match[1];
-    const value = match[2];
-    if (value === "|") {
-      const block = [];
-      index += 1;
-      while (index < lines.length && /^\s+/.test(lines[index])) {
-        block.push(lines[index].trim());
-        index += 1;
-      }
-      index -= 1;
-      attrs[key] = block.join("\n").trim();
-      continue;
-    }
-    if (value.trim() === "") {
-      const nested = [];
-      index += 1;
-      while (index < lines.length && /^\s+/.test(lines[index])) {
-        nested.push(lines[index]);
-        index += 1;
-      }
-      index -= 1;
-      attrs[key] = parseNestedFrontmatterValue(nested);
-      continue;
-    }
-    attrs[key] = parseScalar(value);
-  }
-  return attrs;
+	const attrs = {};
+	const lines = source.split("\n");
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		const match = /^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
+		if (!match) {
+			if (line.trim()) throw new CompileError(`Invalid frontmatter line ${index + 1}: "${line.trim()}"`, "frontmatter-invalid-line");
+			continue;
+		}
+		const key = match[1];
+		const value = match[2];
+		if (value === "|") {
+			const block = [];
+			index += 1;
+			while (index < lines.length && /^\s+/.test(lines[index])) {
+				block.push(lines[index].trim());
+				index += 1;
+			}
+			index -= 1;
+			attrs[key] = block.join("\n").trim();
+			continue;
+		}
+		if (value.trim() === "") {
+			const nested = [];
+			index += 1;
+			while (index < lines.length && /^\s+/.test(lines[index])) {
+				nested.push(lines[index]);
+				index += 1;
+			}
+			index -= 1;
+			attrs[key] = parseNestedFrontmatterValue(nested);
+			continue;
+		}
+		attrs[key] = parseScalar(value);
+	}
+	return attrs;
 }
 function isFrontmatterStart(lines, index) {
-  return looksLikeFrontmatterFence(lines, index) && findFrontmatterEnd(lines, index) > index;
+	return looksLikeFrontmatterFence(lines, index) && findFrontmatterEnd(lines, index) > index;
 }
 function looksLikeFrontmatterFence(lines, index) {
-  if (!isFence(lines[index])) return false;
-  const next = lines[index + 1];
-  return next != null && /^([A-Za-z_][A-Za-z0-9_-]*):\s*/.test(next);
+	if (!isFence(lines[index])) return false;
+	const next = lines[index + 1];
+	return next != null && /^([A-Za-z_][A-Za-z0-9_-]*):\s*/.test(next);
 }
 function findFrontmatterEnd(lines, start) {
-  for (let index = start + 1; index < lines.length; index += 1) {
-    if (isFence(lines[index])) return index;
-  }
-  return -1;
+	for (let index = start + 1; index < lines.length; index += 1) if (isFence(lines[index])) return index;
+	return -1;
 }
 function isFence(line) {
-  return /^---\s*$/.test(line);
+	return /^---\s*$/.test(line);
 }
 function hasMeaningfulLines(lines) {
-  return lines.some((line) => line.trim() !== "");
+	return lines.some((line) => line.trim() !== "");
 }
 function parseNestedFrontmatterValue(lines) {
-  const meaningful = lines.map((line) => line.trim()).filter(Boolean);
-  if (meaningful.every((line) => line.startsWith("- "))) {
-    return meaningful.map((line) => parseScalar(line.slice(2)));
-  }
-  const object = {};
-  for (const line of meaningful) {
-    const match = /^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
-    if (!match) {
-      throw new CompileError(`Invalid nested frontmatter line: "${line}"`, "frontmatter-invalid-line");
-    }
-    object[match[1]] = parseScalar(match[2]);
-  }
-  return object;
+	const meaningful = lines.map((line) => line.trim()).filter(Boolean);
+	if (meaningful.every((line) => line.startsWith("- "))) return meaningful.map((line) => parseScalar(line.slice(2)));
+	const object = {};
+	for (const line of meaningful) {
+		const match = /^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
+		if (!match) throw new CompileError(`Invalid nested frontmatter line: "${line}"`, "frontmatter-invalid-line");
+		object[match[1]] = parseScalar(match[2]);
+	}
+	return object;
 }
 function parseScalar(value) {
-  const trimmed = value.trim().replace(/^['"]|['"]$/g, "");
-  if (trimmed === "true") return true;
-  if (trimmed === "false") return false;
-  if (/^\[.*\]$/.test(trimmed)) {
-    return trimmed.slice(1, -1).split(",").map((item) => item.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
-  }
-  return trimmed;
+	const trimmed = value.trim().replace(/^['"]|['"]$/g, "");
+	if (trimmed === "true") return true;
+	if (trimmed === "false") return false;
+	if (/^\[.*\]$/.test(trimmed)) return trimmed.slice(1, -1).split(",").map((item) => item.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+	return trimmed;
 }
 function takeString(attrs, key) {
-  const value = attrs[key];
-  if (typeof value !== "string") return void 0;
-  delete attrs[key];
-  return value;
+	const value = attrs[key];
+	if (typeof value !== "string") return void 0;
+	delete attrs[key];
+	return value;
 }
 function takeKnownStringWithWarning(attrs, key, values, fallback, warnings, code, slideIndex) {
-  const value = attrs[key];
-  delete attrs[key];
-  if (value === void 0) return void 0;
-  if (typeof value === "string" && values.includes(value)) return value;
-  warnings.push({
-    code,
-    message: `Unknown ${key} value "${String(value)}"; using ${fallback}.`,
-    ...slideIndex !== void 0 ? { slideIndex } : {}
-  });
-  return fallback;
+	const value = attrs[key];
+	delete attrs[key];
+	if (value === void 0) return void 0;
+	if (typeof value === "string" && values.includes(value)) return value;
+	warnings.push({
+		code,
+		message: `Unknown ${key} value "${String(value)}"; using ${fallback}.`,
+		...slideIndex !== void 0 ? { slideIndex } : {}
+	});
+	return fallback;
 }
 function takeTransitionDuration(attrs, warnings, slideIndex) {
-  const value = attrs.transitionDuration;
-  delete attrs.transitionDuration;
-  if (value === void 0) return void 0;
-  if (typeof value === "string" && isValidTransitionDuration(value)) return value;
-  warnings.push({
-    code: "invalid-transition-duration",
-    message: `Invalid transitionDuration value "${String(value)}"; ignoring it.`,
-    ...slideIndex !== void 0 ? { slideIndex } : {}
-  });
-  return void 0;
+	const value = attrs.transitionDuration;
+	delete attrs.transitionDuration;
+	if (value === void 0) return void 0;
+	if (typeof value === "string" && isValidTransitionDuration(value)) return value;
+	warnings.push({
+		code: "invalid-transition-duration",
+		message: `Invalid transitionDuration value "${String(value)}"; ignoring it.`,
+		...slideIndex !== void 0 ? { slideIndex } : {}
+	});
 }
 function takeTransitionEasing(attrs, warnings, slideIndex) {
-  const value = attrs.transitionEasing;
-  delete attrs.transitionEasing;
-  if (value === void 0) return void 0;
-  if (typeof value === "string" && isValidTransitionEasing(value)) return value;
-  warnings.push({
-    code: "invalid-transition-easing",
-    message: `Invalid transitionEasing value "${String(value)}"; ignoring it.`,
-    ...slideIndex !== void 0 ? { slideIndex } : {}
-  });
-  return void 0;
+	const value = attrs.transitionEasing;
+	delete attrs.transitionEasing;
+	if (value === void 0) return void 0;
+	if (typeof value === "string" && isValidTransitionEasing(value)) return value;
+	warnings.push({
+		code: "invalid-transition-easing",
+		message: `Invalid transitionEasing value "${String(value)}"; ignoring it.`,
+		...slideIndex !== void 0 ? { slideIndex } : {}
+	});
 }
 function isValidTransitionDuration(value) {
-  return value.split(",").map((item) => item.trim()).every((item) => /^(?:\d+|\d*\.\d+)(?:ms|s)$/.test(item));
+	return value.split(",").map((item) => item.trim()).every((item) => /^(?:\d+|\d*\.\d+)(?:ms|s)$/.test(item));
 }
 function isValidTransitionEasing(value) {
-  const easing = value.trim();
-  return ["linear", "ease", "ease-in", "ease-out", "ease-in-out", "step-start", "step-end"].includes(easing) || /^cubic-bezier\(\s*-?(?:\d+|\d*\.\d+)\s*,\s*-?(?:\d+|\d*\.\d+)\s*,\s*-?(?:\d+|\d*\.\d+)\s*,\s*-?(?:\d+|\d*\.\d+)\s*\)$/.test(
-    easing
-  ) || /^steps\(\s*\d+\s*(?:,\s*(?:jump-start|jump-end|jump-none|jump-both|start|end))?\s*\)$/.test(easing) || /^linear\([^)]+\)$/.test(easing);
+	const easing = value.trim();
+	return [
+		"linear",
+		"ease",
+		"ease-in",
+		"ease-out",
+		"ease-in-out",
+		"step-start",
+		"step-end"
+	].includes(easing) || /^cubic-bezier\(\s*-?(?:\d+|\d*\.\d+)\s*,\s*-?(?:\d+|\d*\.\d+)\s*,\s*-?(?:\d+|\d*\.\d+)\s*,\s*-?(?:\d+|\d*\.\d+)\s*\)$/.test(easing) || /^steps\(\s*\d+\s*(?:,\s*(?:jump-start|jump-end|jump-none|jump-both|start|end))?\s*\)$/.test(easing) || /^linear\([^)]+\)$/.test(easing);
 }
 function takeStringOrStringArray(attrs, key) {
-  const value = attrs[key];
-  if (typeof value === "string") {
-    delete attrs[key];
-    return value;
-  }
-  if (Array.isArray(value)) {
-    delete attrs[key];
-    return value.map(String);
-  }
-  return void 0;
+	const value = attrs[key];
+	if (typeof value === "string") {
+		delete attrs[key];
+		return value;
+	}
+	if (Array.isArray(value)) {
+		delete attrs[key];
+		return value.map(String);
+	}
 }
 function takeBoolean(attrs, key) {
-  const value = attrs[key];
-  if (typeof value !== "boolean") return void 0;
-  delete attrs[key];
-  return value;
+	const value = attrs[key];
+	if (typeof value !== "boolean") return void 0;
+	delete attrs[key];
+	return value;
 }
-
-// src/deck/assets.ts
+//#endregion
+//#region src/deck/assets.ts
 function buildExternalAssetRefs(candidates) {
-  const refs = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
-    const type = assetRefType(candidate);
-    if (!type || refs.has(candidate)) continue;
-    const contentType = contentTypeForPath(candidate);
-    refs.set(candidate, {
-      sourcePath: candidate,
-      publicPath: candidate,
-      type,
-      ...contentType ? { contentType } : {}
-    });
-  }
-  return [...refs.values()];
+	const refs = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const type = assetRefType(candidate);
+		if (!type || refs.has(candidate)) continue;
+		const contentType = contentTypeForPath(candidate);
+		refs.set(candidate, {
+			sourcePath: candidate,
+			publicPath: candidate,
+			type,
+			...contentType ? { contentType } : {}
+		});
+	}
+	return [...refs.values()];
 }
 function addExternalAssetWarnings(warnings, assets) {
-  for (const asset of assets) {
-    if (asset.type !== "remote" && asset.type !== "r2") continue;
-    const label = asset.type === "r2" ? "R2" : "Remote";
-    warnings.push({
-      code: "external-asset-unverified",
-      message: `${label} asset existence cannot be verified at compile time: ${asset.sourcePath}`
-    });
-  }
+	for (const asset of assets) {
+		if (asset.type !== "remote" && asset.type !== "r2") continue;
+		const label = asset.type === "r2" ? "R2" : "Remote";
+		warnings.push({
+			code: "external-asset-unverified",
+			message: `${label} asset existence cannot be verified at compile time: ${asset.sourcePath}`
+		});
+	}
 }
 function collectMarkdownAssetCandidates(markdown) {
-  const candidates = [];
-  for (const match of markdown.matchAll(/^\s*(?:background|image|src|asset):\s*['"]?([^'"\n]+)['"]?\s*$/gim)) {
-    candidates.push(match[1].trim());
-  }
-  for (const match of markdown.matchAll(/!\[[^\]]*\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g)) {
-    candidates.push(match[1].trim());
-  }
-  for (const match of markdown.matchAll(/\b(?:src|href|image|background)=["']([^"']+)["']/g)) {
-    candidates.push(match[1].trim());
-  }
-  return candidates;
+	const candidates = [];
+	for (const match of markdown.matchAll(/^\s*(?:background|image|src|asset):\s*['"]?([^'"\n]+)['"]?\s*$/gim)) candidates.push(match[1].trim());
+	for (const match of markdown.matchAll(/!\[[^\]]*\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g)) candidates.push(match[1].trim());
+	for (const match of markdown.matchAll(/\b(?:src|href|image|background)=["']([^"']+)["']/g)) candidates.push(match[1].trim());
+	return candidates;
 }
 function collectFrontmatterAssetCandidates(value) {
-  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
-  if (typeof value === "string") return [value.trim()].filter(Boolean);
-  return [];
+	if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
+	if (typeof value === "string") return [value.trim()].filter(Boolean);
+	return [];
 }
 function contentTypeForPath(path) {
-  const pathname = path.replace(/\?.*$/, "").toLowerCase();
-  if (/\.png(?:#.*)?$/.test(pathname)) return "image/png";
-  if (/\.jpe?g(?:#.*)?$/.test(pathname)) return "image/jpeg";
-  if (/\.gif(?:#.*)?$/.test(pathname)) return "image/gif";
-  if (/\.svg(?:#.*)?$/.test(pathname)) return "image/svg+xml";
-  if (/\.webp(?:#.*)?$/.test(pathname)) return "image/webp";
-  return void 0;
+	const pathname = path.replace(/\?.*$/, "").toLowerCase();
+	if (/\.png(?:#.*)?$/.test(pathname)) return "image/png";
+	if (/\.jpe?g(?:#.*)?$/.test(pathname)) return "image/jpeg";
+	if (/\.gif(?:#.*)?$/.test(pathname)) return "image/gif";
+	if (/\.svg(?:#.*)?$/.test(pathname)) return "image/svg+xml";
+	if (/\.webp(?:#.*)?$/.test(pathname)) return "image/webp";
 }
 function assetRefType(value) {
-  if (/^https?:\/\//i.test(value)) return "remote";
-  if (/^r2:\/\//i.test(value)) return "r2";
-  if (value.startsWith("/")) return "public";
-  return void 0;
+	if (/^https?:\/\//i.test(value)) return "remote";
+	if (/^r2:\/\//i.test(value)) return "r2";
+	if (value.startsWith("/")) return "public";
 }
-
-// src/deck/speaker-notes.ts
+//#endregion
+//#region src/deck/speaker-notes.ts
 function extractMdxCommentSpeakerNotes(source) {
-  const notes = [];
-  const body = source.replace(/\{\/\*([\s\S]*?)\*\/\}/g, (_match, rawNote) => {
-    const note = normalizeSpeakerNote(rawNote);
-    if (note) notes.push(note);
-    return "";
-  });
-  return {
-    body,
-    ...notes.length ? { notes: notes.join("\n\n") } : {}
-  };
+	const notes = [];
+	return {
+		body: source.replace(/\{\/\*([\s\S]*?)\*\/\}/g, (_match, rawNote) => {
+			const note = normalizeSpeakerNote(rawNote);
+			if (note) notes.push(note);
+			return "";
+		}),
+		...notes.length ? { notes: notes.join("\n\n") } : {}
+	};
 }
 function combineSpeakerNotes(...notes) {
-  const combined = notes.map((note) => note?.trim()).filter((note) => Boolean(note));
-  return combined.length ? combined.join("\n\n") : void 0;
+	const combined = notes.map((note) => note?.trim()).filter((note) => Boolean(note));
+	return combined.length ? combined.join("\n\n") : void 0;
 }
 function normalizeSpeakerNote(value) {
-  return value.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).join("\n").trim();
+	return value.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).join("\n").trim();
 }
-
-// src/parser/parser.ts
-import { unified } from "unified";
-import remarkGfm from "remark-gfm";
-import remarkMdx from "remark-mdx";
-import remarkParse from "remark-parse";
-var slideSeparator = /^---\s*$/m;
+//#endregion
+//#region src/parser/parser.ts
+const slideSeparator = /^---\s*$/m;
 function parseDeckWithWarnings(markdown) {
-  const normalized = markdown.replace(/\r\n/g, "\n").trim();
-  const chunks = normalized.length > 0 ? normalized.split(slideSeparator) : [""];
-  const parsedSlides = chunks.map((chunk, index) => parseSlide(chunk.trim(), index)).filter(({ slide }) => slide.raw.length > 0 || slide.blocks.length > 0 || slide.nodes.length > 0);
-  return {
-    slides: parsedSlides.map(({ slide }) => slide),
-    warnings: parsedSlides.flatMap(({ warnings }) => warnings)
-  };
+	const normalized = markdown.replace(/\r\n/g, "\n").trim();
+	const parsedSlides = (normalized.length > 0 ? normalized.split(slideSeparator) : [""]).map((chunk, index) => parseSlide(chunk.trim(), index)).filter(({ slide }) => slide.raw.length > 0 || slide.blocks.length > 0 || slide.nodes.length > 0);
+	return {
+		slides: parsedSlides.map(({ slide }) => slide),
+		warnings: parsedSlides.flatMap(({ warnings }) => warnings)
+	};
 }
 function parseSlide(source, index) {
-  const { attrs, body } = readSlideAttributes(source);
-  const parsed = parseContent(body, index);
-  const firstHeading = parsed.blocks.find((block) => block.type === "heading");
-  return {
-    slide: {
-      index,
-      title: stringAttr(attrs.title) ?? firstHeading?.text,
-      layout: stringAttr(attrs.layout) ?? (index === 0 ? "cover" : "default"),
-      className: stringAttr(attrs.class),
-      blocks: parsed.blocks,
-      nodes: parsed.nodes,
-      raw: source
-    },
-    warnings: parsed.warnings
-  };
+	const { attrs, body } = readSlideAttributes(source);
+	const parsed = parseContent(body, index);
+	const firstHeading = parsed.blocks.find((block) => block.type === "heading");
+	return {
+		slide: {
+			index,
+			title: stringAttr(attrs.title) ?? firstHeading?.text,
+			layout: stringAttr(attrs.layout) ?? (index === 0 ? "cover" : "default"),
+			className: stringAttr(attrs.class),
+			blocks: parsed.blocks,
+			nodes: parsed.nodes,
+			raw: source
+		},
+		warnings: parsed.warnings
+	};
 }
 function readSlideAttributes(source) {
-  const lines = source.split("\n");
-  const attrs = {};
-  let cursor = 0;
-  while (cursor < lines.length) {
-    const line = lines[cursor];
-    const match = /^(title|layout|class):\s*(.+)$/.exec(line);
-    if (!match) break;
-    attrs[match[1]] = match[2].trim().replace(/^['"]|['"]$/g, "");
-    cursor += 1;
-  }
-  return { attrs, body: lines.slice(cursor).join("\n").trim() };
+	const lines = source.split("\n");
+	const attrs = {};
+	let cursor = 0;
+	while (cursor < lines.length) {
+		const line = lines[cursor];
+		const match = /^(title|layout|class):\s*(.+)$/.exec(line);
+		if (!match) break;
+		attrs[match[1]] = match[2].trim().replace(/^['"]|['"]$/g, "");
+		cursor += 1;
+	}
+	return {
+		attrs,
+		body: lines.slice(cursor).join("\n").trim()
+	};
 }
 function parseContent(body, slideIndex) {
-  const { root, warnings: parseWarnings } = parseMarkdownTree(body, slideIndex);
-  const blockResults = (root.children ?? []).map((child) => toBlocks(child, slideIndex, body));
-  const nodeResults = (root.children ?? []).map((child) => toNodes(child, slideIndex, body));
-  return {
-    blocks: blockResults.flatMap(({ blocks }) => blocks),
-    nodes: nodeResults.flatMap(({ nodes }) => nodes),
-    warnings: [
-      ...fenceWarningsFor(body, slideIndex),
-      ...parseWarnings,
-      ...blockResults.flatMap(({ warnings }) => warnings),
-      ...nodeResults.flatMap(({ warnings }) => warnings)
-    ]
-  };
+	const { root, warnings: parseWarnings } = parseMarkdownTree(body, slideIndex);
+	const blockResults = (root.children ?? []).map((child) => toBlocks(child, slideIndex, body));
+	const nodeResults = (root.children ?? []).map((child) => toNodes(child, slideIndex, body));
+	return {
+		blocks: blockResults.flatMap(({ blocks }) => blocks),
+		nodes: nodeResults.flatMap(({ nodes }) => nodes),
+		warnings: [
+			...fenceWarningsFor(body, slideIndex),
+			...parseWarnings,
+			...blockResults.flatMap(({ warnings }) => warnings),
+			...nodeResults.flatMap(({ warnings }) => warnings)
+		]
+	};
 }
 function parseMarkdownTree(body, slideIndex) {
-  try {
-    return {
-      root: unified().use(remarkParse).use(remarkGfm).use(remarkMdx).parse(body),
-      warnings: []
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown MDX parse error";
-    return {
-      root: unified().use(remarkParse).use(remarkGfm).parse(body),
-      warnings: [parserWarning("mdx-parse-error", `Slide ${slideIndex + 1}: ${message}`, slideIndex)]
-    };
-  }
+	try {
+		return {
+			root: unified().use(remarkParse).use(remarkGfm).use(remarkMdx).parse(body),
+			warnings: []
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown MDX parse error";
+		return {
+			root: unified().use(remarkParse).use(remarkGfm).parse(body),
+			warnings: [parserWarning("mdx-parse-error", `Slide ${slideIndex + 1}: ${message}`, slideIndex)]
+		};
+	}
 }
 function fenceWarningsFor(body, slideIndex) {
-  let openFence;
-  for (const line of body.split("\n")) {
-    const match = /^(```|~~~)/.exec(line);
-    if (!match) continue;
-    if (!openFence) {
-      openFence = match[1];
-      continue;
-    }
-    if (line.startsWith(openFence)) openFence = void 0;
-  }
-  if (!openFence) return [];
-  return [parserWarning("code-fence-unclosed", `Slide ${slideIndex + 1}: code fence is not closed.`, slideIndex)];
+	let openFence;
+	for (const line of body.split("\n")) {
+		const match = /^(```|~~~)/.exec(line);
+		if (!match) continue;
+		if (!openFence) {
+			openFence = match[1];
+			continue;
+		}
+		if (line.startsWith(openFence)) openFence = void 0;
+	}
+	if (!openFence) return [];
+	return [parserWarning("code-fence-unclosed", `Slide ${slideIndex + 1}: code fence is not closed.`, slideIndex)];
 }
 function toBlocks(node, slideIndex, source) {
-  switch (node.type) {
-    case "heading":
-      return blockResult([{ type: "heading", depth: headingDepth(node.depth), text: textContent(node) }]);
-    case "paragraph": {
-      const image = soleImage(node);
-      if (image) {
-        return blockResult([
-          {
-            type: "image",
-            alt: image.alt ?? "",
-            src: image.url ?? "",
-            ...image.title ? { title: image.title } : {}
-          }
-        ]);
-      }
-      return blockResult([{ type: "paragraph", text: textContent(node).replace(/\s+/g, " ").trim() }]);
-    }
-    case "list":
-      return blockResult([
-        {
-          type: "list",
-          ordered: node.ordered === true,
-          items: (node.children ?? []).map((item) => taskListItemText(item)).filter(Boolean)
-        }
-      ]);
-    case "code":
-      return blockResult([{ type: "code", lang: node.lang ?? void 0, code: node.value ?? "" }]);
-    case "blockquote":
-      return blockResult([{ type: "blockquote", text: textContent(node).trim() }]);
-    case "table":
-      return blockResult([tableBlock(node)]);
-    case "mdxJsxFlowElement":
-    case "mdxJsxTextElement":
-      return jsxElementBlock(node, slideIndex, source);
-    case "mdxjsEsm":
-    case "mdxFlowExpression":
-    case "mdxTextExpression":
-    case "thematicBreak":
-      return blockResult([]);
-    default:
-      return blockResult(textContent(node).trim() ? [{ type: "paragraph", text: textContent(node).trim() }] : []);
-  }
+	switch (node.type) {
+		case "heading": return blockResult([{
+			type: "heading",
+			depth: headingDepth(node.depth),
+			text: textContent(node)
+		}]);
+		case "paragraph": {
+			const image = soleImage(node);
+			if (image) return blockResult([{
+				type: "image",
+				alt: image.alt ?? "",
+				src: image.url ?? "",
+				...image.title ? { title: image.title } : {}
+			}]);
+			return blockResult([{
+				type: "paragraph",
+				text: textContent(node).replace(/\s+/g, " ").trim()
+			}]);
+		}
+		case "list": return blockResult([{
+			type: "list",
+			ordered: node.ordered === true,
+			items: (node.children ?? []).map((item) => taskListItemText(item)).filter(Boolean)
+		}]);
+		case "code": return blockResult([{
+			type: "code",
+			lang: node.lang ?? void 0,
+			code: node.value ?? ""
+		}]);
+		case "blockquote": return blockResult([{
+			type: "blockquote",
+			text: textContent(node).trim()
+		}]);
+		case "table": return blockResult([tableBlock(node)]);
+		case "mdxJsxFlowElement":
+		case "mdxJsxTextElement": return jsxElementBlock(node, slideIndex, source);
+		case "mdxjsEsm":
+		case "mdxFlowExpression":
+		case "mdxTextExpression":
+		case "thematicBreak": return blockResult([]);
+		default: return blockResult(textContent(node).trim() ? [{
+			type: "paragraph",
+			text: textContent(node).trim()
+		}] : []);
+	}
 }
 function jsxElementBlock(node, slideIndex, source) {
-  const name = node.name ?? "";
-  if (!name) return blockResult([]);
-  if (isComponentName(name)) {
-    const parsedProps = parseProps(node.attributes ?? [], slideIndex, name);
-    return blockResult(
-      [
-        {
-          type: "component",
-          name,
-          props: parsedProps.props,
-          raw: sourceForNode(node, source) ?? `<${name} />`
-        }
-      ],
-      parsedProps.warnings
-    );
-  }
-  return blockResult([{ type: "paragraph", text: textContent(node).trim() }]);
+	const name = node.name ?? "";
+	if (!name) return blockResult([]);
+	if (isComponentName(name)) {
+		const parsedProps = parseProps(node.attributes ?? [], slideIndex, name);
+		return blockResult([{
+			type: "component",
+			name,
+			props: parsedProps.props,
+			raw: sourceForNode(node, source) ?? `<${name} />`
+		}], parsedProps.warnings);
+	}
+	return blockResult([{
+		type: "paragraph",
+		text: textContent(node).trim()
+	}]);
 }
 function toNodes(node, slideIndex, source) {
-  switch (node.type) {
-    case "text":
-      return nodeResult(node.value ? [{ type: "text", value: node.value }] : []);
-    case "emphasis":
-      return elementNodeResult(node, "em", slideIndex, source);
-    case "strong":
-      return elementNodeResult(node, "strong", slideIndex, source);
-    case "delete":
-      return elementNodeResult(node, "del", slideIndex, source);
-    case "inlineCode":
-      return nodeResult([{ type: "element", tag: "code", props: {}, children: [{ type: "text", value: node.value ?? "" }] }]);
-    case "break":
-      return nodeResult([{ type: "element", tag: "br", props: {}, children: [] }]);
-    case "heading":
-      return elementNodeResult(node, `h${headingDepth(node.depth)}`, slideIndex, source);
-    case "paragraph": {
-      if (soleImage(node)) return childrenToNodes(node, slideIndex, source);
-      if (isJsxOnlyParagraph(node)) return childrenToNodes(node, slideIndex, source);
-      return elementNodeResult(node, "p", slideIndex, source);
-    }
-    case "list": {
-      const tag = node.ordered === true ? "ol" : "ul";
-      const items = node.children ?? [];
-      const childResults = items.map((child) => childrenToNodes(child, slideIndex, source));
-      return nodeResult(
-        [
-          {
-            type: "element",
-            tag,
-            props: {},
-            children: childResults.map(({ nodes }, itemIndex) => listItemNode(nodes, items[itemIndex]?.checked))
-          }
-        ],
-        childResults.flatMap(({ warnings }) => warnings)
-      );
-    }
-    case "listItem":
-      return childrenToNodes(node, slideIndex, source);
-    case "code":
-      return nodeResult([{ type: "code", lang: node.lang ?? void 0, value: node.value ?? "" }]);
-    case "blockquote":
-      return elementNodeResult(node, "blockquote", slideIndex, source);
-    case "image":
-      return nodeResult([
-        {
-          type: "element",
-          tag: "img",
-          props: { src: node.url ?? "", alt: node.alt ?? "", ...node.title ? { title: node.title } : {} },
-          children: []
-        }
-      ]);
-    case "link":
-      return elementNodeResult(node, "a", slideIndex, source, { href: node.url ?? "" });
-    case "table":
-      return tableNodes(node, slideIndex, source);
-    case "mdxJsxFlowElement":
-    case "mdxJsxTextElement":
-      return jsxElementNodes(node, slideIndex, source);
-    case "mdxjsEsm":
-      return nodeResult(
-        [],
-        [
-          parserWarning(
-            "mdx-import-export-ignored",
-            `Slide ${slideIndex + 1}: MDX import/export syntax is ignored.`,
-            slideIndex
-          )
-        ]
-      );
-    case "mdxFlowExpression":
-    case "mdxTextExpression":
-      return nodeResult(
-        [],
-        [
-          parserWarning(
-            "mdx-expression-ignored",
-            `Slide ${slideIndex + 1}: MDX JavaScript expressions are ignored.`,
-            slideIndex
-          )
-        ]
-      );
-    case "thematicBreak":
-      return nodeResult([{ type: "element", tag: "hr", props: {}, children: [] }]);
-    default:
-      return childrenToNodes(node, slideIndex, source);
-  }
+	switch (node.type) {
+		case "text": return nodeResult(node.value ? [{
+			type: "text",
+			value: node.value
+		}] : []);
+		case "emphasis": return elementNodeResult(node, "em", slideIndex, source);
+		case "strong": return elementNodeResult(node, "strong", slideIndex, source);
+		case "delete": return elementNodeResult(node, "del", slideIndex, source);
+		case "inlineCode": return nodeResult([{
+			type: "element",
+			tag: "code",
+			props: {},
+			children: [{
+				type: "text",
+				value: node.value ?? ""
+			}]
+		}]);
+		case "break": return nodeResult([{
+			type: "element",
+			tag: "br",
+			props: {},
+			children: []
+		}]);
+		case "heading": return elementNodeResult(node, `h${headingDepth(node.depth)}`, slideIndex, source);
+		case "paragraph":
+			if (soleImage(node)) return childrenToNodes(node, slideIndex, source);
+			if (isJsxOnlyParagraph(node)) return childrenToNodes(node, slideIndex, source);
+			return elementNodeResult(node, "p", slideIndex, source);
+		case "list": {
+			const tag = node.ordered === true ? "ol" : "ul";
+			const items = node.children ?? [];
+			const childResults = items.map((child) => childrenToNodes(child, slideIndex, source));
+			return nodeResult([{
+				type: "element",
+				tag,
+				props: {},
+				children: childResults.map(({ nodes }, itemIndex) => listItemNode(nodes, items[itemIndex]?.checked))
+			}], childResults.flatMap(({ warnings }) => warnings));
+		}
+		case "listItem": return childrenToNodes(node, slideIndex, source);
+		case "code": return nodeResult([{
+			type: "code",
+			lang: node.lang ?? void 0,
+			value: node.value ?? ""
+		}]);
+		case "blockquote": return elementNodeResult(node, "blockquote", slideIndex, source);
+		case "image": return nodeResult([{
+			type: "element",
+			tag: "img",
+			props: {
+				src: node.url ?? "",
+				alt: node.alt ?? "",
+				...node.title ? { title: node.title } : {}
+			},
+			children: []
+		}]);
+		case "link": return elementNodeResult(node, "a", slideIndex, source, { href: node.url ?? "" });
+		case "table": return tableNodes(node, slideIndex, source);
+		case "mdxJsxFlowElement":
+		case "mdxJsxTextElement": return jsxElementNodes(node, slideIndex, source);
+		case "mdxjsEsm": return nodeResult([], [parserWarning("mdx-import-export-ignored", `Slide ${slideIndex + 1}: MDX import/export syntax is ignored.`, slideIndex)]);
+		case "mdxFlowExpression":
+		case "mdxTextExpression": return nodeResult([], [parserWarning("mdx-expression-ignored", `Slide ${slideIndex + 1}: MDX JavaScript expressions are ignored.`, slideIndex)]);
+		case "thematicBreak": return nodeResult([{
+			type: "element",
+			tag: "hr",
+			props: {},
+			children: []
+		}]);
+		default: return childrenToNodes(node, slideIndex, source);
+	}
 }
 function elementNodeResult(node, tag, slideIndex, source, props = {}) {
-  const children = childrenToNodes(node, slideIndex, source);
-  return nodeResult(
-    [
-      {
-        type: "element",
-        tag,
-        props,
-        children: children.nodes
-      }
-    ],
-    children.warnings
-  );
+	const children = childrenToNodes(node, slideIndex, source);
+	return nodeResult([{
+		type: "element",
+		tag,
+		props,
+		children: children.nodes
+	}], children.warnings);
 }
 function listItemNode(children, checked) {
-  if (typeof checked !== "boolean") return { type: "element", tag: "li", props: {}, children };
-  return {
-    type: "element",
-    tag: "li",
-    props: { class: "task-list-item" },
-    children: [
-      {
-        type: "element",
-        tag: "input",
-        props: { type: "checkbox", disabled: true, ...checked ? { checked: true } : {} },
-        children: []
-      },
-      { type: "text", value: " " },
-      ...children
-    ]
-  };
+	if (typeof checked !== "boolean") return {
+		type: "element",
+		tag: "li",
+		props: {},
+		children
+	};
+	return {
+		type: "element",
+		tag: "li",
+		props: { class: "task-list-item" },
+		children: [
+			{
+				type: "element",
+				tag: "input",
+				props: {
+					type: "checkbox",
+					disabled: true,
+					...checked ? { checked: true } : {}
+				},
+				children: []
+			},
+			{
+				type: "text",
+				value: " "
+			},
+			...children
+		]
+	};
 }
 function tableNodes(node, slideIndex, source) {
-  const align = node.align ?? [];
-  const [headerRow, ...bodyRows] = node.children ?? [];
-  const headerResult = headerRow ? tableRowCells(headerRow, "th", align, slideIndex, source) : cellsResult([]);
-  const bodyResults = bodyRows.map((row) => tableRowCells(row, "td", align, slideIndex, source));
-  return nodeResult(
-    [
-      {
-        type: "element",
-        tag: "table",
-        props: {},
-        children: [
-          {
-            type: "element",
-            tag: "thead",
-            props: {},
-            children: [{ type: "element", tag: "tr", props: {}, children: headerResult.cells }]
-          },
-          {
-            type: "element",
-            tag: "tbody",
-            props: {},
-            children: bodyResults.map(({ cells }) => ({ type: "element", tag: "tr", props: {}, children: cells }))
-          }
-        ]
-      }
-    ],
-    [...headerResult.warnings, ...bodyResults.flatMap(({ warnings }) => warnings)]
-  );
+	const align = node.align ?? [];
+	const [headerRow, ...bodyRows] = node.children ?? [];
+	const headerResult = headerRow ? tableRowCells(headerRow, "th", align, slideIndex, source) : cellsResult([]);
+	const bodyResults = bodyRows.map((row) => tableRowCells(row, "td", align, slideIndex, source));
+	return nodeResult([{
+		type: "element",
+		tag: "table",
+		props: {},
+		children: [{
+			type: "element",
+			tag: "thead",
+			props: {},
+			children: [{
+				type: "element",
+				tag: "tr",
+				props: {},
+				children: headerResult.cells
+			}]
+		}, {
+			type: "element",
+			tag: "tbody",
+			props: {},
+			children: bodyResults.map(({ cells }) => ({
+				type: "element",
+				tag: "tr",
+				props: {},
+				children: cells
+			}))
+		}]
+	}], [...headerResult.warnings, ...bodyResults.flatMap(({ warnings }) => warnings)]);
 }
 function cellsResult(cells, emittedWarnings = []) {
-  return { cells, warnings: emittedWarnings };
+	return {
+		cells,
+		warnings: emittedWarnings
+	};
 }
 function tableRowCells(row, tag, align, slideIndex, source) {
-  const results = (row.children ?? []).map((cell, cellIndex) => {
-    const children = childrenToNodes(cell, slideIndex, source);
-    const cellAlign = toTableAlign(align[cellIndex]);
-    return {
-      cell: {
-        type: "element",
-        tag,
-        props: cellAlign ? { style: `text-align:${cellAlign}` } : {},
-        children: children.nodes
-      },
-      warnings: children.warnings
-    };
-  });
-  return cellsResult(
-    results.map(({ cell }) => cell),
-    results.flatMap(({ warnings }) => warnings)
-  );
+	const results = (row.children ?? []).map((cell, cellIndex) => {
+		const children = childrenToNodes(cell, slideIndex, source);
+		const cellAlign = toTableAlign(align[cellIndex]);
+		return {
+			cell: {
+				type: "element",
+				tag,
+				props: cellAlign ? { style: `text-align:${cellAlign}` } : {},
+				children: children.nodes
+			},
+			warnings: children.warnings
+		};
+	});
+	return cellsResult(results.map(({ cell }) => cell), results.flatMap(({ warnings }) => warnings));
 }
 function jsxElementNodes(node, slideIndex, source) {
-  const name = node.name ?? "";
-  if (!name) return childrenToNodes(node, slideIndex, source);
-  if (isUnsafeHtmlElement(name)) {
-    return nodeResult([{ type: "text", value: sourceForNode(node, source) ?? textContent(node) }]);
-  }
-  const parsedProps = parseProps(node.attributes ?? [], slideIndex, name);
-  const parsedChildren = childrenToNodes(node, slideIndex, source);
-  const children = parsedChildren.nodes.filter((child) => child.type !== "text" || child.value.trim() !== "");
-  const warnings = [...parsedProps.warnings, ...parsedChildren.warnings];
-  if (isComponentName(name)) return nodeResult([{ type: "component", name, props: parsedProps.props, children }], warnings);
-  return nodeResult([{ type: "element", tag: name, props: parsedProps.props, children }], warnings);
+	const name = node.name ?? "";
+	if (!name) return childrenToNodes(node, slideIndex, source);
+	if (isUnsafeHtmlElement(name)) return nodeResult([{
+		type: "text",
+		value: sourceForNode(node, source) ?? textContent(node)
+	}]);
+	const parsedProps = parseProps(node.attributes ?? [], slideIndex, name);
+	const parsedChildren = childrenToNodes(node, slideIndex, source);
+	const children = parsedChildren.nodes.filter((child) => child.type !== "text" || child.value.trim() !== "");
+	const warnings = [...parsedProps.warnings, ...parsedChildren.warnings];
+	if (isComponentName(name)) return nodeResult([{
+		type: "component",
+		name,
+		props: parsedProps.props,
+		children
+	}], warnings);
+	return nodeResult([{
+		type: "element",
+		tag: name,
+		props: parsedProps.props,
+		children
+	}], warnings);
 }
 function childrenToNodes(node, slideIndex, source) {
-  const results = (node.children ?? []).map((child) => toNodes(child, slideIndex, source));
-  return nodeResult(
-    results.flatMap(({ nodes }) => nodes),
-    results.flatMap(({ warnings }) => warnings)
-  );
+	const results = (node.children ?? []).map((child) => toNodes(child, slideIndex, source));
+	return nodeResult(results.flatMap(({ nodes }) => nodes), results.flatMap(({ warnings }) => warnings));
 }
 function parseProps(attributes, slideIndex, componentName) {
-  const props = {};
-  const warnings = attributes.flatMap((attr) => {
-    if (attr.type !== "mdxJsxAttribute" || !attr.name) return [];
-    if (attr.value === null || attr.value === void 0) {
-      props[attr.name] = true;
-      return [];
-    }
-    if (typeof attr.value === "string" || typeof attr.value === "number" || typeof attr.value === "boolean") {
-      props[attr.name] = attr.value;
-      return [];
-    }
-    return [
-      parserWarning(
-        "mdx-expression-prop-ignored",
-        `Slide ${slideIndex + 1}: MDX JavaScript expression props are ignored on ${ignoredPropTarget(componentName, attr.name)}.`,
-        slideIndex
-      )
-    ];
-  });
-  return { props, warnings };
+	const props = {};
+	return {
+		props,
+		warnings: attributes.flatMap((attr) => {
+			if (attr.type !== "mdxJsxAttribute" || !attr.name) return [];
+			if (attr.value === null || attr.value === void 0) {
+				props[attr.name] = true;
+				return [];
+			}
+			if (typeof attr.value === "string" || typeof attr.value === "number" || typeof attr.value === "boolean") {
+				props[attr.name] = attr.value;
+				return [];
+			}
+			return [parserWarning("mdx-expression-prop-ignored", `Slide ${slideIndex + 1}: MDX JavaScript expression props are ignored on ${ignoredPropTarget(componentName, attr.name)}.`, slideIndex)];
+		})
+	};
 }
 function blockResult(blocks, emittedWarnings = []) {
-  return { blocks, warnings: emittedWarnings };
+	return {
+		blocks,
+		warnings: emittedWarnings
+	};
 }
 function nodeResult(nodes, emittedWarnings = []) {
-  return { nodes, warnings: emittedWarnings };
+	return {
+		nodes,
+		warnings: emittedWarnings
+	};
 }
 function parserWarning(code, message, slideIndex) {
-  return { code, message, slideIndex };
+	return {
+		code,
+		message,
+		slideIndex
+	};
 }
 function ignoredPropTarget(componentName, propName) {
-  if (propName.startsWith("$")) return `${componentName} dynamic prop`;
-  return `${componentName}.${propName}`;
+	if (propName.startsWith("$")) return `${componentName} dynamic prop`;
+	return `${componentName}.${propName}`;
 }
 function textContent(node) {
-  if (typeof node.value === "string") return node.value;
-  if (node.type === "strong") return `**${(node.children ?? []).map(textContent).join("")}**`;
-  if (node.type === "emphasis") return `*${(node.children ?? []).map(textContent).join("")}*`;
-  if (node.type === "delete") return `~~${(node.children ?? []).map(textContent).join("")}~~`;
-  if (node.type === "inlineCode") return `\`${node.value ?? ""}\``;
-  if ((node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") && node.name && !isComponentName(node.name)) {
-    return `<${node.name}>${(node.children ?? []).map(textContent).join("")}</${node.name}>`;
-  }
-  return (node.children ?? []).map(textContent).join("");
+	if (typeof node.value === "string") return node.value;
+	if (node.type === "strong") return `**${(node.children ?? []).map(textContent).join("")}**`;
+	if (node.type === "emphasis") return `*${(node.children ?? []).map(textContent).join("")}*`;
+	if (node.type === "delete") return `~~${(node.children ?? []).map(textContent).join("")}~~`;
+	if (node.type === "inlineCode") return `\`${node.value ?? ""}\``;
+	if ((node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") && node.name && !isComponentName(node.name)) return `<${node.name}>${(node.children ?? []).map(textContent).join("")}</${node.name}>`;
+	return (node.children ?? []).map(textContent).join("");
 }
 function taskListItemText(item) {
-  const text = textContent(item).replace(/\s+/g, " ").trim();
-  if (typeof item.checked === "boolean") return `${item.checked ? "[x]" : "[ ]"} ${text}`.trim();
-  return text;
+	const text = textContent(item).replace(/\s+/g, " ").trim();
+	if (typeof item.checked === "boolean") return `${item.checked ? "[x]" : "[ ]"} ${text}`.trim();
+	return text;
 }
 function tableBlock(node) {
-  const rows = (node.children ?? []).map(
-    (row) => (row.children ?? []).map((cell) => textContent(cell).replace(/\s+/g, " ").trim())
-  );
-  const [header = [], ...bodyRows] = rows;
-  return {
-    type: "table",
-    align: (node.align ?? []).map(toTableAlign),
-    header,
-    rows: bodyRows
-  };
+	const [header = [], ...bodyRows] = (node.children ?? []).map((row) => (row.children ?? []).map((cell) => textContent(cell).replace(/\s+/g, " ").trim()));
+	return {
+		type: "table",
+		align: (node.align ?? []).map(toTableAlign),
+		header,
+		rows: bodyRows
+	};
 }
 function toTableAlign(value) {
-  return value === "left" || value === "center" || value === "right" ? value : void 0;
+	return value === "left" || value === "center" || value === "right" ? value : void 0;
 }
 function soleImage(node) {
-  const meaningful = (node.children ?? []).filter((child) => child.type !== "text" || child.value?.trim());
-  return meaningful.length === 1 && meaningful[0].type === "image" ? meaningful[0] : void 0;
+	const meaningful = (node.children ?? []).filter((child) => child.type !== "text" || child.value?.trim());
+	return meaningful.length === 1 && meaningful[0].type === "image" ? meaningful[0] : void 0;
 }
 function isJsxOnlyParagraph(node) {
-  const children = node.children ?? [];
-  return children.length > 0 && children.every(
-    (child) => child.type === "mdxJsxTextElement" || child.type === "mdxJsxFlowElement" || child.type === "text" && child.value?.trim() === ""
-  );
+	const children = node.children ?? [];
+	return children.length > 0 && children.every((child) => child.type === "mdxJsxTextElement" || child.type === "mdxJsxFlowElement" || child.type === "text" && child.value?.trim() === "");
 }
 function sourceForNode(node, source) {
-  const start = node.position?.start?.offset;
-  const end = node.position?.end?.offset;
-  return typeof start === "number" && typeof end === "number" ? source.slice(start, end) : void 0;
+	const start = node.position?.start?.offset;
+	const end = node.position?.end?.offset;
+	return typeof start === "number" && typeof end === "number" ? source.slice(start, end) : void 0;
 }
 function isComponentName(name) {
-  return /^[A-Z]/.test(name);
+	return /^[A-Z]/.test(name);
 }
 function isUnsafeHtmlElement(name) {
-  return /^(script|style|iframe|object|embed)$/i.test(name);
+	return /^(script|style|iframe|object|embed)$/i.test(name);
 }
 function headingDepth(value) {
-  if (value === 1 || value === 2 || value === 3) return value;
-  return 3;
+	if (value === 1 || value === 2 || value === 3) return value;
+	return 3;
 }
 function stringAttr(value) {
-  return value && value.length > 0 ? value : void 0;
+	return value && value.length > 0 ? value : void 0;
 }
-
-// src/generator/mdx/assets.ts
+//#endregion
+//#region src/generator/mdx/assets.ts
 function rewriteAssetUrls(source, assets) {
-  let result2 = source;
-  for (const asset of assets) {
-    const assetPath = localAssetRelativePath(asset.sourcePath);
-    result2 = result2.replaceAll(`./assets/${assetPath}`, asset.publicPath);
-    result2 = result2.replace(new RegExp(`(?<!/)assets/${escapeRegExp(assetPath)}`, "g"), asset.publicPath);
-  }
-  return result2;
+	let result = source;
+	for (const asset of assets) {
+		const assetPath = localAssetRelativePath(asset.sourcePath);
+		result = result.replaceAll(`./assets/${assetPath}`, asset.publicPath);
+		result = result.replace(new RegExp(`(?<!/)assets/${escapeRegExp(assetPath)}`, "g"), asset.publicPath);
+	}
+	return result;
 }
 function rewriteRelativeMdxImports(source, sourceDir, generatedDir) {
-  return source.replace(/(from\s+|import\s+)(["'])(\.[^"']+)\2/g, (_match, prefix, quote, specifier) => {
-    const target = normalizePath2(`${sourceDir}/${specifier}`);
-    return `${prefix}${quote}${toRelativeImportPath(generatedDir, target)}${quote}`;
-  });
+	return source.replace(/(from\s+|import\s+)(["'])(\.[^"']+)\2/g, (_match, prefix, quote, specifier) => {
+		return `${prefix}${quote}${toRelativeImportPath(generatedDir, normalizePath$3(`${sourceDir}/${specifier}`))}${quote}`;
+	});
 }
 function componentImportPath(outDir, sourcePath) {
-  if (!sourcePath) return void 0;
-  const source = sourcePath.replace(/\/index\.(tsx|ts|jsx|js)$/, "");
-  return toRelativeImportPath(outDir, source);
+	if (!sourcePath) return void 0;
+	return toRelativeImportPath(outDir, sourcePath.replace(/\/index\.(tsx|ts|jsx|js)$/, ""));
 }
-function dirname(path) {
-  const normalized = normalizePath2(path);
-  const index = normalized.lastIndexOf("/");
-  return index === -1 ? "." : normalized.slice(0, index);
+function dirname$2(path) {
+	const normalized = normalizePath$3(path);
+	const index = normalized.lastIndexOf("/");
+	return index === -1 ? "." : normalized.slice(0, index);
 }
 function localAssetRelativePath(sourcePath) {
-  const marker = "/assets/";
-  const normalized = normalizePath2(sourcePath);
-  const markerIndex = normalized.indexOf(marker);
-  return markerIndex === -1 ? normalized.split("/").at(-1) ?? normalized : normalized.slice(markerIndex + marker.length);
+	const marker = "/assets/";
+	const normalized = normalizePath$3(sourcePath);
+	const markerIndex = normalized.indexOf(marker);
+	return markerIndex === -1 ? normalized.split("/").at(-1) ?? normalized : normalized.slice(markerIndex + 8);
 }
-function normalizePath2(path) {
-  return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+function normalizePath$3(path) {
+	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
 }
 function toRelativeImportPath(fromDir, target) {
-  const fromParts = normalizePath2(fromDir).split("/").filter(Boolean);
-  const targetParts = normalizePath2(target).split("/").filter(Boolean);
-  while (fromParts.length > 0 && targetParts.length > 0 && fromParts[0] === targetParts[0]) {
-    fromParts.shift();
-    targetParts.shift();
-  }
-  const relative4 = [...fromParts.map(() => ".."), ...targetParts].join("/");
-  return relative4.startsWith(".") ? relative4 : `./${relative4 || "."}`;
+	const fromParts = normalizePath$3(fromDir).split("/").filter(Boolean);
+	const targetParts = normalizePath$3(target).split("/").filter(Boolean);
+	while (fromParts.length > 0 && targetParts.length > 0 && fromParts[0] === targetParts[0]) {
+		fromParts.shift();
+		targetParts.shift();
+	}
+	const relative = [...fromParts.map(() => ".."), ...targetParts].join("/");
+	return relative.startsWith(".") ? relative : `./${relative || "."}`;
 }
 function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-
-// src/generator/assets.ts
+//#endregion
+//#region src/generator/assets.ts
 async function buildAssetRefs(slug, assetPaths, input) {
-  return Promise.all(
-    assetPaths.map(async (sourcePath) => ({
-      sourcePath,
-      publicPath: `${normalizeMountPath(input.mountPath ?? `/${input.root}`)}/${encodeURIComponent(slug)}/assets/${assetName(
-        sourcePath,
-        input.root,
-        slug
-      )}`,
-      type: "local",
-      contentType: contentTypeForPath(sourcePath),
-      body: input.readBinary ? await input.readBinary(sourcePath) : void 0
-    }))
-  );
+	return Promise.all(assetPaths.map(async (sourcePath) => ({
+		sourcePath,
+		publicPath: `${normalizeMountPath(input.mountPath ?? `/${input.root}`)}/${encodeURIComponent(slug)}/assets/${assetName(sourcePath, input.root, slug)}`,
+		type: "local",
+		contentType: contentTypeForPath(sourcePath),
+		body: input.readBinary ? await input.readBinary(sourcePath) : void 0
+	})));
 }
 function assetName(sourcePath, root, slug) {
-  const normalizedPath = normalizePath3(sourcePath);
-  const prefix = `${normalizePath3(root).replace(/\/$/, "")}/${slug}/assets/`;
-  const relative4 = normalizedPath.startsWith(prefix) ? normalizedPath.slice(prefix.length) : normalizedPath.split("/").at(-1) ?? normalizedPath;
-  return relative4.split("/").map(encodeURIComponent).join("/");
+	const normalizedPath = normalizePath$2(sourcePath);
+	const prefix = `${normalizePath$2(root).replace(/\/$/, "")}/${slug}/assets/`;
+	return (normalizedPath.startsWith(prefix) ? normalizedPath.slice(prefix.length) : normalizedPath.split("/").at(-1) ?? normalizedPath).split("/").map(encodeURIComponent).join("/");
 }
 function normalizeMountPath(value) {
-  const withLeadingSlash = value.startsWith("/") ? value : `/${value}`;
-  return withLeadingSlash.replace(/\/$/, "");
+	return (value.startsWith("/") ? value : `/${value}`).replace(/\/$/, "");
 }
-function normalizePath3(path) {
-  return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+function normalizePath$2(path) {
+	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
 }
-
-// src/generator/package-entry.ts
-var DECKS_RUNTIME_ENTRY = "hono-decks";
-var DECKS_ADVANCED_ENTRY = "hono-decks/advanced";
-
-// src/generator/mdx-module-generator.ts
-import { compile } from "@mdx-js/mdx";
-import remarkDirective from "remark-directive";
-import remarkGfm2 from "remark-gfm";
-
-// src/generator/mdx/emit.ts
+//#endregion
+//#region src/generator/package-entry.ts
+const DECKS_RUNTIME_ENTRY = "hono-decks";
+const DECKS_ADVANCED_ENTRY = "hono-decks/advanced";
+//#endregion
+//#region src/generator/mdx/emit.ts
 function emitModuleDecksRouter(input) {
-  const runtimeEntry = JSON.stringify(DECKS_RUNTIME_ENTRY);
-  const advancedEntry = JSON.stringify(DECKS_ADVANCED_ENTRY);
-  const slideImports = input.decks.flatMap(
-    (deck) => deck.slideModules.map(
-      (slide, index) => `import ${slideImportName(deck.deck.slug, index)} from ${JSON.stringify(slide.importPath)};`
-    )
-  ).join("\n");
-  const componentImports = input.decks.filter((deck) => deck.componentModulePath).map((deck) => `import * as ${componentImportName(deck.deck.slug)} from ${JSON.stringify(deck.componentModulePath)};`).join("\n");
-  return `// @ts-nocheck
-import { configureDecks, defineDecks } from ${advancedEntry};
+	const runtimeEntry = JSON.stringify(DECKS_RUNTIME_ENTRY);
+	return `// @ts-nocheck
+import { configureDecks, defineDecks } from ${JSON.stringify(DECKS_ADVANCED_ENTRY)};
 import type { ConfiguredDecks, DecksConfig } from ${runtimeEntry};
 import type { Env } from "hono";
 import { decksClientEntry } from "./client-entry";
-${slideImports}
-${componentImports}
+${input.decks.flatMap((deck) => deck.slideModules.map((slide, index) => `import ${slideImportName(deck.deck.slug, index)} from ${JSON.stringify(slide.importPath)};`)).join("\n")}
+${input.decks.filter((deck) => deck.componentModulePath).map((deck) => `import * as ${componentImportName(deck.deck.slug)} from ${JSON.stringify(deck.componentModulePath)};`).join("\n")}
 
 function withClientComponentIds(module, clientIds) {
   const registry = {};
@@ -1002,589 +948,510 @@ function definedDecksFor<E extends Env>() {
 `;
 }
 function emitDeckObject(deck) {
-  return `    {
+	return `    {
       slug: ${JSON.stringify(deck.deck.slug)},
       sourcePath: ${JSON.stringify(deck.deck.sourcePath)},
       kind: ${JSON.stringify(deck.deck.kind)},
       meta: ${serializeValue(deck.deck.meta, 3)},
-${deck.deck.themeStyle ? `      "themeStyle": ${serializeValue(deck.deck.themeStyle, 3)},
-` : ""}${deck.deck.themeSourcePath ? `      "themeSourcePath": ${JSON.stringify(deck.deck.themeSourcePath)},
-` : ""}
+${deck.deck.themeStyle ? `      "themeStyle": ${serializeValue(deck.deck.themeStyle, 3)},\n` : ""}${deck.deck.themeSourcePath ? `      "themeSourcePath": ${JSON.stringify(deck.deck.themeSourcePath)},\n` : ""}
       assets: ${serializeValue(deck.deck.assets, 3)},
       componentRegistry: ${deck.componentModulePath ? `withClientComponentIds(${componentImportName(deck.deck.slug)}, ${serializeValue(deck.clientComponentIds ?? {}, 3)})` : "{}"},
       warnings: ${serializeValue(deck.deck.warnings, 3)},
       slides: [
-${deck.deck.slides.map(
-    (slide) => `        {
+${deck.deck.slides.map((slide) => `        {
           index: ${slide.index},
           meta: ${serializeValue(slide.meta, 5)},
           html: "",
           components: [],
           notes: ${serializeValue(slide.notes, 5)},
           render: ${slideImportName(deck.deck.slug, slide.index)}
-        }`
-  ).join(",\n")}
+        }`).join(",\n")}
       ]
     }`;
 }
 function slideImportName(slug, index) {
-  return `Slide_${safeIdentifier(slug)}_${index}`;
+	return `Slide_${safeIdentifier$1(slug)}_${index}`;
 }
 function componentImportName(slug) {
-  return `Components_${safeIdentifier(slug)}`;
+	return `Components_${safeIdentifier$1(slug)}`;
 }
-function safeIdentifier(value) {
-  return value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]+/, "_") || "_";
+function safeIdentifier$1(value) {
+	return value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]+/, "_") || "_";
 }
 function serializeValue(value, depth) {
-  const indent = "  ".repeat(depth);
-  const nextIndent = "  ".repeat(depth + 1);
-  if (value === void 0) return "undefined";
-  if (value instanceof Uint8Array) return `new Uint8Array([${[...value].join(", ")}])`;
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "[]";
-    return `[
-${value.map((item) => `${nextIndent}${serializeValue(item, depth + 1)}`).join(",\n")}
-${indent}]`;
-  }
-  if (typeof value === "object" && value !== null) {
-    const entries = Object.entries(value).filter(([, item]) => item !== void 0);
-    if (entries.length === 0) return "{}";
-    return `{
-${entries.map(([key, item]) => `${nextIndent}${JSON.stringify(key)}: ${serializeValue(item, depth + 1)}`).join(",\n")}
-${indent}}`;
-  }
-  return JSON.stringify(value);
-}
-
-// src/generator/mdx/ogp.ts
+	const indent = "  ".repeat(depth);
+	const nextIndent = "  ".repeat(depth + 1);
+	if (value === void 0) return "undefined";
+	if (value instanceof Uint8Array) return `new Uint8Array([${[...value].join(", ")}])`;
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		return `[\n${value.map((item) => `${nextIndent}${serializeValue(item, depth + 1)}`).join(",\n")}\n${indent}]`;
+	}
+	if (typeof value === "object" && value !== null) {
+		const entries = Object.entries(value).filter(([, item]) => item !== void 0);
+		if (entries.length === 0) return "{}";
+		return `{\n${entries.map(([key, item]) => `${nextIndent}${JSON.stringify(key)}: ${serializeValue(item, depth + 1)}`).join(",\n")}\n${indent}}`;
+	}
+	return JSON.stringify(value);
+}
+//#endregion
+//#region src/generator/mdx/ogp.ts
 async function resolveLinkCardMetadataByUrl(source, resolveOgp) {
-  const result2 = /* @__PURE__ */ new Map();
-  if (!resolveOgp) return result2;
-  for (const url of collectLinkCardUrls(source)) {
-    try {
-      const metadata = await resolveOgp(url);
-      if (metadata) result2.set(url, metadata);
-    } catch {
-    }
-  }
-  return result2;
+	const result = /* @__PURE__ */ new Map();
+	if (!resolveOgp) return result;
+	for (const url of collectLinkCardUrls(source)) try {
+		const metadata = await resolveOgp(url);
+		if (metadata) result.set(url, metadata);
+	} catch {}
+	return result;
 }
 function collectLinkCardUrls(source) {
-  const urls = /* @__PURE__ */ new Set();
-  const pattern = /@\[card\]\(([^)\s]+)\)/g;
-  for (const match of source.matchAll(pattern)) {
-    urls.add(match[1]);
-  }
-  return [...urls];
+	const urls = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(/@\[card\]\(([^)\s]+)\)/g)) urls.add(match[1]);
+	return [...urls];
 }
-
-// src/generator/mdx/syntax.ts
-import { codeToHtml } from "shiki";
+//#endregion
+//#region src/generator/mdx/syntax.ts
 function remarkDeckSyntax(input = {}) {
-  return () => (tree) => {
-    transformDeckSyntaxChildren(tree, input);
-  };
+	return () => (tree) => {
+		transformDeckSyntaxChildren(tree, input);
+	};
 }
 function remarkCodeHighlight() {
-  return async (tree) => {
-    await highlightMarkdownNode(tree);
-  };
+	return async (tree) => {
+		await highlightMarkdownNode(tree);
+	};
 }
 function transformDeckSyntaxChildren(node, input) {
-  if (!Array.isArray(node.children)) return;
-  const children = [];
-  for (const child of node.children) {
-    transformDeckSyntaxChildren(child, input);
-    rejectRemovedFireAuthoring(child);
-    children.push(
-      fireAttributeNode(child) ?? zennEmbedNode(child, input) ?? plainUrlLinkNode(child) ?? fireDirectiveNode(child) ?? unknownDirectiveFallback(child) ?? child
-    );
-  }
-  node.children = children;
+	if (!Array.isArray(node.children)) return;
+	const children = [];
+	for (const child of node.children) {
+		transformDeckSyntaxChildren(child, input);
+		rejectRemovedFireAuthoring(child);
+		children.push(fireAttributeNode(child) ?? zennEmbedNode(child, input) ?? plainUrlLinkNode(child) ?? fireDirectiveNode(child) ?? unknownDirectiveFallback(child) ?? child);
+	}
+	node.children = children;
 }
 function rejectRemovedFireAuthoring(node) {
-  if (node.type !== "mdxJsxFlowElement" && node.type !== "mdxJsxTextElement") return;
-  if (!Array.isArray(node.attributes)) return;
-  if (node.attributes.some((attribute) => attribute.name === "$fire")) {
-    throw new Error('The "$fire" prop is not supported. Use fire or fire="effect" on a block-level custom component.');
-  }
-  if (node.name === "Fire" && node.attributes.some((attribute) => attribute.name === "order")) {
-    throw new Error('The Fire "order" prop is not supported. Fires reveal in source order.');
-  }
-  if (node.name === "Fire") {
-    const atAttribute = node.attributes.find((attribute) => attribute.name === "at");
-    if (atAttribute) fireAtAttributeValue(atAttribute.value);
-  }
+	if (node.type !== "mdxJsxFlowElement" && node.type !== "mdxJsxTextElement") return;
+	if (!Array.isArray(node.attributes)) return;
+	if (node.attributes.some((attribute) => attribute.name === "$fire")) throw new Error("The \"$fire\" prop is not supported. Use fire or fire=\"effect\" on a block-level custom component.");
+	if (node.name === "Fire" && node.attributes.some((attribute) => attribute.name === "order")) throw new Error("The Fire \"order\" prop is not supported. Fires reveal in source order.");
+	if (node.name === "Fire") {
+		const atAttribute = node.attributes.find((attribute) => attribute.name === "at");
+		if (atAttribute) fireAtAttributeValue(atAttribute.value);
+	}
 }
 function fireAttributeNode(node) {
-  if (node.type !== "mdxJsxFlowElement" && node.type !== "mdxJsxTextElement") return void 0;
-  if (!Array.isArray(node.attributes)) return void 0;
-  const fireAttribute = node.attributes.find(
-    (attribute) => attribute.type === "mdxJsxAttribute" && attribute.name === "fire"
-  );
-  if (!fireAttribute) return void 0;
-  const atAttribute = node.attributes.find(
-    (attribute) => attribute.type === "mdxJsxAttribute" && attribute.name === "at"
-  );
-  if (node.name === "Fire") {
-    throw new Error('The "fire" attribute is not supported on <Fire>. Use the effect prop instead.');
-  }
-  if (!node.name || !/^[A-Z]/.test(node.name)) {
-    throw new Error('The "fire" attribute is only supported on custom components. Use :::fire for Markdown content.');
-  }
-  if (node.type !== "mdxJsxFlowElement") {
-    throw new Error('The "fire" attribute is only supported on block-level custom components. Move the component to its own line.');
-  }
-  if (fireAttribute.value !== null && fireAttribute.value !== void 0 && typeof fireAttribute.value !== "string") {
-    throw new Error('The "fire" attribute accepts no value or a static effect name such as fire="fade-up".');
-  }
-  const effect = typeof fireAttribute.value === "string" ? fireAttribute.value.trim() : "";
-  const at = atAttribute ? fireAtAttributeValue(atAttribute.value) : void 0;
-  node.attributes = node.attributes.filter((attribute) => attribute !== fireAttribute && attribute !== atAttribute);
-  return mdxElement(
-    "Fire",
-    [
-      ...effect ? [mdxAttribute("effect", effect)] : [],
-      ...at ? [mdxAttribute("at", at)] : []
-    ],
-    [node]
-  );
+	if (node.type !== "mdxJsxFlowElement" && node.type !== "mdxJsxTextElement") return void 0;
+	if (!Array.isArray(node.attributes)) return void 0;
+	const fireAttribute = node.attributes.find((attribute) => attribute.type === "mdxJsxAttribute" && attribute.name === "fire");
+	if (!fireAttribute) return void 0;
+	const atAttribute = node.attributes.find((attribute) => attribute.type === "mdxJsxAttribute" && attribute.name === "at");
+	if (node.name === "Fire") throw new Error("The \"fire\" attribute is not supported on <Fire>. Use the effect prop instead.");
+	if (!node.name || !/^[A-Z]/.test(node.name)) throw new Error("The \"fire\" attribute is only supported on custom components. Use :::fire for Markdown content.");
+	if (node.type !== "mdxJsxFlowElement") throw new Error("The \"fire\" attribute is only supported on block-level custom components. Move the component to its own line.");
+	if (fireAttribute.value !== null && fireAttribute.value !== void 0 && typeof fireAttribute.value !== "string") throw new Error("The \"fire\" attribute accepts no value or a static effect name such as fire=\"fade-up\".");
+	const effect = typeof fireAttribute.value === "string" ? fireAttribute.value.trim() : "";
+	const at = atAttribute ? fireAtAttributeValue(atAttribute.value) : void 0;
+	node.attributes = node.attributes.filter((attribute) => attribute !== fireAttribute && attribute !== atAttribute);
+	return mdxElement("Fire", [...effect ? [mdxAttribute("effect", effect)] : [], ...at ? [mdxAttribute("at", at)] : []], [node]);
 }
 function fireAtAttributeValue(value) {
-  if (typeof value === "string") {
-    const at = value.trim();
-    if (/^(?:\d+|[+-]\d+)$/.test(at)) return at;
-  }
-  throw new Error('The fire "at" attribute accepts a non-negative integer or a relative value such as "+1".');
+	if (typeof value === "string") {
+		const at = value.trim();
+		if (/^(?:\d+|[+-]\d+)$/.test(at)) return at;
+	}
+	throw new Error("The fire \"at\" attribute accepts a non-negative integer or a relative value such as \"+1\".");
 }
 function zennEmbedNode(node, input) {
-  if (node.type !== "paragraph" || !Array.isArray(node.children) || node.children.length !== 2) return void 0;
-  const [prefix, link] = node.children;
-  if (prefix?.type !== "text" || String(prefix.value ?? "").trim() !== "@") return void 0;
-  if (link?.type !== "link" || typeof link.url !== "string") return void 0;
-  const name = collectMarkdownText(link).trim().toLowerCase();
-  if (name === "youtube") {
-    return mdxElement(
-      "EmbedFrame",
-      [
-        mdxAttribute("provider", "youtube"),
-        mdxAttribute("src", toYoutubeEmbedUrl(link.url)),
-        mdxAttribute("fallbackHref", link.url),
-        mdxAttribute("title", "YouTube embed example")
-      ],
-      [{ type: "text", value: "Open YouTube embed" }]
-    );
-  }
-  if (name === "x") {
-    return mdxElement("TweetEmbed", [mdxAttribute("href", link.url), mdxAttribute("label", "Open post on X")], []);
-  }
-  if (name === "card") {
-    const metadata = input.linkCardMetadata?.get(link.url);
-    return mdxElement(
-      "LinkCard",
-      [
-        mdxAttribute("href", link.url),
-        ...metadataAttributes(metadata)
-      ],
-      []
-    );
-  }
-  if (name === "embed" || name === "iframe") {
-    return mdxElement(
-      "EmbedFrame",
-      [mdxAttribute("src", link.url), mdxAttribute("title", "Embedded content")],
-      [{ type: "text", value: "Open embed" }]
-    );
-  }
-  return void 0;
+	if (node.type !== "paragraph" || !Array.isArray(node.children) || node.children.length !== 2) return void 0;
+	const [prefix, link] = node.children;
+	if (prefix?.type !== "text" || String(prefix.value ?? "").trim() !== "@") return void 0;
+	if (link?.type !== "link" || typeof link.url !== "string") return void 0;
+	const name = collectMarkdownText(link).trim().toLowerCase();
+	if (name === "youtube") return mdxElement("EmbedFrame", [
+		mdxAttribute("provider", "youtube"),
+		mdxAttribute("src", toYoutubeEmbedUrl(link.url)),
+		mdxAttribute("fallbackHref", link.url),
+		mdxAttribute("title", "YouTube embed example")
+	], [{
+		type: "text",
+		value: "Open YouTube embed"
+	}]);
+	if (name === "x") return mdxElement("TweetEmbed", [mdxAttribute("href", link.url), mdxAttribute("label", "Open post on X")], []);
+	if (name === "card") {
+		const metadata = input.linkCardMetadata?.get(link.url);
+		return mdxElement("LinkCard", [mdxAttribute("href", link.url), ...metadataAttributes(metadata)], []);
+	}
+	if (name === "embed" || name === "iframe") return mdxElement("EmbedFrame", [mdxAttribute("src", link.url), mdxAttribute("title", "Embedded content")], [{
+		type: "text",
+		value: "Open embed"
+	}]);
 }
 function metadataAttributes(metadata) {
-  if (!metadata) return [];
-  return [
-    ...metadata.title ? [mdxAttribute("title", metadata.title)] : [],
-    ...metadata.description ? [mdxAttribute("description", metadata.description)] : [],
-    ...metadata.image ? [mdxAttribute("image", metadata.image)] : [],
-    ...metadata.siteName ? [mdxAttribute("siteName", metadata.siteName)] : []
-  ];
+	if (!metadata) return [];
+	return [
+		...metadata.title ? [mdxAttribute("title", metadata.title)] : [],
+		...metadata.description ? [mdxAttribute("description", metadata.description)] : [],
+		...metadata.image ? [mdxAttribute("image", metadata.image)] : [],
+		...metadata.siteName ? [mdxAttribute("siteName", metadata.siteName)] : []
+	];
 }
 function plainUrlLinkNode(node) {
-  if (node.type !== "paragraph" || !Array.isArray(node.children) || node.children.length !== 1) return void 0;
-  const [child] = node.children;
-  if (child?.type !== "text" || typeof child.value !== "string") return void 0;
-  const value = child.value.trim();
-  if (!isHttpUrl(value)) return void 0;
-  return {
-    type: "paragraph",
-    children: [
-      {
-        type: "link",
-        url: value,
-        children: [{ type: "text", value }]
-      }
-    ]
-  };
-}
-function isHttpUrl(value) {
-  try {
-    const url = new URL(value);
-    return url.protocol === "https:" || url.protocol === "http:";
-  } catch {
-    return false;
-  }
+	if (node.type !== "paragraph" || !Array.isArray(node.children) || node.children.length !== 1) return void 0;
+	const [child] = node.children;
+	if (child?.type !== "text" || typeof child.value !== "string") return void 0;
+	const value = child.value.trim();
+	if (!isHttpUrl$1(value)) return void 0;
+	return {
+		type: "paragraph",
+		children: [{
+			type: "link",
+			url: value,
+			children: [{
+				type: "text",
+				value
+			}]
+		}]
+	};
+}
+function isHttpUrl$1(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" || url.protocol === "http:";
+	} catch {
+		return false;
+	}
 }
 function fireDirectiveNode(node) {
-  if (node.type !== "containerDirective" || node.name !== "fire") return void 0;
-  const attributes = directiveAttributes(node);
-  if (attributes.order !== void 0) {
-    throw new Error('The fire "order" attribute is not supported. Fires reveal in source order.');
-  }
-  if (attributes.each === void 0 && (attributes.depth !== void 0 || attributes.every !== void 0)) {
-    throw new Error('The fire "depth" and "every" attributes require each="item".');
-  }
-  if (attributes.each !== void 0) return fireEachItemNode(node, attributes);
-  const at = attributes.at !== void 0 ? fireAtAttributeValue(attributes.at) : void 0;
-  const fireAttributes = [
-    ...typeof attributes.effect === "string" ? [mdxAttribute("effect", attributes.effect)] : [],
-    ...at ? [mdxAttribute("at", at)] : []
-  ];
-  return mdxElement("Fire", fireAttributes, node.children ?? []);
+	if (node.type !== "containerDirective" || node.name !== "fire") return void 0;
+	const attributes = directiveAttributes(node);
+	if (attributes.order !== void 0) throw new Error("The fire \"order\" attribute is not supported. Fires reveal in source order.");
+	if (attributes.each === void 0 && (attributes.depth !== void 0 || attributes.every !== void 0)) throw new Error("The fire \"depth\" and \"every\" attributes require each=\"item\".");
+	if (attributes.each !== void 0) return fireEachItemNode(node, attributes);
+	const at = attributes.at !== void 0 ? fireAtAttributeValue(attributes.at) : void 0;
+	return mdxElement("Fire", [...typeof attributes.effect === "string" ? [mdxAttribute("effect", attributes.effect)] : [], ...at ? [mdxAttribute("at", at)] : []], node.children ?? []);
 }
 function fireEachItemNode(node, attributes) {
-  if (attributes.each !== "item") {
-    throw new Error('The fire "each" attribute only accepts "item".');
-  }
-  const children = node.children ?? [];
-  const list = children.length === 1 && children[0]?.type === "list" ? children[0] : void 0;
-  if (!list) {
-    throw new Error('fire each="item" must contain exactly one Markdown list.');
-  }
-  const depth = positiveFireInteger(attributes.depth, "depth", 1);
-  const every = positiveFireInteger(attributes.every, "every", 1);
-  const at = attributes.at !== void 0 ? fireAtAttributeValue(attributes.at) : void 0;
-  const effect = attributes.effect ? fireEffectToken(attributes.effect) : void 0;
-  const items = fireListItems(list, depth);
-  for (const [itemIndex, item] of items.entries()) {
-    const itemAt = fireListItemAt(at, every, itemIndex);
-    item.data = {
-      ...item.data,
-      hProperties: {
-        ...item.data?.hProperties,
-        "data-hono-decks-fire": "true",
-        ...itemAt ? { "data-fire-at": itemAt } : {},
-        ...effect ? { "data-fire-effect": effect } : {}
-      }
-    };
-  }
-  return list;
+	if (attributes.each !== "item") throw new Error("The fire \"each\" attribute only accepts \"item\".");
+	const children = node.children ?? [];
+	const list = children.length === 1 && children[0]?.type === "list" ? children[0] : void 0;
+	if (!list) throw new Error("fire each=\"item\" must contain exactly one Markdown list.");
+	const depth = positiveFireInteger(attributes.depth, "depth", 1);
+	const every = positiveFireInteger(attributes.every, "every", 1);
+	const at = attributes.at !== void 0 ? fireAtAttributeValue(attributes.at) : void 0;
+	const effect = attributes.effect ? fireEffectToken(attributes.effect) : void 0;
+	const items = fireListItems(list, depth);
+	for (const [itemIndex, item] of items.entries()) {
+		const itemAt = fireListItemAt(at, every, itemIndex);
+		item.data = {
+			...item.data,
+			hProperties: {
+				...item.data?.hProperties,
+				"data-hono-decks-fire": "true",
+				...itemAt ? { "data-fire-at": itemAt } : {},
+				...effect ? { "data-fire-effect": effect } : {}
+			}
+		};
+	}
+	return list;
 }
 function positiveFireInteger(value, name, fallback) {
-  if (value === void 0) return fallback;
-  const parsed = Number(value);
-  if (Number.isInteger(parsed) && parsed > 0) return parsed;
-  throw new Error(`The fire "${name}" attribute accepts a positive integer.`);
+	if (value === void 0) return fallback;
+	const parsed = Number(value);
+	if (Number.isInteger(parsed) && parsed > 0) return parsed;
+	throw new Error(`The fire "${name}" attribute accepts a positive integer.`);
 }
 function fireListItems(list, maxDepth, depth = 1) {
-  const items = [];
-  for (const item of list.children ?? []) {
-    if (item.type !== "listItem") continue;
-    items.push(item);
-    if (depth >= maxDepth) continue;
-    for (const child of item.children ?? []) {
-      if (child.type === "list") items.push(...fireListItems(child, maxDepth, depth + 1));
-    }
-  }
-  return items;
+	const items = [];
+	for (const item of list.children ?? []) {
+		if (item.type !== "listItem") continue;
+		items.push(item);
+		if (depth >= maxDepth) continue;
+		for (const child of item.children ?? []) if (child.type === "list") items.push(...fireListItems(child, maxDepth, depth + 1));
+	}
+	return items;
 }
 function fireListItemAt(at, every, itemIndex) {
-  if (at && /^\d+$/.test(at)) return String(Number(at) + Math.floor(itemIndex / every));
-  if (!at && every === 1) return void 0;
-  if (itemIndex === 0) return at;
-  return itemIndex % every === 0 ? "+1" : "+0";
+	if (at && /^\d+$/.test(at)) return String(Number(at) + Math.floor(itemIndex / every));
+	if (!at && every === 1) return void 0;
+	if (itemIndex === 0) return at;
+	return itemIndex % every === 0 ? "+1" : "+0";
 }
 function fireEffectToken(value) {
-  return value.trim().replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "fade";
+	return value.trim().replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "fade";
 }
 function unknownDirectiveFallback(node) {
-  if (node.type === "textDirective") return { type: "text", value: `:${node.name ?? ""}` };
-  if (node.type === "leafDirective") return { type: "text", value: `::${node.name ?? ""}` };
-  if (node.type === "containerDirective") {
-    return {
-      type: "paragraph",
-      children: [{ type: "text", value: `:::${node.name ?? ""}` }, ...node.children ?? []]
-    };
-  }
-  return void 0;
+	if (node.type === "textDirective") return {
+		type: "text",
+		value: `:${node.name ?? ""}`
+	};
+	if (node.type === "leafDirective") return {
+		type: "text",
+		value: `::${node.name ?? ""}`
+	};
+	if (node.type === "containerDirective") return {
+		type: "paragraph",
+		children: [{
+			type: "text",
+			value: `:::${node.name ?? ""}`
+		}, ...node.children ?? []]
+	};
 }
 function directiveAttributes(node) {
-  if (!node.attributes || Array.isArray(node.attributes)) return {};
-  const result2 = {};
-  for (const [key, value] of Object.entries(node.attributes)) {
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      result2[key] = String(value);
-    }
-  }
-  return result2;
+	if (!node.attributes || Array.isArray(node.attributes)) return {};
+	const result = {};
+	for (const [key, value] of Object.entries(node.attributes)) if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") result[key] = String(value);
+	return result;
 }
 function mdxElement(name, attributes, children) {
-  return {
-    type: "mdxJsxFlowElement",
-    name,
-    attributes,
-    children
-  };
+	return {
+		type: "mdxJsxFlowElement",
+		name,
+		attributes,
+		children
+	};
 }
 function toYoutubeEmbedUrl(value) {
-  try {
-    const url = new URL(value);
-    const host = url.hostname.replace(/^www\./, "");
-    if (host === "youtu.be") {
-      const id = url.pathname.split("/").filter(Boolean)[0];
-      return id ? `https://www.youtube.com/embed/${id}` : value;
-    }
-    if (host === "youtube.com" || host === "m.youtube.com") {
-      if (url.pathname.startsWith("/embed/")) return value;
-      const id = url.searchParams.get("v");
-      return id ? `https://www.youtube.com/embed/${id}` : value;
-    }
-    return value;
-  } catch {
-    return value;
-  }
+	try {
+		const url = new URL(value);
+		const host = url.hostname.replace(/^www\./, "");
+		if (host === "youtu.be") {
+			const id = url.pathname.split("/").filter(Boolean)[0];
+			return id ? `https://www.youtube.com/embed/${id}` : value;
+		}
+		if (host === "youtube.com" || host === "m.youtube.com") {
+			if (url.pathname.startsWith("/embed/")) return value;
+			const id = url.searchParams.get("v");
+			return id ? `https://www.youtube.com/embed/${id}` : value;
+		}
+		return value;
+	} catch {
+		return value;
+	}
 }
 async function highlightMarkdownNode(node) {
-  if (node.type === "code") {
-    const code = typeof node.value === "string" ? node.value : "";
-    const lang = typeof node.lang === "string" && node.lang ? node.lang : void 0;
-    const highlightedHtml = await highlightCodeBlock(code, lang);
-    node.type = "mdxJsxFlowElement";
-    node.name = "CodeBlock";
-    node.attributes = [
-      ...lang ? [mdxAttribute("lang", lang)] : [],
-      mdxAttribute("highlightedHtml", highlightedHtml)
-    ];
-    node.children = [{ type: "text", value: code }];
-    delete node.value;
-    delete node.lang;
-    delete node.meta;
-    return;
-  }
-  if (node.type === "mdxJsxFlowElement" && node.name === "CodeBlock") {
-    const code = collectMarkdownText(node);
-    if (code.trim()) {
-      const lang = getMdxStringAttribute(node, "lang");
-      const highlightedHtml = await highlightCodeBlock(code, lang);
-      node.attributes = upsertMdxStringAttribute(node.attributes, "highlightedHtml", highlightedHtml);
-    }
-    return;
-  }
-  if (!Array.isArray(node.children)) return;
-  await Promise.all(node.children.map((child) => highlightMarkdownNode(child)));
+	if (node.type === "code") {
+		const code = typeof node.value === "string" ? node.value : "";
+		const lang = typeof node.lang === "string" && node.lang ? node.lang : void 0;
+		const highlightedHtml = await highlightCodeBlock(code, lang);
+		node.type = "mdxJsxFlowElement";
+		node.name = "CodeBlock";
+		node.attributes = [...lang ? [mdxAttribute("lang", lang)] : [], mdxAttribute("highlightedHtml", highlightedHtml)];
+		node.children = [{
+			type: "text",
+			value: code
+		}];
+		delete node.value;
+		delete node.lang;
+		delete node.meta;
+		return;
+	}
+	if (node.type === "mdxJsxFlowElement" && node.name === "CodeBlock") {
+		const code = collectMarkdownText(node);
+		if (code.trim()) {
+			const highlightedHtml = await highlightCodeBlock(code, getMdxStringAttribute(node, "lang"));
+			node.attributes = upsertMdxStringAttribute(node.attributes, "highlightedHtml", highlightedHtml);
+		}
+		return;
+	}
+	if (!Array.isArray(node.children)) return;
+	await Promise.all(node.children.map((child) => highlightMarkdownNode(child)));
 }
 async function highlightCodeBlock(code, lang) {
-  const language = lang && /^[A-Za-z0-9_#+.-]+$/.test(lang) ? lang : "text";
-  try {
-    return await codeToHtml(code, { lang: language, theme: "github-dark" });
-  } catch (error) {
-    if (language === "text") throw error;
-    return codeToHtml(code, { lang: "text", theme: "github-dark" });
-  }
+	const language = lang && /^[A-Za-z0-9_#+.-]+$/.test(lang) ? lang : "text";
+	try {
+		return await codeToHtml(code, {
+			lang: language,
+			theme: "github-dark"
+		});
+	} catch (error) {
+		if (language === "text") throw error;
+		return codeToHtml(code, {
+			lang: "text",
+			theme: "github-dark"
+		});
+	}
 }
 function mdxAttribute(name, value) {
-  return { type: "mdxJsxAttribute", name, value };
+	return {
+		type: "mdxJsxAttribute",
+		name,
+		value
+	};
 }
 function getMdxStringAttribute(node, name) {
-  const attributes = Array.isArray(node.attributes) ? node.attributes : [];
-  const attribute = attributes.find((item) => item.type === "mdxJsxAttribute" && item.name === name);
-  return typeof attribute?.value === "string" ? attribute.value : void 0;
+	const attribute = (Array.isArray(node.attributes) ? node.attributes : []).find((item) => item.type === "mdxJsxAttribute" && item.name === name);
+	return typeof attribute?.value === "string" ? attribute.value : void 0;
 }
 function upsertMdxStringAttribute(attributes, name, value) {
-  const next = Array.isArray(attributes) ? [...attributes] : [];
-  const index = next.findIndex((item) => item.type === "mdxJsxAttribute" && item.name === name);
-  const attribute = mdxAttribute(name, value);
-  if (index === -1) return [...next, attribute];
-  next[index] = attribute;
-  return next;
+	const next = Array.isArray(attributes) ? [...attributes] : [];
+	const index = next.findIndex((item) => item.type === "mdxJsxAttribute" && item.name === name);
+	const attribute = mdxAttribute(name, value);
+	if (index === -1) return [...next, attribute];
+	next[index] = attribute;
+	return next;
 }
 function collectMarkdownText(node) {
-  if (typeof node.value === "string") return node.value;
-  if (!Array.isArray(node.children)) return "";
-  return node.children.map((child) => collectMarkdownText(child)).join(node.type === "paragraph" ? "\n" : "");
+	if (typeof node.value === "string") return node.value;
+	if (!Array.isArray(node.children)) return "";
+	return node.children.map((child) => collectMarkdownText(child)).join(node.type === "paragraph" ? "\n" : "");
 }
-
-// src/generator/mdx-module-generator.ts
+//#endregion
+//#region src/generator/mdx-module-generator.ts
 async function compileMdxModuleDecks(input) {
-  const decks = await Promise.all(input.decks.map((entry) => compileMdxModuleDeck(input, entry)));
-  return {
-    decks,
-    routerModule: emitModuleDecksRouter({ decks })
-  };
+	const decks = await Promise.all(input.decks.map((entry) => compileMdxModuleDeck(input, entry)));
+	return {
+		decks,
+		routerModule: emitModuleDecksRouter({ decks })
+	};
 }
 async function compileMdxModuleDeck(input, entry) {
-  const source = await input.readText(entry.sourcePath);
-  const { attrs, body } = readFrontmatter(source);
-  const { prelude, body: contentBody } = extractDeckPrelude(body);
-  const slideSources = splitSlideSources(contentBody);
-  let warnings = [];
-  const deckMeta = toDeckFrontmatter(attrs, warnings);
-  addUnknownFrontmatterWarnings(warnings, deckMeta.meta, "deck");
-  const assets = [
-    ...await buildAssetRefs(entry.slug, entry.assetPaths, input),
-    ...collectGeneratedExternalAssetRefs(contentBody, deckMeta)
-  ];
-  const componentModulePath = componentImportPath(input.outDir, input.componentModulePaths?.[entry.slug]);
-  const themeStyle = entry.kind === "directory" ? input.themeStyles?.[entry.slug] : void 0;
-  const slideModules = [];
-  const slides = [];
-  for (let index = 0; index < slideSources.length; index += 1) {
-    const { attrs: slideAttrs, body: slideBody } = readFrontmatter(slideSources[index]);
-    const speakerNotes = extractMdxCommentSpeakerNotes(slideBody);
-    const parsed = parseDeckWithWarnings(speakerNotes.body);
-    warnings = warnings.concat(toGeneratedParserCompileWarnings(parsed.warnings, index));
-    const firstParsedSlide = parsed.slides[0];
-    const slideModulePath = `${input.outDir}/decks/${entry.slug}/slide-${index}.ts`;
-    const slideMeta = toSlideFrontmatter(slideAttrs, warnings, {
-      slideIndex: index,
-      fallbackTransition: deckMeta.transition,
-      fallbackTransitionDuration: deckMeta.transitionDuration,
-      fallbackTransitionEasing: deckMeta.transitionEasing,
-      fallbackTitle: firstParsedSlide?.title,
-      fallbackLayout: firstParsedSlide?.layout,
-      fallbackClassName: firstParsedSlide?.className
-    });
-    addUnknownFrontmatterWarnings(warnings, slideMeta.meta, "slide", index);
-    const moduleSource = [prelude, rewriteAssetUrls(speakerNotes.body, assets)].filter(Boolean).join("\n\n");
-    const rewrittenSource = rewriteRelativeMdxImports(moduleSource, dirname(entry.sourcePath), dirname(slideModulePath));
-    const code = await compileMdxModule(rewrittenSource, entry.sourcePath, index, input.resolveOgp);
-    slideModules.push({
-      path: slideModulePath,
-      importPath: `./decks/${entry.slug}/slide-${index}`,
-      code
-    });
-    slides.push({
-      index,
-      meta: slideMeta,
-      html: "",
-      components: [],
-      notes: combineSpeakerNotes(slideMeta.notes, speakerNotes.notes)
-    });
-  }
-  addExternalAssetWarnings(warnings, assets);
-  return {
-    componentModulePath,
-    clientComponentIds: input.clientComponentIds?.[entry.slug],
-    deck: {
-      slug: entry.slug,
-      sourcePath: entry.sourcePath,
-      kind: entry.kind,
-      meta: deckMeta,
-      themeStyle: themeStyle?.style,
-      themeSourcePath: themeStyle?.sourcePath,
-      slides,
-      assets,
-      warnings
-    },
-    slideModules
-  };
+	const { attrs, body } = readFrontmatter(await input.readText(entry.sourcePath));
+	const { prelude, body: contentBody } = extractDeckPrelude(body);
+	const slideSources = splitSlideSources(contentBody);
+	let warnings = [];
+	const deckMeta = toDeckFrontmatter(attrs, warnings);
+	addUnknownFrontmatterWarnings(warnings, deckMeta.meta, "deck");
+	const assets = [...await buildAssetRefs(entry.slug, entry.assetPaths, input), ...collectGeneratedExternalAssetRefs(contentBody, deckMeta)];
+	const componentModulePath = componentImportPath(input.outDir, input.componentModulePaths?.[entry.slug]);
+	const themeStyle = entry.kind === "directory" ? input.themeStyles?.[entry.slug] : void 0;
+	const slideModules = [];
+	const slides = [];
+	for (let index = 0; index < slideSources.length; index += 1) {
+		const { attrs: slideAttrs, body: slideBody } = readFrontmatter(slideSources[index]);
+		const speakerNotes = extractMdxCommentSpeakerNotes(slideBody);
+		const parsed = parseDeckWithWarnings(speakerNotes.body);
+		warnings = warnings.concat(toGeneratedParserCompileWarnings(parsed.warnings, index));
+		const firstParsedSlide = parsed.slides[0];
+		const slideModulePath = `${input.outDir}/decks/${entry.slug}/slide-${index}.ts`;
+		const slideMeta = toSlideFrontmatter(slideAttrs, warnings, {
+			slideIndex: index,
+			fallbackTransition: deckMeta.transition,
+			fallbackTransitionDuration: deckMeta.transitionDuration,
+			fallbackTransitionEasing: deckMeta.transitionEasing,
+			fallbackTitle: firstParsedSlide?.title,
+			fallbackLayout: firstParsedSlide?.layout,
+			fallbackClassName: firstParsedSlide?.className
+		});
+		addUnknownFrontmatterWarnings(warnings, slideMeta.meta, "slide", index);
+		const code = await compileMdxModule(rewriteRelativeMdxImports([prelude, rewriteAssetUrls(speakerNotes.body, assets)].filter(Boolean).join("\n\n"), dirname$2(entry.sourcePath), dirname$2(slideModulePath)), entry.sourcePath, index, input.resolveOgp);
+		slideModules.push({
+			path: slideModulePath,
+			importPath: `./decks/${entry.slug}/slide-${index}`,
+			code
+		});
+		slides.push({
+			index,
+			meta: slideMeta,
+			html: "",
+			components: [],
+			notes: combineSpeakerNotes(slideMeta.notes, speakerNotes.notes)
+		});
+	}
+	addExternalAssetWarnings(warnings, assets);
+	return {
+		componentModulePath,
+		clientComponentIds: input.clientComponentIds?.[entry.slug],
+		deck: {
+			slug: entry.slug,
+			sourcePath: entry.sourcePath,
+			kind: entry.kind,
+			meta: deckMeta,
+			themeStyle: themeStyle?.style,
+			themeSourcePath: themeStyle?.sourcePath,
+			slides,
+			assets,
+			warnings
+		},
+		slideModules
+	};
 }
 function collectGeneratedExternalAssetRefs(contentBody, deckMeta) {
-  return buildExternalAssetRefs([
-    ...collectMarkdownAssetCandidates(contentBody),
-    ...collectFrontmatterAssetCandidates(deckMeta.assets)
-  ]);
+	return buildExternalAssetRefs([...collectMarkdownAssetCandidates(contentBody), ...collectFrontmatterAssetCandidates(deckMeta.assets)]);
 }
 function generatedMdxParserWarnings(warnings) {
-  return warnings.filter((warning) => warning.code === "code-fence-unclosed");
+	return warnings.filter((warning) => warning.code === "code-fence-unclosed");
 }
 function toGeneratedParserCompileWarnings(warnings, slideIndex) {
-  return generatedMdxParserWarnings(warnings).map((warning) => ({
-    code: "parse-warning",
-    message: warning.message,
-    slideIndex
-  }));
+	return generatedMdxParserWarnings(warnings).map((warning) => ({
+		code: "parse-warning",
+		message: warning.message,
+		slideIndex
+	}));
 }
 async function compileMdxModule(source, sourcePath, slideIndex, resolveOgp) {
-  try {
-    const linkCardMetadata = await resolveLinkCardMetadataByUrl(source, resolveOgp);
-    const compiled = String(
-      await compile(
-        { path: `${sourcePath}#slide-${slideIndex + 1}`, value: source },
-        {
-          jsxRuntime: "automatic",
-          jsxImportSource: "hono/jsx",
-          format: "mdx",
-          elementAttributeNameCase: "html",
-          remarkPlugins: [
-            remarkGfm2,
-            remarkDirective,
-            remarkDeckSyntax({ linkCardMetadata }),
-            remarkCodeHighlight
-          ]
-        }
-      )
-    );
-    return `// @ts-nocheck
-${compiled}`;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new CompileError(
-      `MDX compile failed in ${sourcePath} slide ${slideIndex + 1}: ${message}`,
-      "mdx-compile-error"
-    );
-  }
+	try {
+		const linkCardMetadata = await resolveLinkCardMetadataByUrl(source, resolveOgp);
+		return `// @ts-nocheck\n${String(await compile({
+			path: `${sourcePath}#slide-${slideIndex + 1}`,
+			value: source
+		}, {
+			jsxRuntime: "automatic",
+			jsxImportSource: "hono/jsx",
+			format: "mdx",
+			elementAttributeNameCase: "html",
+			remarkPlugins: [
+				remarkGfm,
+				remarkDirective,
+				remarkDeckSyntax({ linkCardMetadata }),
+				remarkCodeHighlight
+			]
+		}))}`;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new CompileError(`MDX compile failed in ${sourcePath} slide ${slideIndex + 1}: ${message}`, "mdx-compile-error");
+	}
 }
 function extractDeckPrelude(source) {
-  const lines = source.replace(/\r\n/g, "\n").split("\n");
-  const prelude = [];
-  let cursor = 0;
-  while (cursor < lines.length) {
-    const line = lines[cursor];
-    if (line.trim() === "") {
-      prelude.push(line);
-      cursor += 1;
-      continue;
-    }
-    if (/^\s*(import|export)\s/.test(line)) {
-      prelude.push(line);
-      cursor += 1;
-      continue;
-    }
-    break;
-  }
-  return {
-    prelude: prelude.join("\n").trim(),
-    body: lines.slice(cursor).join("\n").trim()
-  };
-}
-
-// src/node/client-entry.ts
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { join } from "path";
-import { fileURLToPath } from "url";
-import { build as buildBrowserBundle } from "esbuild";
+	const lines = source.replace(/\r\n/g, "\n").split("\n");
+	const prelude = [];
+	let cursor = 0;
+	while (cursor < lines.length) {
+		const line = lines[cursor];
+		if (line.trim() === "") {
+			prelude.push(line);
+			cursor += 1;
+			continue;
+		}
+		if (/^\s*(import|export)\s/.test(line)) {
+			prelude.push(line);
+			cursor += 1;
+			continue;
+		}
+		break;
+	}
+	return {
+		prelude: prelude.join("\n").trim(),
+		body: lines.slice(cursor).join("\n").trim()
+	};
+}
+//#endregion
+//#region src/node/client-entry.ts
 async function discoverClientComponentIds(input) {
-  const result2 = {};
-  for (const entry of input.clientEntries) {
-    const source = await readFile(join(input.cwd, entry.sourcePath), "utf8");
-    const exports = extractComponentExportNames(source);
-    result2[entry.slug] = Object.fromEntries(exports.map((name) => [name, clientComponentId(entry.slug, name)]));
-  }
-  return result2;
+	const result = {};
+	for (const entry of input.clientEntries) {
+		const exports = extractComponentExportNames(await readFile(join(input.cwd, entry.sourcePath), "utf8"));
+		result[entry.slug] = Object.fromEntries(exports.map((name) => [name, clientComponentId(entry.slug, name)]));
+	}
+	return result;
 }
 async function emitClientEntryModule(input) {
-  const imports = [];
-  const registrations = [];
-  for (const entry of input.clientEntries) {
-    const ids = input.clientComponentIds[entry.slug] ?? {};
-    for (const [exportName, clientId] of Object.entries(ids)) {
-      const localName = clientImportName(entry.slug, exportName);
-      imports.push(`import { ${exportName} as ${localName} } from ${JSON.stringify(join(input.cwd, entry.sourcePath))};`);
-      registrations.push(`${JSON.stringify(clientId)}: ${localName}`);
-    }
-  }
-  if (registrations.length === 0) return 'export const decksClientEntry = "";\n';
-  const entryContents = `import { hydrateSlideIslands } from "hono-decks/client";
+	const imports = [];
+	const registrations = [];
+	for (const entry of input.clientEntries) {
+		const ids = input.clientComponentIds[entry.slug] ?? {};
+		for (const [exportName, clientId] of Object.entries(ids)) {
+			const localName = clientImportName(entry.slug, exportName);
+			imports.push(`import { ${exportName} as ${localName} } from ${JSON.stringify(join(input.cwd, entry.sourcePath))};`);
+			registrations.push(`${JSON.stringify(clientId)}: ${localName}`);
+		}
+	}
+	if (registrations.length === 0) return "export const decksClientEntry = \"\";\n";
+	const output = (await build({
+		stdin: {
+			contents: `import { hydrateSlideIslands } from "hono-decks/client";
 ${imports.join("\n")}
 
 hydrateSlideIslands({
@@ -1592,496 +1459,458 @@ hydrateSlideIslands({
     ${registrations.join(",\n    ")}
   }
 });
-`;
-  const result2 = await buildBrowserBundle({
-    stdin: {
-      contents: entryContents,
-      resolveDir: input.cwd,
-      sourcefile: "hono-decks-client-entry.tsx",
-      loader: "tsx"
-    },
-    bundle: true,
-    write: false,
-    format: "esm",
-    platform: "browser",
-    target: "es2022",
-    jsx: "automatic",
-    jsxImportSource: "hono/jsx/dom",
-    nodePaths: nodeModuleFallbackPaths(input.cwd),
-    alias: { "hono-decks/client": resolveClientRuntimeEntry() },
-    sourcemap: false,
-    minify: false
-  });
-  const output = result2.outputFiles[0];
-  if (!output) throw new Error("Client entry did not produce output.");
-  return `export const decksClientEntry = ${JSON.stringify(output.text)};
-`;
+`,
+			resolveDir: input.cwd,
+			sourcefile: "hono-decks-client-entry.tsx",
+			loader: "tsx"
+		},
+		bundle: true,
+		write: false,
+		format: "esm",
+		platform: "browser",
+		target: "es2022",
+		jsx: "automatic",
+		jsxImportSource: "hono/jsx/dom",
+		nodePaths: nodeModuleFallbackPaths(input.cwd),
+		alias: { "hono-decks/client": resolveClientRuntimeEntry() },
+		sourcemap: false,
+		minify: false
+	})).outputFiles[0];
+	if (!output) throw new Error("Client entry did not produce output.");
+	return `export const decksClientEntry = ${JSON.stringify(output.text)};\n`;
 }
 function resolveClientRuntimeEntry() {
-  const built = fileURLToPath(new URL("./client.js", import.meta.url));
-  if (existsSync(built)) return built;
-  return fileURLToPath(new URL("../client.ts", import.meta.url));
+	const built = fileURLToPath(new URL("./client.js", import.meta.url));
+	if (existsSync(built)) return built;
+	return fileURLToPath(new URL("../client.ts", import.meta.url));
 }
 function extractComponentExportNames(source) {
-  const names = /* @__PURE__ */ new Set();
-  for (const match of source.matchAll(/\bexport\s+function\s+([A-Z][A-Za-z0-9_]*)\b/g)) {
-    names.add(match[1]);
-  }
-  for (const match of source.matchAll(/\bexport\s+const\s+([A-Z][A-Za-z0-9_]*)\b/g)) {
-    names.add(match[1]);
-  }
-  return [...names].sort();
+	const names = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(/\bexport\s+function\s+([A-Z][A-Za-z0-9_]*)\b/g)) names.add(match[1]);
+	for (const match of source.matchAll(/\bexport\s+const\s+([A-Z][A-Za-z0-9_]*)\b/g)) names.add(match[1]);
+	return [...names].sort();
 }
 function nodeModuleFallbackPaths(cwd) {
-  const current = process.cwd();
-  return [
-    join(cwd, "node_modules"),
-    join(cwd, "..", "node_modules"),
-    join(cwd, "..", "..", "node_modules"),
-    join(current, "node_modules"),
-    join(current, "..", "node_modules"),
-    join(current, "..", "..", "node_modules")
-  ];
+	const current = process.cwd();
+	return [
+		join(cwd, "node_modules"),
+		join(cwd, "..", "node_modules"),
+		join(cwd, "..", "..", "node_modules"),
+		join(current, "node_modules"),
+		join(current, "..", "node_modules"),
+		join(current, "..", "..", "node_modules")
+	];
 }
 function clientComponentId(slug, exportName) {
-  const base = `${exportName}__${safeIdentifier2(slug)}`;
-  return `${base}_${hashString(`${slug}:${exportName}`).slice(0, 8)}`;
+	return `${`${exportName}__${safeIdentifier(slug)}`}_${hashString(`${slug}:${exportName}`).slice(0, 8)}`;
 }
 function clientImportName(slug, exportName) {
-  return `${safeIdentifier2(exportName)}__${safeIdentifier2(slug)}_${hashString(`${slug}:${exportName}`).slice(0, 8)}`;
+	return `${safeIdentifier(exportName)}__${safeIdentifier(slug)}_${hashString(`${slug}:${exportName}`).slice(0, 8)}`;
 }
 function hashString(value) {
-  let hash = 5381;
-  for (let index = 0; index < value.length; index += 1) {
-    hash = hash * 33 ^ value.charCodeAt(index);
-  }
-  return (hash >>> 0).toString(36);
+	let hash = 5381;
+	for (let index = 0; index < value.length; index += 1) hash = hash * 33 ^ value.charCodeAt(index);
+	return (hash >>> 0).toString(36);
 }
-function safeIdentifier2(value) {
-  return value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]+/, "_") || "_";
+function safeIdentifier(value) {
+	return value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]+/, "_") || "_";
 }
-
-// src/node/local-deck-io.ts
-import { existsSync as existsSync2, watch } from "fs";
-import { readdir, readFile as readFile2 } from "fs/promises";
-import { join as join2, relative as relative2 } from "path";
-
-// src/node/path-utils.ts
-import { relative } from "path";
-function dirname2(path) {
-  const normalized = normalizePath4(path);
-  return normalized.includes("/") ? normalized.slice(0, normalized.lastIndexOf("/")) : ".";
+//#endregion
+//#region src/node/path-utils.ts
+function dirname$1(path) {
+	const normalized = normalizePath$1(path);
+	return normalized.includes("/") ? normalized.slice(0, normalized.lastIndexOf("/")) : ".";
 }
-function normalizePath4(path) {
-  return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+function normalizePath$1(path) {
+	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
 }
 function normalizeDeckRoot(root) {
-  const normalized = normalizeRelativePath(root, "Deck root").replace(/\/$/, "");
-  if (normalized === ".") {
-    throw new Error("Deck root must be a relative path inside the current working directory");
-  }
-  return normalized;
+	const normalized = normalizeRelativePath(root, "Deck root").replace(/\/$/, "");
+	if (normalized === ".") throw new Error("Deck root must be a relative path inside the current working directory");
+	return normalized;
 }
 function normalizeRelativePath(path, label) {
-  const normalized = normalizePath4(path).replace(/\/$/, "");
-  const segments = normalized.split("/");
-  if (normalized === "" || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized) || segments.includes("..")) {
-    throw new Error(`${label} must be a relative path inside the current working directory`);
-  }
-  return normalized;
+	const normalized = normalizePath$1(path).replace(/\/$/, "");
+	const segments = normalized.split("/");
+	if (normalized === "" || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized) || segments.includes("..")) throw new Error(`${label} must be a relative path inside the current working directory`);
+	return normalized;
 }
-
-// src/node/local-deck-io.ts
+//#endregion
+//#region src/node/local-deck-io.ts
 async function listFiles(cwd, dir) {
-  const entries = await readdir(dir, { withFileTypes: true });
-  const paths = await Promise.all(
-    entries.map(async (entry) => {
-      const fullPath = join2(dir, entry.name);
-      if (entry.isDirectory()) return listFiles(cwd, fullPath);
-      if (entry.isFile()) return [normalizePath4(relative2(cwd, fullPath))];
-      return [];
-    })
-  );
-  return paths.flat().sort();
-}
-
-// src/node/ogp.ts
-import { lookup } from "dns/promises";
-import { isIP } from "net";
-var MAX_OGP_BYTES = 256 * 1024;
-var MAX_OGP_REDIRECTS = 3;
+	const entries = await readdir(dir, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (entry) => {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) return listFiles(cwd, fullPath);
+		if (entry.isFile()) return [normalizePath$1(relative(cwd, fullPath))];
+		return [];
+	}))).flat().sort();
+}
+//#endregion
+//#region src/node/ogp.ts
+const MAX_OGP_BYTES = 256 * 1024;
+const MAX_OGP_REDIRECTS = 3;
 async function resolveOgpMetadata(url) {
-  if (!isHttpUrl2(url) || typeof fetch === "undefined") return void 0;
-  try {
-    const response = await fetchPublicHttpUrl(url);
-    if (!response) return void 0;
-    const contentType = response.headers.get("content-type") ?? "";
-    if (!response.ok || !contentType.toLowerCase().includes("text/html") || isTooLarge(response)) return void 0;
-    const html = await readTextWithLimit(response, MAX_OGP_BYTES);
-    if (!html) return void 0;
-    return parseOgpHtml(html, response.url || url);
-  } catch {
-    return void 0;
-  }
+	if (!isHttpUrl(url) || typeof fetch === "undefined") return void 0;
+	try {
+		const response = await fetchPublicHttpUrl(url);
+		if (!response) return void 0;
+		const contentType = response.headers.get("content-type") ?? "";
+		if (!response.ok || !contentType.toLowerCase().includes("text/html") || isTooLarge(response)) return void 0;
+		const html = await readTextWithLimit(response, MAX_OGP_BYTES);
+		if (!html) return void 0;
+		return parseOgpHtml(html, response.url || url);
+	} catch {
+		return;
+	}
 }
 async function fetchPublicHttpUrl(url) {
-  let current = url;
-  for (let redirect = 0; redirect <= MAX_OGP_REDIRECTS; redirect += 1) {
-    if (!await isPublicHttpUrl(current)) return void 0;
-    const response = await fetch(current, {
-      headers: { accept: "text/html,application/xhtml+xml" },
-      redirect: "manual",
-      signal: AbortSignal.timeout(1500)
-    });
-    if (!isRedirect(response.status)) return response;
-    await response.body?.cancel();
-    const location = response.headers.get("location");
-    if (!location) return void 0;
-    current = new URL(location, current).toString();
-  }
-  return void 0;
+	let current = url;
+	for (let redirect = 0; redirect <= MAX_OGP_REDIRECTS; redirect += 1) {
+		if (!await isPublicHttpUrl(current)) return void 0;
+		const response = await fetch(current, {
+			headers: { accept: "text/html,application/xhtml+xml" },
+			redirect: "manual",
+			signal: AbortSignal.timeout(1500)
+		});
+		if (!isRedirect(response.status)) return response;
+		await response.body?.cancel();
+		const location = response.headers.get("location");
+		if (!location) return void 0;
+		current = new URL(location, current).toString();
+	}
 }
 async function isPublicHttpUrl(value) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    return false;
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
-  if (isLocalHostname(url.hostname)) return false;
-  if (isPrivateIpAddress(url.hostname)) return false;
-  const addresses = await lookup(url.hostname, { all: true, verbatim: true });
-  return addresses.length > 0 && addresses.every(({ address }) => !isPrivateIpAddress(address));
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return false;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+	if (isLocalHostname(url.hostname)) return false;
+	if (isPrivateIpAddress(url.hostname)) return false;
+	const addresses = await lookup(url.hostname, {
+		all: true,
+		verbatim: true
+	});
+	return addresses.length > 0 && addresses.every(({ address }) => !isPrivateIpAddress(address));
 }
 function isLocalHostname(hostname) {
-  const normalized = hostname.toLowerCase().replace(/\.$/, "");
-  return normalized === "localhost" || normalized.endsWith(".localhost");
+	const normalized = hostname.toLowerCase().replace(/\.$/, "");
+	return normalized === "localhost" || normalized.endsWith(".localhost");
 }
 function isPrivateIpAddress(value) {
-  const normalized = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
-  const version = isIP(normalized);
-  if (version === 4) return isPrivateIpv4(normalized);
-  if (version === 6) return isPrivateIpv6(normalized);
-  return false;
+	const normalized = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
+	const version = isIP(normalized);
+	if (version === 4) return isPrivateIpv4(normalized);
+	if (version === 6) return isPrivateIpv6(normalized);
+	return false;
 }
 function isPrivateIpv4(address) {
-  const parts = address.split(".").map((part) => Number.parseInt(part, 10));
-  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return true;
-  const [a, b] = parts;
-  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
+	const parts = address.split(".").map((part) => Number.parseInt(part, 10));
+	if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return true;
+	const [a, b] = parts;
+	return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
 }
 function isPrivateIpv6(address) {
-  const normalized = address.toLowerCase();
-  if (normalized === "::" || normalized === "::1" || normalized.startsWith("fe80:") || normalized.startsWith("fec0:") || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("ff")) {
-    return true;
-  }
-  if (normalized.startsWith("::ffff:")) {
-    const tail = normalized.slice("::ffff:".length);
-    const dotted = tail.match(/^(?:0:)?(\d+\.\d+\.\d+\.\d+)$/);
-    if (dotted) return isPrivateIpv4(dotted[1]);
-    const hex = tail.match(/^(?:0:)?([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
-    if (hex) {
-      const hi = Number.parseInt(hex[1], 16);
-      const lo = Number.parseInt(hex[2], 16);
-      const value32 = hi << 16 | lo;
-      const ipv4 = [value32 >>> 24 & 255, value32 >>> 16 & 255, value32 >>> 8 & 255, value32 & 255].join(".");
-      return isPrivateIpv4(ipv4);
-    }
-  }
-  return false;
+	const normalized = address.toLowerCase();
+	if (normalized === "::" || normalized === "::1" || normalized.startsWith("fe80:") || normalized.startsWith("fec0:") || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("ff")) return true;
+	if (normalized.startsWith("::ffff:")) {
+		const tail = normalized.slice(7);
+		const dotted = tail.match(/^(?:0:)?(\d+\.\d+\.\d+\.\d+)$/);
+		if (dotted) return isPrivateIpv4(dotted[1]);
+		const hex = tail.match(/^(?:0:)?([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+		if (hex) {
+			const hi = Number.parseInt(hex[1], 16);
+			const lo = Number.parseInt(hex[2], 16);
+			const value32 = hi << 16 | lo;
+			return isPrivateIpv4([
+				value32 >>> 24 & 255,
+				value32 >>> 16 & 255,
+				value32 >>> 8 & 255,
+				value32 & 255
+			].join("."));
+		}
+	}
+	return false;
 }
 function isRedirect(status) {
-  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
 }
 function isTooLarge(response) {
-  const contentLength = response.headers.get("content-length");
-  return contentLength != null && Number(contentLength) > MAX_OGP_BYTES;
+	const contentLength = response.headers.get("content-length");
+	return contentLength != null && Number(contentLength) > MAX_OGP_BYTES;
 }
 async function readTextWithLimit(response, maxBytes) {
-  const reader = response.body?.getReader();
-  if (!reader) {
-    const text = await response.text();
-    return new TextEncoder().encode(text).byteLength > maxBytes ? void 0 : text;
-  }
-  const chunks = [];
-  let bytes = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    bytes += value.byteLength;
-    if (bytes > maxBytes) {
-      await reader.cancel();
-      return void 0;
-    }
-    chunks.push(value);
-  }
-  const buffer = new Uint8Array(bytes);
-  let offset = 0;
-  for (const chunk of chunks) {
-    buffer.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return new TextDecoder().decode(buffer);
+	const reader = response.body?.getReader();
+	if (!reader) {
+		const text = await response.text();
+		return new TextEncoder().encode(text).byteLength > maxBytes ? void 0 : text;
+	}
+	const chunks = [];
+	let bytes = 0;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		bytes += value.byteLength;
+		if (bytes > maxBytes) {
+			await reader.cancel();
+			return;
+		}
+		chunks.push(value);
+	}
+	const buffer = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		buffer.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder().decode(buffer);
 }
 function parseOgpHtml(html, pageUrl) {
-  const meta = collectHtmlMeta(html);
-  const title = firstValue(meta, ["og:title", "twitter:title"]) ?? htmlTitle(html);
-  const description = firstValue(meta, ["og:description", "twitter:description", "description"]);
-  const image = absoluteUrl(firstValue(meta, ["og:image", "og:image:url", "twitter:image"]), pageUrl);
-  const siteName = firstValue(meta, ["og:site_name", "application-name"]);
-  const result2 = { title, description, image, siteName };
-  return Object.values(result2).some(Boolean) ? result2 : void 0;
+	const meta = collectHtmlMeta(html);
+	const result = {
+		title: firstValue(meta, ["og:title", "twitter:title"]) ?? htmlTitle(html),
+		description: firstValue(meta, [
+			"og:description",
+			"twitter:description",
+			"description"
+		]),
+		image: absoluteUrl(firstValue(meta, [
+			"og:image",
+			"og:image:url",
+			"twitter:image"
+		]), pageUrl),
+		siteName: firstValue(meta, ["og:site_name", "application-name"])
+	};
+	return Object.values(result).some(Boolean) ? result : void 0;
 }
 function collectHtmlMeta(html) {
-  const meta = /* @__PURE__ */ new Map();
-  const tagPattern = /<meta\b[^>]*>/gi;
-  for (const match of html.matchAll(tagPattern)) {
-    const attributes = parseHtmlAttributes(match[0]);
-    const key = attributes.property ?? attributes.name;
-    const content = attributes.content;
-    if (key && content && !meta.has(key.toLowerCase())) {
-      meta.set(key.toLowerCase(), decodeHtmlEntities(content.trim()));
-    }
-  }
-  return meta;
+	const meta = /* @__PURE__ */ new Map();
+	for (const match of html.matchAll(/<meta\b[^>]*>/gi)) {
+		const attributes = parseHtmlAttributes(match[0]);
+		const key = attributes.property ?? attributes.name;
+		const content = attributes.content;
+		if (key && content && !meta.has(key.toLowerCase())) meta.set(key.toLowerCase(), decodeHtmlEntities(content.trim()));
+	}
+	return meta;
 }
 function parseHtmlAttributes(tag) {
-  const attributes = {};
-  const attributePattern = /([^\s"'<>/=]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/g;
-  for (const match of tag.matchAll(attributePattern)) {
-    attributes[match[1].toLowerCase()] = match[2] ?? match[3] ?? match[4] ?? "";
-  }
-  return attributes;
+	const attributes = {};
+	for (const match of tag.matchAll(/([^\s"'<>/=]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/g)) attributes[match[1].toLowerCase()] = match[2] ?? match[3] ?? match[4] ?? "";
+	return attributes;
 }
 function firstValue(meta, keys) {
-  for (const key of keys) {
-    const value = meta.get(key);
-    if (value) return value;
-  }
-  return void 0;
+	for (const key of keys) {
+		const value = meta.get(key);
+		if (value) return value;
+	}
 }
 function htmlTitle(html) {
-  const match = html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i);
-  return match ? decodeHtmlEntities(match[1].replace(/\s+/g, " ").trim()) : void 0;
+	const match = html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i);
+	return match ? decodeHtmlEntities(match[1].replace(/\s+/g, " ").trim()) : void 0;
 }
 function absoluteUrl(value, base) {
-  if (!value) return void 0;
-  try {
-    return new URL(value, base).toString();
-  } catch {
-    return value;
-  }
+	if (!value) return void 0;
+	try {
+		return new URL(value, base).toString();
+	} catch {
+		return value;
+	}
 }
 function decodeHtmlEntities(value) {
-  return value.replaceAll("&amp;", "&").replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">");
-}
-function isHttpUrl2(value) {
-  try {
-    const url = new URL(value);
-    return url.protocol === "http:" || url.protocol === "https:";
-  } catch {
-    return false;
-  }
+	return value.replaceAll("&amp;", "&").replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">");
 }
-
-// src/node/compile-decks.ts
+function isHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/node/compile-decks.ts
 async function compileDecks(input) {
-  const out = normalizeRelativePath(input.out, "Output directory");
-  const root = normalizeDeckRoot(input.root);
-  const paths = await listFiles(input.cwd, join3(input.cwd, root));
-  const resolved = resolveDeckFiles(paths, root);
-  const componentModulePaths = Object.fromEntries(
-    resolved.flatMap((deck) => {
-      const path = deck.kind === "directory" ? findComponentModule(paths, root, deck.slug) : void 0;
-      return path ? [[deck.slug, path]] : [];
-    })
-  );
-  const clientEntryPaths = resolved.flatMap((deck) => {
-    const path = deck.kind === "directory" ? findClientEntryModule(paths, root, deck.slug) : void 0;
-    return path ? [{ slug: deck.slug, sourcePath: path }] : [];
-  });
-  const themeStyles = await discoverDeckThemeStyles({ cwd: input.cwd, root, paths, decks: resolved });
-  const clientComponentIds = await discoverClientComponentIds({
-    cwd: input.cwd,
-    clientEntries: clientEntryPaths
-  });
-  const ogpCache = await createOgpCacheResolver({
-    cwd: input.cwd,
-    cacheFile: input.ogpCacheFile,
-    refresh: input.refreshOgp,
-    resolveOgp: input.resolveOgp ?? resolveOgpMetadata
-  });
-  const generated = await compileMdxModuleDecks({
-    root,
-    outDir: out,
-    mountPath: input.mountPath,
-    decks: resolved,
-    componentModulePaths,
-    clientComponentIds,
-    themeStyles,
-    resolveOgp: ogpCache.resolveOgp,
-    readText: (path) => readFile3(join3(input.cwd, path), "utf8"),
-    readBinary: (path) => readFile3(join3(input.cwd, path))
-  });
-  for (const deck of generated.decks) {
-    for (const slide of deck.slideModules) {
-      await writeTextFile(join3(input.cwd, slide.path), slide.code);
-    }
-  }
-  await writeTextFile(join3(input.cwd, out, "decks.ts"), generated.routerModule);
-  await writeTextFile(
-    join3(input.cwd, out, "client-entry.ts"),
-    await emitClientEntryModule({ cwd: input.cwd, clientEntries: clientEntryPaths, clientComponentIds })
-  );
-  await ogpCache.write();
-  return { decks: generated.decks.map((deck) => deck.deck) };
+	const out = normalizeRelativePath(input.out, "Output directory");
+	const root = normalizeDeckRoot(input.root);
+	const paths = await listFiles(input.cwd, join(input.cwd, root));
+	const resolved = resolveDeckFiles(paths, root);
+	const componentModulePaths = Object.fromEntries(resolved.flatMap((deck) => {
+		const path = deck.kind === "directory" ? findComponentModule(paths, root, deck.slug) : void 0;
+		return path ? [[deck.slug, path]] : [];
+	}));
+	const clientEntryPaths = resolved.flatMap((deck) => {
+		const path = deck.kind === "directory" ? findClientEntryModule(paths, root, deck.slug) : void 0;
+		return path ? [{
+			slug: deck.slug,
+			sourcePath: path
+		}] : [];
+	});
+	const themeStyles = await discoverDeckThemeStyles({
+		cwd: input.cwd,
+		root,
+		paths,
+		decks: resolved
+	});
+	const clientComponentIds = await discoverClientComponentIds({
+		cwd: input.cwd,
+		clientEntries: clientEntryPaths
+	});
+	const ogpCache = await createOgpCacheResolver({
+		cwd: input.cwd,
+		cacheFile: input.ogpCacheFile,
+		refresh: input.refreshOgp,
+		resolveOgp: input.resolveOgp ?? resolveOgpMetadata
+	});
+	const generated = await compileMdxModuleDecks({
+		root,
+		outDir: out,
+		mountPath: input.mountPath,
+		decks: resolved,
+		componentModulePaths,
+		clientComponentIds,
+		themeStyles,
+		resolveOgp: ogpCache.resolveOgp,
+		readText: (path) => readFile(join(input.cwd, path), "utf8"),
+		readBinary: (path) => readFile(join(input.cwd, path))
+	});
+	for (const deck of generated.decks) for (const slide of deck.slideModules) await writeTextFile(join(input.cwd, slide.path), slide.code);
+	await writeTextFile(join(input.cwd, out, "decks.ts"), generated.routerModule);
+	await writeTextFile(join(input.cwd, out, "client-entry.ts"), await emitClientEntryModule({
+		cwd: input.cwd,
+		clientEntries: clientEntryPaths,
+		clientComponentIds
+	}));
+	await ogpCache.write();
+	return { decks: generated.decks.map((deck) => deck.deck) };
 }
 async function createOgpCacheResolver(input) {
-  if (!input.cacheFile) {
-    return {
-      resolveOgp: input.resolveOgp,
-      write: async () => void 0
-    };
-  }
-  const cachePath = join3(input.cwd, normalizeRelativePath(input.cacheFile, "OGP cache file"));
-  const cache = await readOgpCache(cachePath);
-  let dirty = false;
-  return {
-    async resolveOgp(url) {
-      if (!input.refresh && cache[url]) return cache[url];
-      if (!input.refresh) return void 0;
-      const metadata = await input.resolveOgp(url);
-      if (metadata) {
-        cache[url] = metadata;
-        dirty = true;
-      }
-      return metadata;
-    },
-    async write() {
-      if (!dirty) return;
-      await writeTextFile(cachePath, `${JSON.stringify(cache, null, 2)}
-`);
-    }
-  };
+	if (!input.cacheFile) return {
+		resolveOgp: input.resolveOgp,
+		write: async () => void 0
+	};
+	const cachePath = join(input.cwd, normalizeRelativePath(input.cacheFile, "OGP cache file"));
+	const cache = await readOgpCache(cachePath);
+	let dirty = false;
+	return {
+		async resolveOgp(url) {
+			if (!input.refresh && cache[url]) return cache[url];
+			if (!input.refresh) return void 0;
+			const metadata = await input.resolveOgp(url);
+			if (metadata) {
+				cache[url] = metadata;
+				dirty = true;
+			}
+			return metadata;
+		},
+		async write() {
+			if (!dirty) return;
+			await writeTextFile(cachePath, `${JSON.stringify(cache, null, 2)}\n`);
+		}
+	};
 }
 async function readOgpCache(path) {
-  let raw;
-  try {
-    raw = await readFile3(path, "utf8");
-  } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") return {};
-    throw error;
-  }
-  const parsed = JSON.parse(raw);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("OGP cache file must contain a JSON object");
-  }
-  const cache = {};
-  for (const [url, value] of Object.entries(parsed)) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
-    const metadata = value;
-    cache[url] = {
-      ...typeof metadata.title === "string" ? { title: metadata.title } : {},
-      ...typeof metadata.description === "string" ? { description: metadata.description } : {},
-      ...typeof metadata.image === "string" ? { image: metadata.image } : {},
-      ...typeof metadata.siteName === "string" ? { siteName: metadata.siteName } : {}
-    };
-  }
-  return cache;
+	let raw;
+	try {
+		raw = await readFile(path, "utf8");
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return {};
+		throw error;
+	}
+	const parsed = JSON.parse(raw);
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("OGP cache file must contain a JSON object");
+	const cache = {};
+	for (const [url, value] of Object.entries(parsed)) {
+		if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+		const metadata = value;
+		cache[url] = {
+			...typeof metadata.title === "string" ? { title: metadata.title } : {},
+			...typeof metadata.description === "string" ? { description: metadata.description } : {},
+			...typeof metadata.image === "string" ? { image: metadata.image } : {},
+			...typeof metadata.siteName === "string" ? { siteName: metadata.siteName } : {}
+		};
+	}
+	return cache;
 }
 function isNodeError(error) {
-  return error instanceof Error && "code" in error;
+	return error instanceof Error && "code" in error;
 }
 async function writeTextFile(path, contents) {
-  await mkdir(dirname2(path), { recursive: true });
-  await writeFile(path, contents, "utf8");
+	await mkdir(dirname$1(path), { recursive: true });
+	await writeFile(path, contents, "utf8");
 }
 function findComponentModule(paths, root, slug) {
-  const base = `${normalizePath4(root).replace(/\/$/, "")}/${slug}/components/index`;
-  return paths.find((path) => {
-    const normalized = normalizePath4(path);
-    return normalized === `${base}.tsx` || normalized === `${base}.ts` || normalized === `${base}.jsx` || normalized === `${base}.js`;
-  });
+	const base = `${normalizePath$1(root).replace(/\/$/, "")}/${slug}/components/index`;
+	return paths.find((path) => {
+		const normalized = normalizePath$1(path);
+		return normalized === `${base}.tsx` || normalized === `${base}.ts` || normalized === `${base}.jsx` || normalized === `${base}.js`;
+	});
 }
 function findClientEntryModule(paths, root, slug) {
-  const base = `${normalizePath4(root).replace(/\/$/, "")}/${slug}/components/client/index`;
-  return paths.find((path) => {
-    const normalized = normalizePath4(path);
-    return normalized === `${base}.tsx` || normalized === `${base}.ts` || normalized === `${base}.jsx` || normalized === `${base}.js`;
-  });
+	const base = `${normalizePath$1(root).replace(/\/$/, "")}/${slug}/components/client/index`;
+	return paths.find((path) => {
+		const normalized = normalizePath$1(path);
+		return normalized === `${base}.tsx` || normalized === `${base}.ts` || normalized === `${base}.jsx` || normalized === `${base}.js`;
+	});
 }
 async function discoverDeckThemeStyles(input) {
-  const result2 = {};
-  for (const deck of input.decks) {
-    if (deck.kind !== "directory") continue;
-    const sourcePath = findDeckThemeStyle(input.paths, input.root, deck.slug);
-    if (!sourcePath) continue;
-    result2[deck.slug] = {
-      sourcePath,
-      style: await readFile3(join3(input.cwd, sourcePath), "utf8")
-    };
-  }
-  return result2;
+	const result = {};
+	for (const deck of input.decks) {
+		if (deck.kind !== "directory") continue;
+		const sourcePath = findDeckThemeStyle(input.paths, input.root, deck.slug);
+		if (!sourcePath) continue;
+		result[deck.slug] = {
+			sourcePath,
+			style: await readFile(join(input.cwd, sourcePath), "utf8")
+		};
+	}
+	return result;
 }
 function findDeckThemeStyle(paths, root, slug) {
-  const base = `${normalizePath4(root).replace(/\/$/, "")}/${slug}`;
-  const themePath = `${base}/theme.css`;
-  const stylesEntryPath = `${base}/styles/index.css`;
-  const hasTheme = paths.includes(themePath);
-  const hasStylesEntry = paths.includes(stylesEntryPath);
-  if (hasTheme && hasStylesEntry) {
-    throw new Error(`Deck ${slug} has both ${themePath} and ${stylesEntryPath}. Use only one theme CSS entry.`);
-  }
-  return hasTheme ? themePath : hasStylesEntry ? stylesEntryPath : void 0;
+	const base = `${normalizePath$1(root).replace(/\/$/, "")}/${slug}`;
+	const themePath = `${base}/theme.css`;
+	const stylesEntryPath = `${base}/styles/index.css`;
+	const hasTheme = paths.includes(themePath);
+	const hasStylesEntry = paths.includes(stylesEntryPath);
+	if (hasTheme && hasStylesEntry) throw new Error(`Deck ${slug} has both ${themePath} and ${stylesEntryPath}. Use only one theme CSS entry.`);
+	return hasTheme ? themePath : hasStylesEntry ? stylesEntryPath : void 0;
 }
-
-// src/node/config.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { build } from "esbuild";
-var DEFAULT_DECKS_CONFIG_FILE = "hono-decks.config.ts";
 async function loadDecksConfig(input) {
-  const path = resolve(input.cwd, input.configFile ?? DEFAULT_DECKS_CONFIG_FILE);
-  if (!existsSync3(path)) {
-    throw new Error(`Config file not found: ${input.configFile ?? DEFAULT_DECKS_CONFIG_FILE}. Run \`hono-decks init\` first.`);
-  }
-  const result2 = await build({
-    absWorkingDir: input.cwd,
-    entryPoints: [path],
-    bundle: true,
-    format: "esm",
-    platform: "node",
-    target: "node20",
-    write: false,
-    logLevel: "silent",
-    alias: {
-      "hono-decks": resolveRuntimeEntry()
-    }
-  });
-  const source = result2.outputFiles[0]?.text;
-  if (!source) throw new Error(`Could not load config file: ${path}`);
-  const module = await import(`data:text/javascript;charset=utf-8,${encodeURIComponent(source)}#${Date.now()}`);
-  const config = module.default;
-  if (!config || typeof config !== "object") throw new Error(`Config must have a default export: ${path}`);
-  if (typeof config.mountPath !== "string") throw new Error(`Config mountPath must be a string: ${path}`);
-  return {
-    path,
-    config,
-    root: config.build?.root ?? "decks",
-    outDir: config.build?.outDir ?? "src/generated",
-    ogpCacheFile: config.build?.ogpCacheFile
-  };
+	const path = resolve(input.cwd, input.configFile ?? "hono-decks.config.ts");
+	if (!existsSync(path)) throw new Error(`Config file not found: ${input.configFile ?? "hono-decks.config.ts"}. Run \`hono-decks init\` first.`);
+	const source = (await build({
+		absWorkingDir: input.cwd,
+		entryPoints: [path],
+		bundle: true,
+		format: "esm",
+		platform: "node",
+		target: "node20",
+		write: false,
+		logLevel: "silent",
+		alias: { "hono-decks": resolveRuntimeEntry() }
+	})).outputFiles[0]?.text;
+	if (!source) throw new Error(`Could not load config file: ${path}`);
+	const config = (await import(`data:text/javascript;charset=utf-8,${encodeURIComponent(source)}#${Date.now()}`)).default;
+	if (!config || typeof config !== "object") throw new Error(`Config must have a default export: ${path}`);
+	if (typeof config.mountPath !== "string") throw new Error(`Config mountPath must be a string: ${path}`);
+	return {
+		path,
+		config,
+		root: config.build?.root ?? "decks",
+		outDir: config.build?.outDir ?? "src/generated",
+		ogpCacheFile: config.build?.ogpCacheFile
+	};
 }
 function resolveRuntimeEntry() {
-  const built = fileURLToPath2(new URL("./mod.js", import.meta.url));
-  if (existsSync3(built)) return built;
-  return fileURLToPath2(new URL("../mod.ts", import.meta.url));
+	const built = fileURLToPath(new URL("./mod.js", import.meta.url));
+	if (existsSync(built)) return built;
+	return fileURLToPath(new URL("../mod.ts", import.meta.url));
 }
-
-// src/node/cli.ts
-var USAGE = `Usage:
+//#endregion
+//#region src/node/cli.ts
+const USAGE = `Usage:
   hono-decks init [--config hono-decks.config.ts] [--out src/decks.ts]
   hono-decks compile [--config hono-decks.config.ts] [--watch] [--refresh-ogp]
 
@@ -2097,179 +1926,207 @@ Options:
   --refresh-ogp            Refresh OGP cache entries from the network.
   -h, --help               Show this help.`;
 async function runHonoDecksCli(input) {
-  const stdout = input.stdout ?? (() => void 0);
-  const stderr = input.stderr ?? (() => void 0);
-  const [command, ...args] = input.argv;
-  if (!command || command === "--help" || command === "-h") {
-    stdout(USAGE);
-    return { exitCode: 0 };
-  }
-  if (command === "init") return runInitCommand(input, args, stdout, stderr);
-  if (command !== "compile" && command !== "build") {
-    stderr(`Unknown command: ${command}`);
-    stderr(USAGE);
-    return { exitCode: 1 };
-  }
-  const parsed = parseCompileArgs(args);
-  if (parsed.help) {
-    stdout(USAGE);
-    return { exitCode: 0 };
-  }
-  if (parsed.error) {
-    stderr(parsed.error);
-    stderr(USAGE);
-    return { exitCode: 1 };
-  }
-  const compile2 = async () => {
-    const loaded = await loadDecksConfig({ cwd: input.cwd, configFile: parsed.options.configFile });
-    const manifest = await compileDecks({
-      cwd: input.cwd,
-      root: loaded.root,
-      out: loaded.outDir,
-      mountPath: loaded.config.mountPath,
-      ogpCacheFile: loaded.ogpCacheFile,
-      refreshOgp: parsed.options.refreshOgp
-    });
-    stdout(`Compiled ${manifest.decks.length} decks to ${loaded.outDir}`);
-    return { root: loaded.root, configPath: loaded.path };
-  };
-  try {
-    const initial = await compile2();
-    if (!parsed.options.watch) return { exitCode: 0 };
-    stdout(`Watching ${initial.root} and ${relative3(input.cwd, initial.configPath)}`);
-    await watchAndCompile({ ...input, root: initial.root, configPath: initial.configPath, compile: compile2, stderr });
-    return { exitCode: 0 };
-  } catch (error) {
-    stderr(error instanceof Error ? error.message : String(error));
-    return { exitCode: 1 };
-  }
+	const stdout = input.stdout ?? (() => void 0);
+	const stderr = input.stderr ?? (() => void 0);
+	const [command, ...args] = input.argv;
+	if (!command || command === "--help" || command === "-h") {
+		stdout(USAGE);
+		return { exitCode: 0 };
+	}
+	if (command === "init") return runInitCommand(input, args, stdout, stderr);
+	if (command !== "compile" && command !== "build") {
+		stderr(`Unknown command: ${command}`);
+		stderr(USAGE);
+		return { exitCode: 1 };
+	}
+	const parsed = parseCompileArgs(args);
+	if (parsed.help) {
+		stdout(USAGE);
+		return { exitCode: 0 };
+	}
+	if (parsed.error) {
+		stderr(parsed.error);
+		stderr(USAGE);
+		return { exitCode: 1 };
+	}
+	const compile = async () => {
+		const loaded = await loadDecksConfig({
+			cwd: input.cwd,
+			configFile: parsed.options.configFile
+		});
+		const manifest = await compileDecks({
+			cwd: input.cwd,
+			root: loaded.root,
+			out: loaded.outDir,
+			mountPath: loaded.config.mountPath,
+			ogpCacheFile: loaded.ogpCacheFile,
+			refreshOgp: parsed.options.refreshOgp
+		});
+		stdout(`Compiled ${manifest.decks.length} decks to ${loaded.outDir}`);
+		return {
+			root: loaded.root,
+			configPath: loaded.path
+		};
+	};
+	try {
+		const initial = await compile();
+		if (!parsed.options.watch) return { exitCode: 0 };
+		stdout(`Watching ${initial.root} and ${relative(input.cwd, initial.configPath)}`);
+		await watchAndCompile({
+			...input,
+			root: initial.root,
+			configPath: initial.configPath,
+			compile,
+			stderr
+		});
+		return { exitCode: 0 };
+	} catch (error) {
+		stderr(error instanceof Error ? error.message : String(error));
+		return { exitCode: 1 };
+	}
 }
 async function watchAndCompile(input) {
-  const watchFileSystem = input.watchFileSystem ?? watch2;
-  let watchedRoot = input.root;
-  let deckWatcher;
-  let timer;
-  let compiling = false;
-  let queued = false;
-  const run = async () => {
-    if (compiling) {
-      queued = true;
-      return;
-    }
-    compiling = true;
-    try {
-      const next = await input.compile();
-      if (next.root !== watchedRoot) {
-        deckWatcher.close();
-        watchedRoot = next.root;
-        deckWatcher = watchFileSystem(join4(input.cwd, watchedRoot), { recursive: true }, schedule);
-      }
-    } catch (error) {
-      input.stderr(error instanceof Error ? error.message : String(error));
-    } finally {
-      compiling = false;
-      if (queued) {
-        queued = false;
-        await run();
-      }
-    }
-  };
-  const schedule = () => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => void run(), 75);
-  };
-  deckWatcher = watchFileSystem(join4(input.cwd, watchedRoot), { recursive: true }, schedule);
-  const configWatcher = watchFileSystem(input.configPath, { recursive: false }, schedule);
-  await new Promise((resolve2) => {
-    if (input.signal?.aborted) return resolve2();
-    input.signal?.addEventListener("abort", () => resolve2(), { once: true });
-  });
-  if (timer) clearTimeout(timer);
-  deckWatcher.close();
-  configWatcher.close();
+	const watchFileSystem = input.watchFileSystem ?? watch;
+	let watchedRoot = input.root;
+	let deckWatcher;
+	let timer;
+	let compiling = false;
+	let queued = false;
+	const run = async () => {
+		if (compiling) {
+			queued = true;
+			return;
+		}
+		compiling = true;
+		try {
+			const next = await input.compile();
+			if (next.root !== watchedRoot) {
+				deckWatcher.close();
+				watchedRoot = next.root;
+				deckWatcher = watchFileSystem(join(input.cwd, watchedRoot), { recursive: true }, schedule);
+			}
+		} catch (error) {
+			input.stderr(error instanceof Error ? error.message : String(error));
+		} finally {
+			compiling = false;
+			if (queued) {
+				queued = false;
+				await run();
+			}
+		}
+	};
+	const schedule = () => {
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => void run(), 75);
+	};
+	deckWatcher = watchFileSystem(join(input.cwd, watchedRoot), { recursive: true }, schedule);
+	const configWatcher = watchFileSystem(input.configPath, { recursive: false }, schedule);
+	await new Promise((resolve) => {
+		if (input.signal?.aborted) return resolve();
+		input.signal?.addEventListener("abort", () => resolve(), { once: true });
+	});
+	if (timer) clearTimeout(timer);
+	deckWatcher.close();
+	configWatcher.close();
 }
 async function runInitCommand(input, args, stdout, stderr) {
-  const parsed = parseInitArgs(args);
-  if (parsed.help) {
-    stdout(USAGE);
-    return { exitCode: 0 };
-  }
-  if (parsed.error) {
-    stderr(parsed.error);
-    stderr(USAGE);
-    return { exitCode: 1 };
-  }
-  const configFile = normalizeOutputFile(parsed.options.configFile ?? DEFAULT_DECKS_CONFIG_FILE);
-  const out = normalizeOutputFile(parsed.options.out ?? "src/decks.ts");
-  try {
-    await writeInitialFiles({
-      cwd: input.cwd,
-      configFile,
-      out,
-      generated: parsed.options.generated ?? "./generated/decks"
-    });
-    stdout(`Initialized ${configFile} and ${out}`);
-    return { exitCode: 0 };
-  } catch (error) {
-    stderr(error instanceof Error ? error.message : String(error));
-    return { exitCode: 1 };
-  }
+	const parsed = parseInitArgs(args);
+	if (parsed.help) {
+		stdout(USAGE);
+		return { exitCode: 0 };
+	}
+	if (parsed.error) {
+		stderr(parsed.error);
+		stderr(USAGE);
+		return { exitCode: 1 };
+	}
+	const configFile = normalizeOutputFile(parsed.options.configFile ?? "hono-decks.config.ts");
+	const out = normalizeOutputFile(parsed.options.out ?? "src/decks.ts");
+	try {
+		await writeInitialFiles({
+			cwd: input.cwd,
+			configFile,
+			out,
+			generated: parsed.options.generated ?? "./generated/decks"
+		});
+		stdout(`Initialized ${configFile} and ${out}`);
+		return { exitCode: 0 };
+	} catch (error) {
+		stderr(error instanceof Error ? error.message : String(error));
+		return { exitCode: 1 };
+	}
 }
 function parseCompileArgs(args) {
-  const options = {};
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--help" || arg === "-h") return { options, help: true };
-    if (arg === "--watch") {
-      options.watch = true;
-      continue;
-    }
-    if (arg === "--refresh-ogp") {
-      options.refreshOgp = true;
-      continue;
-    }
-    if (arg === "--config") {
-      const value = args[index + 1];
-      if (!value || value.startsWith("--")) return { options, error: `Missing value for ${arg}` };
-      options.configFile = value;
-      index += 1;
-      continue;
-    }
-    return { options, error: `Unknown option: ${arg}` };
-  }
-  return { options };
+	const options = {};
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--help" || arg === "-h") return {
+			options,
+			help: true
+		};
+		if (arg === "--watch") {
+			options.watch = true;
+			continue;
+		}
+		if (arg === "--refresh-ogp") {
+			options.refreshOgp = true;
+			continue;
+		}
+		if (arg === "--config") {
+			const value = args[index + 1];
+			if (!value || value.startsWith("--")) return {
+				options,
+				error: `Missing value for ${arg}`
+			};
+			options.configFile = value;
+			index += 1;
+			continue;
+		}
+		return {
+			options,
+			error: `Unknown option: ${arg}`
+		};
+	}
+	return { options };
 }
 function parseInitArgs(args) {
-  const options = {};
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--help" || arg === "-h") return { options, help: true };
-    if (arg === "--config" || arg === "--out" || arg === "--generated") {
-      const value = args[index + 1];
-      if (!value || value.startsWith("--")) return { options, error: `Missing value for ${arg}` };
-      if (arg === "--config") options.configFile = value;
-      if (arg === "--out") options.out = value;
-      if (arg === "--generated") options.generated = value;
-      index += 1;
-      continue;
-    }
-    return { options, error: `Unknown option: ${arg}` };
-  }
-  return { options };
+	const options = {};
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--help" || arg === "-h") return {
+			options,
+			help: true
+		};
+		if (arg === "--config" || arg === "--out" || arg === "--generated") {
+			const value = args[index + 1];
+			if (!value || value.startsWith("--")) return {
+				options,
+				error: `Missing value for ${arg}`
+			};
+			if (arg === "--config") options.configFile = value;
+			if (arg === "--out") options.out = value;
+			if (arg === "--generated") options.generated = value;
+			index += 1;
+			continue;
+		}
+		return {
+			options,
+			error: `Unknown option: ${arg}`
+		};
+	}
+	return { options };
 }
 async function writeInitialFiles(input) {
-  for (const path of [input.configFile, input.out]) {
-    if (existsSync4(join4(input.cwd, path))) throw new Error(`Refusing to overwrite existing file: ${path}`);
-  }
-  const configPath = join4(input.cwd, input.configFile);
-  const facadePath = join4(input.cwd, input.out);
-  await mkdir2(dirname3(configPath), { recursive: true });
-  await mkdir2(dirname3(facadePath), { recursive: true });
-  await writeFile2(configPath, emitDecksConfig(), "utf8");
-  await writeFile2(facadePath, emitDecksFacade(input.generated, relativeImport(input.out, input.configFile)), "utf8");
+	for (const path of [input.configFile, input.out]) if (existsSync(join(input.cwd, path))) throw new Error(`Refusing to overwrite existing file: ${path}`);
+	const configPath = join(input.cwd, input.configFile);
+	const facadePath = join(input.cwd, input.out);
+	await mkdir(dirname(configPath), { recursive: true });
+	await mkdir(dirname(facadePath), { recursive: true });
+	await writeFile(configPath, emitDecksConfig(), "utf8");
+	await writeFile(facadePath, emitDecksFacade(input.generated, relativeImport(input.out, input.configFile)), "utf8");
 }
 function emitDecksConfig() {
-  return `import { defineDecksConfig } from "hono-decks";
+	return `import { defineDecksConfig } from "hono-decks";
 
 export default defineDecksConfig({
   mountPath: "/decks",
@@ -2281,7 +2138,7 @@ export default defineDecksConfig({
 `;
 }
 function emitDecksFacade(generated, configImport) {
-  return `// App-owned facade. Files under the generated directory are overwritten.
+	return `// App-owned facade. Files under the generated directory are overwritten.
 import config from ${JSON.stringify(configImport)};
 import { createDecks } from ${JSON.stringify(generated)};
 
@@ -2289,43 +2146,39 @@ export const decks = createDecks(config);
 `;
 }
 function relativeImport(fromFile, toFile) {
-  const path = normalizePath5(relative3(dirname3(fromFile), toFile)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
-  return path.startsWith(".") ? path : `./${path}`;
+	const path = normalizePath(relative(dirname(fromFile), toFile)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+	return path.startsWith(".") ? path : `./${path}`;
 }
 function normalizeOutputFile(path) {
-  const normalized = normalizePath5(path).replace(/\/$/, "");
-  const segments = normalized.split("/");
-  if (!normalized || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized) || segments.includes("..")) {
-    throw new Error("File must be a relative path inside the current working directory");
-  }
-  return normalized;
+	const normalized = normalizePath(path).replace(/\/$/, "");
+	const segments = normalized.split("/");
+	if (!normalized || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized) || segments.includes("..")) throw new Error("File must be a relative path inside the current working directory");
+	return normalized;
 }
-function normalizePath5(path) {
-  return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+function normalizePath(path) {
+	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
 }
-function dirname3(path) {
-  const normalized = normalizePath5(path);
-  return normalized.includes("/") ? normalized.slice(0, normalized.lastIndexOf("/")) : ".";
+function dirname(path) {
+	const normalized = normalizePath(path);
+	return normalized.includes("/") ? normalized.slice(0, normalized.lastIndexOf("/")) : ".";
 }
 if (typeof process !== "undefined" && process.argv[1]?.endsWith("/node/cli.ts")) {
-  const result2 = await runHonoDecksCli({
-    argv: process.argv.slice(2),
-    cwd: process.cwd(),
-    stdout: (line) => process.stdout.write(`${line}
-`),
-    stderr: (line) => process.stderr.write(`${line}
-`)
-  });
-  process.exitCode = result2.exitCode;
-}
-
-// src/bin.ts
-var result = await runHonoDecksCli({
-  argv: process.argv.slice(2),
-  cwd: process.cwd(),
-  stdout: (line) => process.stdout.write(`${line}
-`),
-  stderr: (line) => process.stderr.write(`${line}
-`)
+	const result = await runHonoDecksCli({
+		argv: process.argv.slice(2),
+		cwd: process.cwd(),
+		stdout: (line) => process.stdout.write(`${line}\n`),
+		stderr: (line) => process.stderr.write(`${line}\n`)
+	});
+	process.exitCode = result.exitCode;
+}
+//#endregion
+//#region src/bin.ts
+const result = await runHonoDecksCli({
+	argv: process.argv.slice(2),
+	cwd: process.cwd(),
+	stdout: (line) => process.stdout.write(`${line}\n`),
+	stderr: (line) => process.stderr.write(`${line}\n`)
 });
 process.exitCode = result.exitCode;
+//#endregion
+export {};