@thanh01.pmt/presentation-kit 0.1.0

package/dist/click-css-CadkoJ_A.d.ts

@@ -0,0 +1,244 @@
+/** Built-in theme identifiers */
+type BuiltInTheme = 'dark' | 'light' | 'navy';
+/** Custom theme tokens — all colors as hex or CSS color values */
+interface ThemeTokens {
+    /** Slide background color */
+    background: string;
+    /** Primary text color */
+    text: string;
+    /** Heading color (h1, h2, h3) */
+    heading: string;
+    /** Bold text color */
+    bold: string;
+    /** Link color */
+    link: string;
+    /** Code block background */
+    codeBg: string;
+    /** Code block text color */
+    codeText: string;
+    /** Inline code background */
+    inlineCodeBg: string;
+    /** Inline code text color */
+    inlineCodeText: string;
+    /** Code border color */
+    codeBorder: string;
+    /** Blockquote background */
+    quoteBg: string;
+    /** Blockquote border color */
+    quoteBorder: string;
+    /** Blockquote text color */
+    quoteText: string;
+    /** Table header background */
+    tableHeaderBg: string;
+    /** Table border color */
+    tableBorder: string;
+    /** Table row hover color */
+    tableRowHover: string;
+    /** Table text color */
+    tableText: string;
+    /** Card border (slide border) */
+    cardBorder: string;
+    /** Card shadow */
+    cardShadow: string;
+    /** Footer / header meta color */
+    meta: string;
+    /** Table even row background (navy uses tinted) */
+    tableEvenRow?: string;
+    /** Mermaid dark mode flag */
+    mermaidDark: boolean;
+    /** Mermaid theme variables (passed to mermaid.initialize) */
+    mermaidVariables: Record<string, string>;
+    /** Mermaid themeCSS (inline CSS for mermaid rendering) */
+    mermaidThemeCSS: string;
+}
+/** Custom theme definition */
+interface SlideTheme {
+    /** Unique theme name */
+    name: string;
+    /** Theme color tokens */
+    tokens: ThemeTokens;
+}
+/** Mermaid block detected in rendered HTML */
+interface MermaidBlock {
+    /** Index of the block in the slide deck */
+    index: number;
+    /** Raw mermaid code (before sanitization) */
+    code: string;
+    /** Sanitized mermaid code (after sanitizeMermaidCode) */
+    sanitizedCode: string;
+}
+/** Options for slide rendering */
+interface SlideRenderOptions {
+    /** Theme to use — built-in name or custom SlideTheme */
+    theme?: BuiltInTheme | SlideTheme;
+    /** Enable Shiki syntax highlighting for code blocks (default: true) */
+    enableShiki?: boolean;
+    /** Enable Mermaid diagram rendering (default: true) */
+    enableMermaid?: boolean;
+    /** Enable click-to-reveal system (default: false) */
+    enableClicks?: boolean;
+    /** Container element ID (default: 'marp-container') */
+    containerId?: string;
+}
+/** Result of synchronous slide rendering */
+interface SlideRenderResult {
+    /** Rendered HTML (with slide sections) */
+    html: string;
+    /** Marp-generated CSS */
+    css: string;
+    /** Scoped theme CSS (custom typography + layout) */
+    themeCss: string;
+    /** Number of slides detected */
+    slideCount: number;
+    /** Mermaid blocks detected (consumer must render these into DOM) */
+    mermaidBlocks: MermaidBlock[];
+    /** Scoped CSS for click-to-reveal animations (empty if clicks disabled) */
+    clickCss: string;
+    /** Total number of click groups (0 if clicks disabled) */
+    maxClicks: number;
+}
+/** Extended result for async rendering (includes Shiki processed HTML) */
+interface SlideRenderAsyncResult extends SlideRenderResult {
+    /** HTML after Shiki post-processing */
+    processedHtml: string;
+}
+/** Engine configuration for createEngine() */
+interface SlideEngineConfig {
+    /** Default theme for all renders */
+    theme?: BuiltInTheme | SlideTheme;
+    /** Enable Shiki by default (default: true) */
+    enableShiki?: boolean;
+    /** Enable Mermaid by default (default: true) */
+    enableMermaid?: boolean;
+}
+/** Slide engine instance returned by createEngine() */
+interface SlideEngine {
+    /** Synchronous render — fast, mermaid blocks returned separately */
+    render: (markdown: string, options?: SlideRenderOptions) => SlideRenderResult;
+    /** Async render — waits for Shiki, returns fully processed HTML */
+    renderAsync: (markdown: string, options?: SlideRenderOptions) => Promise<SlideRenderAsyncResult>;
+    /** Get scoped CSS for a theme */
+    getThemeCss: (theme: BuiltInTheme | SlideTheme, containerId?: string) => string;
+}
+
+/**
+ * Synchronous Marp render — instant, no network.
+ * Returns raw HTML + CSS + theme CSS + mermaid blocks detection.
+ * Shiki and Mermaid are NOT applied (use renderSlideAsync for full quality).
+ */
+declare function renderMarp(markdown: string, containerId?: string, enableClicks?: boolean): {
+    html: string;
+    css: string;
+    maxClicks: number;
+};
+/**
+ * Count slides in rendered Marp HTML by detecting <svg data-marpit-svg> elements.
+ */
+declare function countSlides(html: string): number;
+/**
+ * High-level synchronous render — resolves theme, generates scoped CSS,
+ * detects mermaid blocks. Does NOT apply Shiki or Mermaid rendering.
+ */
+declare function renderSlide(markdown: string, options?: SlideRenderOptions): SlideRenderResult;
+/**
+ * High-level async render — applies Shiki syntax highlighting.
+ * Mermaid blocks are returned separately (DOM-based, consumer renders them).
+ */
+declare function renderSlideAsync(markdown: string, options?: SlideRenderOptions): Promise<SlideRenderAsyncResult>;
+
+/**
+ * Get theme tokens by built-in name.
+ */
+declare function getThemeTokens(theme: BuiltInTheme): ThemeTokens;
+/**
+ * Resolve a theme (built-in name or custom SlideTheme) to a full SlideTheme object.
+ */
+declare function resolveTheme(theme: BuiltInTheme | SlideTheme | undefined): SlideTheme;
+/**
+ * Define a custom theme with full token control.
+ */
+declare function defineTheme(definition: {
+    name: string;
+    tokens: ThemeTokens;
+}): SlideTheme;
+/**
+ * Generate scoped CSS for a theme.
+ */
+declare function generateScopedCss(theme: SlideTheme, containerId?: string): string;
+
+interface ClickPreprocessResult {
+    /** Processed markdown with HTML click markers */
+    markdown: string;
+    /** Total number of click groups assigned */
+    totalClicks: number;
+}
+/**
+ * Preprocess markdown to convert click directives to HTML wrappers.
+ *
+ * Syntax:
+ * - `<!-- click -->`     → Block-level: wraps next block in data-click-group="N"
+ * - `<!-- clicks -->`    → Item-level: marks list for auto-expansion in postprocessor
+ *
+ * Auto-assigns sequential indices (1, 2, 3, ...) based on order of appearance.
+ *
+ * IMPORTANT: Skips code fences (``` ... ```) to avoid converting directives
+ * inside code blocks.
+ *
+ * Strategy: Each `<!-- click -->` opens a `<div data-click-group="N">` that wraps
+ * all content until the next `<!-- click -->` / `<!-- clicks -->` or end of slide.
+ * The postprocessor only needs to handle `<!-- clicks -->` (list expansion).
+ */
+declare function preprocessClicks(markdown: string): ClickPreprocessResult;
+
+interface ClickPostprocessResult {
+    /** HTML with click groups applied */
+    html: string;
+    /** Total number of individual click groups (after expanding clicks) */
+    totalClicks: number;
+}
+/**
+ * Post-process rendered Marp HTML to expand clicks (item-level) list items.
+ *
+ * The preprocessor wraps <!-- click --> blocks in <div data-click-group="N">.
+ * This postprocessor handles <!-- clicks --> by splitting list items into
+ * individual click groups.
+ *
+ * Pattern: <div data-clicks="N">...<ul><li>...</li></ul>...</div>
+ * Becomes: multiple <div data-click-group="N">...<ul><li>...</li></ul>...</div>
+ *
+ * @param html - Raw Marp-rendered HTML (with click-group and clicks markers)
+ * @returns HTML with all click groups expanded
+ */
+declare function postprocessClicks(html: string): ClickPostprocessResult;
+/**
+ * Extract max click index from rendered HTML.
+ * Scans for all data-click-group="N" attributes and returns the max N.
+ */
+declare function extractMaxClicks(html: string): number;
+
+interface ClickCssOptions {
+    /** Container ID to scope CSS (default: no scope, global) */
+    containerId?: string;
+    /** Animation duration in ms (default: 300) */
+    duration?: number;
+    /** Animation easing (default: 'ease') */
+    easing?: string;
+    /** Y offset for slide-up animation in px (default: 8) */
+    offsetY?: number;
+    /** Use slide-up animation (default: true) */
+    slideUp?: boolean;
+    /** Use fade animation (default: true) */
+    fade?: boolean;
+}
+/**
+ * Generate CSS for click-to-reveal system.
+ *
+ * Elements with `data-click-group="N"` are hidden by default.
+ * Adding class `visible` reveals them with animation.
+ *
+ * @param options - Animation options
+ * @returns CSS string to inject via <style>
+ */
+declare function generateClickCss(options?: ClickCssOptions): string;
+
+export { type BuiltInTheme as B, type ClickPreprocessResult as C, type MermaidBlock as M, type SlideEngineConfig as S, type ThemeTokens as T, type SlideEngine as a, renderSlideAsync as b, renderMarp as c, countSlides as d, defineTheme as e, resolveTheme as f, getThemeTokens as g, generateScopedCss as h, postprocessClicks as i, extractMaxClicks as j, generateClickCss as k, type ClickPostprocessResult as l, type ClickCssOptions as m, type SlideTheme as n, type SlideRenderOptions as o, preprocessClicks as p, type SlideRenderResult as q, renderSlide as r, type SlideRenderAsyncResult as s };

package/dist/index.cjs

@@ -0,0 +1,126 @@
+'use strict';
+
+var chunkN4Q6GUAQ_cjs = require('./chunk-N4Q6GUAQ.cjs');
+
+// src/engine.ts
+function createEngine(config = {}) {
+  const defaultTheme = config.theme ?? "dark";
+  const defaultEnableShiki = config.enableShiki ?? true;
+  const defaultEnableMermaid = config.enableMermaid ?? true;
+  function mergeOptions(options) {
+    return {
+      theme: options?.theme ?? defaultTheme,
+      enableShiki: options?.enableShiki ?? defaultEnableShiki,
+      enableMermaid: options?.enableMermaid ?? defaultEnableMermaid,
+      containerId: options?.containerId
+    };
+  }
+  return {
+    render: (markdown, options) => {
+      return chunkN4Q6GUAQ_cjs.renderSlide(markdown, mergeOptions(options));
+    },
+    renderAsync: async (markdown, options) => {
+      return chunkN4Q6GUAQ_cjs.renderSlideAsync(markdown, mergeOptions(options));
+    },
+    getThemeCss: (theme, containerId) => {
+      const resolved = chunkN4Q6GUAQ_cjs.resolveTheme(theme);
+      return chunkN4Q6GUAQ_cjs.generateScopedCss2(resolved, containerId);
+    }
+  };
+}
+
+Object.defineProperty(exports, "convertTextArrows", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.convertTextArrows; }
+});
+Object.defineProperty(exports, "countSlides", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.countSlides; }
+});
+Object.defineProperty(exports, "darkThemeTokens", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.darkThemeTokens; }
+});
+Object.defineProperty(exports, "defineTheme", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.defineTheme; }
+});
+Object.defineProperty(exports, "detectMermaidBlocks", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.detectMermaidBlocks; }
+});
+Object.defineProperty(exports, "extractMarpSource", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.extractMarpSource; }
+});
+Object.defineProperty(exports, "extractMaxClicks", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.extractMaxClicks; }
+});
+Object.defineProperty(exports, "generateClickCss", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.generateClickCss; }
+});
+Object.defineProperty(exports, "generateScopedCss", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.generateScopedCss2; }
+});
+Object.defineProperty(exports, "generateScopedCssFromTokens", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.generateScopedCss; }
+});
+Object.defineProperty(exports, "getHighlighter", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.getHighlighter; }
+});
+Object.defineProperty(exports, "getThemeTokens", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.getThemeTokens; }
+});
+Object.defineProperty(exports, "highlightCodeBlocks", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.highlightCodeBlocks; }
+});
+Object.defineProperty(exports, "lightThemeTokens", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.lightThemeTokens; }
+});
+Object.defineProperty(exports, "navyThemeTokens", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.navyThemeTokens; }
+});
+Object.defineProperty(exports, "postprocessClicks", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.postprocessClicks; }
+});
+Object.defineProperty(exports, "preprocessClicks", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.preprocessClicks; }
+});
+Object.defineProperty(exports, "renderMarp", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.renderMarp; }
+});
+Object.defineProperty(exports, "renderMermaidDiagrams", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.renderMermaidDiagrams; }
+});
+Object.defineProperty(exports, "renderSlide", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.renderSlide; }
+});
+Object.defineProperty(exports, "renderSlideAsync", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.renderSlideAsync; }
+});
+Object.defineProperty(exports, "resolveTheme", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.resolveTheme; }
+});
+Object.defineProperty(exports, "sanitizeMermaidCode", {
+  enumerable: true,
+  get: function () { return chunkN4Q6GUAQ_cjs.sanitizeMermaidCode; }
+});
+exports.createEngine = createEngine;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine.ts"],"names":["renderSlide","renderSlideAsync","resolveTheme","generateScopedCss"],"mappings":";;;;;AAyBO,SAAS,YAAA,CAAa,MAAA,GAA4B,EAAC,EAAgB;AACxE,EAAA,MAAM,YAAA,GAAe,OAAO,KAAA,IAAS,MAAA;AACrC,EAAA,MAAM,kBAAA,GAAqB,OAAO,WAAA,IAAe,IAAA;AACjD,EAAA,MAAM,oBAAA,GAAuB,OAAO,aAAA,IAAiB,IAAA;AAErD,EAAA,SAAS,aAAa,OAAA,EAAkD;AACtE,IAAA,OAAO;AAAA,MACL,KAAA,EAAO,SAAS,KAAA,IAAS,YAAA;AAAA,MACzB,WAAA,EAAa,SAAS,WAAA,IAAe,kBAAA;AAAA,MACrC,aAAA,EAAe,SAAS,aAAA,IAAiB,oBAAA;AAAA,MACzC,aAAa,OAAA,EAAS;AAAA,KACxB;AAAA,EACF;AAEA,EAAA,OAAO;AAAA,IACL,MAAA,EAAQ,CAAC,QAAA,EAAkB,OAAA,KAAoD;AAC7E,MAAA,OAAOA,6BAAA,CAAY,QAAA,EAAU,YAAA,CAAa,OAAO,CAAC,CAAA;AAAA,IACpD,CAAA;AAAA,IAEA,WAAA,EAAa,OAAO,QAAA,EAAkB,OAAA,KAAkE;AACtG,MAAA,OAAOC,kCAAA,CAAiB,QAAA,EAAU,YAAA,CAAa,OAAO,CAAC,CAAA;AAAA,IACzD,CAAA;AAAA,IAEA,WAAA,EAAa,CAAC,KAAA,EAAkC,WAAA,KAAiC;AAC/E,MAAA,MAAM,QAAA,GAAWC,+BAAa,KAAK,CAAA;AACnC,MAAA,OAAOC,oCAAAA,CAAkB,UAAU,WAAW,CAAA;AAAA,IAChD;AAAA,GACF;AACF","file":"index.cjs","sourcesContent":["// ═══════════════════════════════════════════════════════════════════════════════\n// Engine Factory — createEngine() for advanced usage\n// ═══════════════════════════════════════════════════════════════════════════════\n\nimport type { SlideEngine, SlideEngineConfig, SlideRenderOptions, SlideRenderResult, SlideRenderAsyncResult, BuiltInTheme, SlideTheme } from './types.js';\nimport { renderSlide, renderSlideAsync } from './core/render.js';\nimport { resolveTheme, generateScopedCss } from './themes/index.js';\n\n/**\n * Create a slide engine instance with default configuration.\n *\n * @example\n * ```ts\n * const engine = createEngine({ theme: 'dark' });\n *\n * // Synchronous\n * const result = engine.render(markdown);\n *\n * // Async (with Shiki highlighting)\n * const fullResult = await engine.renderAsync(markdown);\n *\n * // Get theme CSS independently\n * const css = engine.getThemeCss('navy');\n * ```\n */\nexport function createEngine(config: SlideEngineConfig = {}): SlideEngine {\n  const defaultTheme = config.theme ?? 'dark';\n  const defaultEnableShiki = config.enableShiki ?? true;\n  const defaultEnableMermaid = config.enableMermaid ?? true;\n\n  function mergeOptions(options?: SlideRenderOptions): SlideRenderOptions {\n    return {\n      theme: options?.theme ?? defaultTheme,\n      enableShiki: options?.enableShiki ?? defaultEnableShiki,\n      enableMermaid: options?.enableMermaid ?? defaultEnableMermaid,\n      containerId: options?.containerId,\n    };\n  }\n\n  return {\n    render: (markdown: string, options?: SlideRenderOptions): SlideRenderResult => {\n      return renderSlide(markdown, mergeOptions(options));\n    },\n\n    renderAsync: async (markdown: string, options?: SlideRenderOptions): Promise<SlideRenderAsyncResult> => {\n      return renderSlideAsync(markdown, mergeOptions(options));\n    },\n\n    getThemeCss: (theme: BuiltInTheme | SlideTheme, containerId?: string): string => {\n      const resolved = resolveTheme(theme);\n      return generateScopedCss(resolved, containerId);\n    },\n  };\n}\n"]}

package/dist/index.d.cts

@@ -0,0 +1,86 @@
+import { S as SlideEngineConfig, a as SlideEngine, T as ThemeTokens, M as MermaidBlock } from './click-css-CadkoJ_A.cjs';
+export { B as BuiltInTheme, m as ClickCssOptions, l as ClickPostprocessResult, C as ClickPreprocessResult, s as SlideRenderAsyncResult, o as SlideRenderOptions, q as SlideRenderResult, n as SlideTheme, d as countSlides, e as defineTheme, j as extractMaxClicks, k as generateClickCss, h as generateScopedCss, g as getThemeTokens, i as postprocessClicks, p as preprocessClicks, c as renderMarp, r as renderSlide, b as renderSlideAsync, f as resolveTheme } from './click-css-CadkoJ_A.cjs';
+import { Highlighter } from 'shiki';
+
+/**
+ * Create a slide engine instance with default configuration.
+ *
+ * @example
+ * ```ts
+ * const engine = createEngine({ theme: 'dark' });
+ *
+ * // Synchronous
+ * const result = engine.render(markdown);
+ *
+ * // Async (with Shiki highlighting)
+ * const fullResult = await engine.renderAsync(markdown);
+ *
+ * // Get theme CSS independently
+ * const css = engine.getThemeCss('navy');
+ * ```
+ */
+declare function createEngine(config?: SlideEngineConfig): SlideEngine;
+
+declare const darkThemeTokens: ThemeTokens;
+
+declare const lightThemeTokens: ThemeTokens;
+
+declare const navyThemeTokens: ThemeTokens;
+
+/**
+ * Generate scoped CSS string for a given theme.
+ * This CSS overrides Marp defaults for 1280×720 canvas typography using
+ * the container ID for CSS isolation.
+ */
+declare function generateScopedCss(tokens: ThemeTokens, containerId?: string): string;
+
+/**
+ * Get or create the Shiki highlighter singleton.
+ * First call lazy-loads the WASM module (~3MB); subsequent calls return cached instance.
+ */
+declare function getHighlighter(): Promise<Highlighter>;
+/**
+ * Post-process rendered HTML: replace <pre><code class="language-xxx"> blocks
+ * with Shiki-highlighted HTML.
+ *
+ * This is async because Shiki WASM must be loaded on first call.
+ */
+declare function highlightCodeBlocks(html: string, theme?: string): Promise<string>;
+
+/**
+ * Detect mermaid blocks in rendered Marp HTML.
+ * Returns array of MermaidBlock with raw and sanitized code.
+ */
+declare function detectMermaidBlocks(html: string): MermaidBlock[];
+/**
+ * Sanitize mermaid code — fix common issues that cause render failures.
+ * Ported from: apps/web/components/MermaidRenderer.tsx sanitizeMermaidCode()
+ */
+declare function sanitizeMermaidCode(chart: string, isDark?: boolean): string;
+/**
+ * Render mermaid diagrams inside a container element.
+ * Lazy-loads mermaid module on first call.
+ *
+ * This function MUST run in a browser environment (needs DOM).
+ * Returns early gracefully in SSR/Node.js environments.
+ */
+declare function renderMermaidDiagrams(container: HTMLElement, theme?: 'dark' | 'light' | 'navy'): Promise<void>;
+
+/**
+ * Converts text arrows (->, -->, --->, =>, ==>, <->, etc.) into clean Unicode
+ * arrows while strictly preserving YAML frontmatter, code fences, inline code,
+ * HTML comments, and style tags.
+ */
+declare function convertTextArrows(text: string): string;
+
+/**
+ * Extracts clean Marp source from markdown that may be wrapped in code fences
+ * or preceded by conversational preamble.
+ *
+ * Handles:
+ * - Wrapped in ```markdown ... ``` or ```marp ... ``` or ```md ... ```
+ * - Conversational preamble before the first frontmatter ---
+ */
+declare function extractMarpSource(raw: string): string;
+
+export { MermaidBlock, SlideEngine, SlideEngineConfig, ThemeTokens, convertTextArrows, createEngine, darkThemeTokens, detectMermaidBlocks, extractMarpSource, generateScopedCss as generateScopedCssFromTokens, getHighlighter, highlightCodeBlocks, lightThemeTokens, navyThemeTokens, renderMermaidDiagrams, sanitizeMermaidCode };

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import { S as SlideEngineConfig, a as SlideEngine, T as ThemeTokens, M as MermaidBlock } from './click-css-CadkoJ_A.js';
+export { B as BuiltInTheme, m as ClickCssOptions, l as ClickPostprocessResult, C as ClickPreprocessResult, s as SlideRenderAsyncResult, o as SlideRenderOptions, q as SlideRenderResult, n as SlideTheme, d as countSlides, e as defineTheme, j as extractMaxClicks, k as generateClickCss, h as generateScopedCss, g as getThemeTokens, i as postprocessClicks, p as preprocessClicks, c as renderMarp, r as renderSlide, b as renderSlideAsync, f as resolveTheme } from './click-css-CadkoJ_A.js';
+import { Highlighter } from 'shiki';
+
+/**
+ * Create a slide engine instance with default configuration.
+ *
+ * @example
+ * ```ts
+ * const engine = createEngine({ theme: 'dark' });
+ *
+ * // Synchronous
+ * const result = engine.render(markdown);
+ *
+ * // Async (with Shiki highlighting)
+ * const fullResult = await engine.renderAsync(markdown);
+ *
+ * // Get theme CSS independently
+ * const css = engine.getThemeCss('navy');
+ * ```
+ */
+declare function createEngine(config?: SlideEngineConfig): SlideEngine;
+
+declare const darkThemeTokens: ThemeTokens;
+
+declare const lightThemeTokens: ThemeTokens;
+
+declare const navyThemeTokens: ThemeTokens;
+
+/**
+ * Generate scoped CSS string for a given theme.
+ * This CSS overrides Marp defaults for 1280×720 canvas typography using
+ * the container ID for CSS isolation.
+ */
+declare function generateScopedCss(tokens: ThemeTokens, containerId?: string): string;
+
+/**
+ * Get or create the Shiki highlighter singleton.
+ * First call lazy-loads the WASM module (~3MB); subsequent calls return cached instance.
+ */
+declare function getHighlighter(): Promise<Highlighter>;
+/**
+ * Post-process rendered HTML: replace <pre><code class="language-xxx"> blocks
+ * with Shiki-highlighted HTML.
+ *
+ * This is async because Shiki WASM must be loaded on first call.
+ */
+declare function highlightCodeBlocks(html: string, theme?: string): Promise<string>;
+
+/**
+ * Detect mermaid blocks in rendered Marp HTML.
+ * Returns array of MermaidBlock with raw and sanitized code.
+ */
+declare function detectMermaidBlocks(html: string): MermaidBlock[];
+/**
+ * Sanitize mermaid code — fix common issues that cause render failures.
+ * Ported from: apps/web/components/MermaidRenderer.tsx sanitizeMermaidCode()
+ */
+declare function sanitizeMermaidCode(chart: string, isDark?: boolean): string;
+/**
+ * Render mermaid diagrams inside a container element.
+ * Lazy-loads mermaid module on first call.
+ *
+ * This function MUST run in a browser environment (needs DOM).
+ * Returns early gracefully in SSR/Node.js environments.
+ */
+declare function renderMermaidDiagrams(container: HTMLElement, theme?: 'dark' | 'light' | 'navy'): Promise<void>;
+
+/**
+ * Converts text arrows (->, -->, --->, =>, ==>, <->, etc.) into clean Unicode
+ * arrows while strictly preserving YAML frontmatter, code fences, inline code,
+ * HTML comments, and style tags.
+ */
+declare function convertTextArrows(text: string): string;
+
+/**
+ * Extracts clean Marp source from markdown that may be wrapped in code fences
+ * or preceded by conversational preamble.
+ *
+ * Handles:
+ * - Wrapped in ```markdown ... ``` or ```marp ... ``` or ```md ... ```
+ * - Conversational preamble before the first frontmatter ---
+ */
+declare function extractMarpSource(raw: string): string;
+
+export { MermaidBlock, SlideEngine, SlideEngineConfig, ThemeTokens, convertTextArrows, createEngine, darkThemeTokens, detectMermaidBlocks, extractMarpSource, generateScopedCss as generateScopedCssFromTokens, getHighlighter, highlightCodeBlocks, lightThemeTokens, navyThemeTokens, renderMermaidDiagrams, sanitizeMermaidCode };

package/dist/index.js

@@ -0,0 +1,33 @@
+import { resolveTheme, generateScopedCss2, renderSlideAsync, renderSlide } from './chunk-RCHOTRWI.js';
+export { convertTextArrows, countSlides, darkThemeTokens, defineTheme, detectMermaidBlocks, extractMarpSource, extractMaxClicks, generateClickCss, generateScopedCss2 as generateScopedCss, generateScopedCss as generateScopedCssFromTokens, getHighlighter, getThemeTokens, highlightCodeBlocks, lightThemeTokens, navyThemeTokens, postprocessClicks, preprocessClicks, renderMarp, renderMermaidDiagrams, renderSlide, renderSlideAsync, resolveTheme, sanitizeMermaidCode } from './chunk-RCHOTRWI.js';
+
+// src/engine.ts
+function createEngine(config = {}) {
+  const defaultTheme = config.theme ?? "dark";
+  const defaultEnableShiki = config.enableShiki ?? true;
+  const defaultEnableMermaid = config.enableMermaid ?? true;
+  function mergeOptions(options) {
+    return {
+      theme: options?.theme ?? defaultTheme,
+      enableShiki: options?.enableShiki ?? defaultEnableShiki,
+      enableMermaid: options?.enableMermaid ?? defaultEnableMermaid,
+      containerId: options?.containerId
+    };
+  }
+  return {
+    render: (markdown, options) => {
+      return renderSlide(markdown, mergeOptions(options));
+    },
+    renderAsync: async (markdown, options) => {
+      return renderSlideAsync(markdown, mergeOptions(options));
+    },
+    getThemeCss: (theme, containerId) => {
+      const resolved = resolveTheme(theme);
+      return generateScopedCss2(resolved, containerId);
+    }
+  };
+}
+
+export { createEngine };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine.ts"],"names":["generateScopedCss"],"mappings":";;;;AAyBO,SAAS,YAAA,CAAa,MAAA,GAA4B,EAAC,EAAgB;AACxE,EAAA,MAAM,YAAA,GAAe,OAAO,KAAA,IAAS,MAAA;AACrC,EAAA,MAAM,kBAAA,GAAqB,OAAO,WAAA,IAAe,IAAA;AACjD,EAAA,MAAM,oBAAA,GAAuB,OAAO,aAAA,IAAiB,IAAA;AAErD,EAAA,SAAS,aAAa,OAAA,EAAkD;AACtE,IAAA,OAAO;AAAA,MACL,KAAA,EAAO,SAAS,KAAA,IAAS,YAAA;AAAA,MACzB,WAAA,EAAa,SAAS,WAAA,IAAe,kBAAA;AAAA,MACrC,aAAA,EAAe,SAAS,aAAA,IAAiB,oBAAA;AAAA,MACzC,aAAa,OAAA,EAAS;AAAA,KACxB;AAAA,EACF;AAEA,EAAA,OAAO;AAAA,IACL,MAAA,EAAQ,CAAC,QAAA,EAAkB,OAAA,KAAoD;AAC7E,MAAA,OAAO,WAAA,CAAY,QAAA,EAAU,YAAA,CAAa,OAAO,CAAC,CAAA;AAAA,IACpD,CAAA;AAAA,IAEA,WAAA,EAAa,OAAO,QAAA,EAAkB,OAAA,KAAkE;AACtG,MAAA,OAAO,gBAAA,CAAiB,QAAA,EAAU,YAAA,CAAa,OAAO,CAAC,CAAA;AAAA,IACzD,CAAA;AAAA,IAEA,WAAA,EAAa,CAAC,KAAA,EAAkC,WAAA,KAAiC;AAC/E,MAAA,MAAM,QAAA,GAAW,aAAa,KAAK,CAAA;AACnC,MAAA,OAAOA,kBAAAA,CAAkB,UAAU,WAAW,CAAA;AAAA,IAChD;AAAA,GACF;AACF","file":"index.js","sourcesContent":["// ═══════════════════════════════════════════════════════════════════════════════\n// Engine Factory — createEngine() for advanced usage\n// ═══════════════════════════════════════════════════════════════════════════════\n\nimport type { SlideEngine, SlideEngineConfig, SlideRenderOptions, SlideRenderResult, SlideRenderAsyncResult, BuiltInTheme, SlideTheme } from './types.js';\nimport { renderSlide, renderSlideAsync } from './core/render.js';\nimport { resolveTheme, generateScopedCss } from './themes/index.js';\n\n/**\n * Create a slide engine instance with default configuration.\n *\n * @example\n * ```ts\n * const engine = createEngine({ theme: 'dark' });\n *\n * // Synchronous\n * const result = engine.render(markdown);\n *\n * // Async (with Shiki highlighting)\n * const fullResult = await engine.renderAsync(markdown);\n *\n * // Get theme CSS independently\n * const css = engine.getThemeCss('navy');\n * ```\n */\nexport function createEngine(config: SlideEngineConfig = {}): SlideEngine {\n  const defaultTheme = config.theme ?? 'dark';\n  const defaultEnableShiki = config.enableShiki ?? true;\n  const defaultEnableMermaid = config.enableMermaid ?? true;\n\n  function mergeOptions(options?: SlideRenderOptions): SlideRenderOptions {\n    return {\n      theme: options?.theme ?? defaultTheme,\n      enableShiki: options?.enableShiki ?? defaultEnableShiki,\n      enableMermaid: options?.enableMermaid ?? defaultEnableMermaid,\n      containerId: options?.containerId,\n    };\n  }\n\n  return {\n    render: (markdown: string, options?: SlideRenderOptions): SlideRenderResult => {\n      return renderSlide(markdown, mergeOptions(options));\n    },\n\n    renderAsync: async (markdown: string, options?: SlideRenderOptions): Promise<SlideRenderAsyncResult> => {\n      return renderSlideAsync(markdown, mergeOptions(options));\n    },\n\n    getThemeCss: (theme: BuiltInTheme | SlideTheme, containerId?: string): string => {\n      const resolved = resolveTheme(theme);\n      return generateScopedCss(resolved, containerId);\n    },\n  };\n}\n"]}