@leadertechie/md2html 0.1.0-alpha.13 → 0.1.0-alpha.14

package/README.md

@@ -10,6 +10,12 @@ A configuration-driven markdown to HTML pipeline that parses markdown to an AST
 - **Configuration-driven** - No hardcoded paths or content structure
 - **SSR-ready** - Works in both Node.js and browser environments
 - **Image path handling** - Configurable prefix and base URL for images
+- **Strategy pattern token handlers** - Extensible handler registry with per-token-type strategies
+- **Catch-all fallback** - Unhandled token types are wrapped in container nodes with `data-unhandled` attributes
+- **CSS `@scope` anchors** - Emit `data-md-scope` attributes for CSS `@scope` targeting
+- **Raw HTML passthrough** - Preserve allowed HTML tags (div, span, img, etc.) with script stripping by default
+- **Slot hooks** - Resolve `[[SLOT_NAME]]` placeholders via callback for personalization
+- **Graceful error recovery** - Configurable `'throw' | 'warn' | 'silent'` error handling modes
 
 ## Installation
 
@@ -61,8 +67,12 @@ const pipeline = new MarkdownPipeline({
   styleOptions: {
     classPrefix: 'md-',
     customCSS: 'body { font-family: system-ui; }',
-    addHeadingIds: true
-  }
+    addHeadingIds: true,
+    emitScopeAnchors: true   // v2: emit data-md-scope attributes
+  },
+  preserveRawHTML: true,     // v2: pass through allowed HTML tags
+  errorRecovery: 'warn',     // v2: graceful error handling
+  onSlot: (name) => `[${name}]`  // v2: resolve [[SLOT_NAME]] placeholders
 });
 ```
 
@@ -73,6 +83,7 @@ const pipeline = new MarkdownPipeline({
 | `classPrefix` | string | `''` | Prefix for CSS classes on elements |
 | `customCSS` | string | `''` | Custom CSS string to inject (use `pipeline.getCustomCSS()` to retrieve) |
 | `addHeadingIds` | boolean | `false` | Add ID attributes to headings based on their content for anchor links |
+| `emitScopeAnchors` | boolean | `false` | Emit `data-md-scope` attributes for CSS `@scope` targeting (v2) |
 
 When `classPrefix` or `addHeadingIds` is set, CSS classes will be added to elements:
 - Headings get level-specific classes: `md-h1`, `md-h2`, `md-h3`, etc.
@@ -88,6 +99,83 @@ Example output with `classPrefix: 'md-'` and `addHeadingIds: true`:
 </ul>
 ```
 
+### CSS `@scope` Anchors (v2)
+
+When `emitScopeAnchors: true`, every rendered element gets a `data-md-scope` attribute:
+
+```html
+<div data-md-scope="root">
+  <h2 data-md-scope="heading" class="md-heading">Title</h2>
+  <p data-md-scope="paragraph" class="md-paragraph">Content</p>
+</div>
+```
+
+This enables CSS `@scope` targeting in your stylesheets:
+
+```css
+@layer components {
+  @scope ([data-md-scope="root"]) {
+    :scope { max-width: 700px; }
+    [data-md-scope="heading"] { font-size: clamp(1.5rem, 4vw, 2.5rem); }
+  }
+}
+```
+
+### Raw HTML Passthrough (v2)
+
+When `preserveRawHTML: true`, allowed HTML tags pass through the parser:
+
+```typescript
+const pipeline = new MarkdownPipeline({ preserveRawHTML: true });
+const html = pipeline.renderMarkdown('Hello <div class="test">World</div>');
+// Output preserves the <div> with its attributes
+```
+
+**Default allowed tags:** `img`, `style`, `div`, `span`, `section`, `article`, `aside`, `header`, `footer`, `nav`, `main`, `figure`, `figcaption`, `details`, `summary`, `mark`, `time`, `video`, `audio`, `source`, `iframe`, `embed`
+
+**Script tags** are stripped by default for security. Opt-in with `allowedHTMLTags: ['script']`.
+
+### Slot Hooks (v2)
+
+Resolve `[[SLOT_NAME]]` placeholders for personalization:
+
+```typescript
+const pipeline = new MarkdownPipeline({
+  onSlot: (name) => {
+    const values = { USER_NAME: 'Alice', COMPANY: 'Acme' };
+    return values[name] || `[[${name}]]`;
+  }
+});
+const html = pipeline.renderMarkdown('Hello [[USER_NAME]] from [[COMPANY]]!');
+// Output: Hello Alice from Acme!
+```
+
+Custom slot patterns are supported via `slotPattern`:
+
+```typescript
+const pipeline = new MarkdownPipeline({
+  slotPattern: /\{\{(.*?)\}\}/g,
+  onSlot: (name) => values[name] || `{{${name}}}`
+});
+```
+
+### Error Recovery (v2)
+
+Three error recovery modes for production resilience:
+
+```typescript
+// 'throw' (default) — backward compatible, throws on parse errors
+const strict = new MarkdownPipeline({ errorRecovery: 'throw' });
+
+// 'warn' — logs warning, returns partial content as fallback text
+const tolerant = new MarkdownPipeline({ errorRecovery: 'warn' });
+
+// 'silent' — silently returns fallback content
+const silent = new MarkdownPipeline({ errorRecovery: 'silent' });
+```
+
+Additional safety with `maxRecursionDepth` (default: 100) to prevent stack overflow on deeply nested content.
+
 ### API
 
 | Method | Description |
@@ -99,6 +187,72 @@ Example output with `classPrefix: 'md-'` and `addHeadingIds: true`:
 | `getCustomCSS()` | Get custom CSS string from style config |
 | `getConfig()` | Get current pipeline configuration |
 
+## Architecture (v2)
+
+### Strategy Pattern Token Handlers
+
+The parser uses a **strategy pattern** with a `TokenHandlerRegistry`. Each marked token type has its own handler class:
+
+```
+src/handlers/
+├── types.ts              # TokenHandler interface + ParseContext
+├── registry.ts           # TokenHandlerRegistry with catch-all fallback
+├── heading-handler.ts    # h1-h6
+├── paragraph-handler.ts  # <p> with inline image/HTML support
+├── list-handler.ts       # <ul>/<ol>
+├── image-handler.ts      # <img>
+├── code-handler.ts       # <pre><code>
+├── hr-handler.ts         # <hr>
+├── blockquote-handler.ts # <blockquote>
+├── html-handler.ts       # raw HTML passthrough
+└── catchall-handler.ts   # fallback for unregistered types
+```
+
+**Extending the parser** — register custom handlers without modifying internals:
+
+```typescript
+import { MarkdownParser, TokenHandler } from '@leadertechie/md2html';
+
+const parser = new MarkdownParser();
+
+// Override heading rendering
+const customHeading: TokenHandler = {
+  type: 'heading',
+  handle: (token, ctx) => ({
+    type: 'container',
+    attributes: { tag: 'div', 'data-custom': 'true' },
+    children: [{
+      type: 'heading',
+      content: ctx.processSlots(token.text as string),
+      attributes: { level: String(token.depth) }
+    }]
+  })
+};
+parser.handlers.register(customHeading);
+
+// Remove a handler to skip token types
+parser.handlers.unregister('heading');
+
+// Replace the catch-all for unregistered token types
+parser.handlers.setCatchAll({
+  type: '*',
+  handle: (token) => ({
+    type: 'text',
+    content: `[fallback: ${token.type}]`
+  })
+});
+```
+
+**Catch-all handler** — When a token type has no dedicated handler (e.g., `table`, `def`), the `CatchAllHandler` wraps it in a `<div data-unhandled="type">` container so content is never silently lost. The `onUnhandledToken` callback notifies callers:
+
+```typescript
+const parser = new MarkdownParser({
+  onUnhandledToken: (type, token) => {
+    console.warn(`[md2html] Unhandled token type: ${type}`);
+  }
+});
+```
+
 ## License
 
 MIT

package/dist/index.d.ts

@@ -1,3 +1,48 @@
+/**
+ * Handles 'blockquote' tokens.
+ */
+export declare class BlockquoteHandler implements TokenHandler {
+    readonly type = "blockquote";
+    handle(token: Record<string, unknown>, ctx: ParseContext): {
+        type: "container";
+        attributes: {
+            tag: string;
+        };
+        children: ContentNode[];
+    };
+}
+
+/**
+ * Catch-all handler for any token type that doesn't have a dedicated handler.
+ * Wraps the raw token content in a container node so content is never silently lost.
+ * Reports the unhandled type via the context's reportUnhandled callback.
+ */
+export declare class CatchAllHandler implements TokenHandler {
+    readonly type = "*";
+    handle(token: Record<string, unknown>, ctx: ParseContext): {
+        type: "container";
+        content: string;
+        attributes: {
+            'data-unhandled': string;
+            tag: string;
+        };
+    };
+}
+
+/**
+ * Handles 'code' tokens (fenced code blocks).
+ */
+export declare class CodeHandler implements TokenHandler {
+    readonly type = "code";
+    handle(token: Record<string, unknown>, _ctx: ParseContext): {
+        type: "code";
+        content: string;
+        attributes: {
+            lang: string;
+        };
+    };
+}
+
 export declare interface ContentNode {
     type: ContentNodeType;
     content?: string;
@@ -7,16 +52,73 @@ export declare interface ContentNode {
     src?: string;
     alt?: string;
     ordered?: boolean;
+    /** Raw HTML content for passthrough mode */
+    rawHTML?: string;
+    /** Scope anchor value for data-md-scope */
+    scope?: string;
+}
+
+export declare type ContentNodeType = 'text' | 'heading' | 'paragraph' | 'list' | 'list-item' | 'image' | 'code' | 'container' | 'strong' | 'emphasis' | 'link';
+
+/** Default allowed HTML tags for preserveRawHTML mode */
+export declare const defaultAllowedHTMLTags: string[];
+
+/**
+ * Handles 'heading' tokens (h1-h6).
+ */
+export declare class HeadingHandler implements TokenHandler {
+    readonly type = "heading";
+    handle(token: Record<string, unknown>, ctx: ParseContext): {
+        type: "heading";
+        content: string;
+        attributes: {
+            level: string;
+        };
+    };
 }
 
-export declare type ContentNodeType = 'text' | 'heading' | 'paragraph' | 'list' | 'list-item' | 'image' | 'code' | 'container' | 'strong' | 'emphasis';
+/**
+ * Handles 'hr' tokens (horizontal rules).
+ */
+export declare class HrHandler implements TokenHandler {
+    readonly type = "hr";
+    handle(_token: Record<string, unknown>, _ctx: ParseContext): {
+        type: "container";
+        attributes: {
+            tag: string;
+        };
+    };
+}
+
+/**
+ * Handles 'html' tokens (inline or block-level raw HTML).
+ * In preserveRawHTML mode, passes through allowed HTML tags.
+ * Otherwise, stores the raw content as a container node.
+ */
+export declare class HtmlHandler implements TokenHandler {
+    readonly type = "html";
+    handle(token: Record<string, unknown>, ctx: ParseContext): {
+        type: "container";
+        rawHTML: string;
+        content?: undefined;
+    } | {
+        type: "container";
+        content: string;
+        rawHTML?: undefined;
+    } | null;
+}
 
 export declare class HTMLRenderer {
     private config;
-    constructor(config?: StyleConfig);
+    constructor(config?: StyleConfigV2);
     private hasClassConfig;
     private getClass;
     private generateHeadingId;
+    /**
+     * Get the scope attribute string for a node type.
+     * Returns empty string if emitScopeAnchors is disabled.
+     */
+    private getScopeAttr;
     private renderWithClass;
     renderNode(node: ContentNode): string;
     renderNodes(nodes: ContentNode[]): string;
@@ -25,6 +127,33 @@ export declare class HTMLRenderer {
     getCustomCSS(): string;
 }
 
+/**
+ * Handles standalone 'image' tokens.
+ */
+export declare class ImageHandler implements TokenHandler {
+    readonly type = "image";
+    handle(token: Record<string, unknown>, ctx: ParseContext): {
+        type: "image";
+        src: string;
+        alt: string;
+    };
+}
+
+/**
+ * Handles 'list' tokens (ordered and unordered).
+ */
+export declare class ListHandler implements TokenHandler {
+    readonly type = "list";
+    handle(token: Record<string, unknown>, ctx: ParseContext): {
+        type: "list";
+        ordered: boolean;
+        children: {
+            type: "list-item";
+            content: string;
+        }[];
+    };
+}
+
 export declare interface MarkdownContent {
     title: string;
     metadata?: Record<string, unknown>;
@@ -34,14 +163,27 @@ export declare interface MarkdownContent {
 export declare class MarkdownParser {
     private imagePathPrefix;
     private imageBaseUrl;
-    constructor(options?: {
-        imagePathPrefix?: string;
-        imageBaseUrl?: string;
-    });
+    private preserveRawHTML;
+    private slotPattern;
+    private onSlot;
+    private errorRecovery;
+    private maxRecursionDepth;
+    private allowedHTMLTags;
+    private handlerRegistry;
+    private onUnhandledToken?;
+    constructor(options?: ParserOptions);
+    /** Access the handler registry for customization. */
+    get handlers(): TokenHandlerRegistry;
     private processImagePath;
     private processInlineFormatting;
+    private processSlots;
+    private processRawHTML;
+    /**
+     * Build the ParseContext that is passed to every token handler.
+     * This is the bridge between the parser's private services and the handlers.
+     */
+    private createContext;
     private parseTokens;
-    private parseToken;
     parse(markdown: string, options?: ParseOptions): MarkdownContent;
     parseToNodes(markdown: string, options?: ParseOptions): ContentNode[];
 }
@@ -50,7 +192,7 @@ export declare class MarkdownPipeline {
     private parser;
     private renderer;
     private config;
-    constructor(config?: PipelineConfig);
+    constructor(config?: PipelineConfigV2);
     parse(markdown: string): ContentNode[];
     parseWithMetadata(markdown: string): MarkdownContent;
     render(nodes: ContentNode[]): string;
@@ -59,16 +201,71 @@ export declare class MarkdownPipeline {
         lang?: string;
         charset?: string;
     }): string;
-    getConfig(): Readonly<Required<PipelineConfig>>;
+    getConfig(): Readonly<PipelineConfigV2>;
     getCustomCSS(): string;
 }
 
+/** Maps ContentNodeType to ScopeValue */
+export declare const nodeTypeToScope: Record<ContentNodeType, ScopeValue>;
+
+/**
+ * Handles 'paragraph' tokens, including inline images and raw HTML.
+ */
+export declare class ParagraphHandler implements TokenHandler {
+    readonly type = "paragraph";
+    handle(token: Record<string, unknown>, ctx: ParseContext): {
+        type: "paragraph";
+        children: ContentNode[];
+        content?: undefined;
+    } | {
+        type: "paragraph";
+        content: string;
+        children?: undefined;
+    } | null;
+}
+
+/**
+ * Context passed to every token handler, giving access to parser services.
+ */
+export declare interface ParseContext {
+    processImagePath(src: string): string;
+    processInlineFormatting(text: string): string;
+    processSlots(text: string): string;
+    processRawHTML(html: string): string;
+    parseTokens(tokens: unknown[], depth: number): ContentNode[];
+    preserveRawHTML: boolean;
+    errorRecovery: 'throw' | 'warn' | 'silent';
+    maxRecursionDepth: number;
+    /** Report an unhandled token type so callers can be notified */
+    reportUnhandled(type: string, token: Record<string, unknown>): void;
+}
+
 export declare interface ParseOptions {
     gfm?: boolean;
     breaks?: boolean;
     pedantic?: boolean;
 }
 
+export declare interface ParserOptions {
+    imagePathPrefix?: string;
+    imageBaseUrl?: string;
+    preserveRawHTML?: boolean;
+    slotPattern?: RegExp;
+    onSlot?: (name: string) => string;
+    errorRecovery?: 'throw' | 'warn' | 'silent';
+    maxRecursionDepth?: number;
+    allowedHTMLTags?: string[];
+    /**
+     * Callback invoked when a token type has no dedicated handler.
+     * The catch-all handler will still produce a container node for the content,
+     * but this callback allows callers to log, warn, or track unhandled types.
+     *
+     * @param type - The unhandled token type name (e.g. 'table', 'def')
+     * @param token - The raw marked token
+     */
+    onUnhandledToken?: (type: string, token: Record<string, unknown>) => void;
+}
+
 export declare interface PipelineConfig {
     imagePathPrefix?: string;
     imageBaseUrl?: string;
@@ -76,10 +273,85 @@ export declare interface PipelineConfig {
     styleOptions?: StyleConfig;
 }
 
+/**
+ * v2: Extended PipelineConfig with raw HTML passthrough, slot hooks, and error recovery.
+ */
+export declare interface PipelineConfigV2 extends PipelineConfig {
+    styleOptions?: StyleConfigV2;
+    /** Preserve raw HTML tags in markdown (img, style, div, span, etc.) (default: false) */
+    preserveRawHTML?: boolean;
+    /** Regex pattern for slot placeholders like [[SLOT_NAME]] (default: /\[\[(.*?)\]\]/g) */
+    slotPattern?: RegExp;
+    /** Callback to resolve slot values. Called with the slot name, returns replacement string. */
+    onSlot?: (name: string) => string;
+    /** Error recovery mode (default: 'throw' — backward compatible) */
+    errorRecovery?: 'throw' | 'warn' | 'silent';
+    /** Max recursion depth to prevent stack overflow (default: 100) */
+    maxRecursionDepth?: number;
+    /** Additional allowed HTML tags for preserveRawHTML mode */
+    allowedHTMLTags?: string[];
+}
+
+/** Scope hierarchy values for data-md-scope */
+export declare type ScopeValue = 'root' | 'heading' | 'paragraph' | 'list' | 'list-item' | 'image' | 'code' | 'strong' | 'emphasis' | 'link' | 'container';
+
 export declare interface StyleConfig {
     classPrefix?: string;
     customCSS?: string;
     addHeadingIds?: boolean;
 }
 
+/**
+ * v2: Extended StyleConfig with scope anchor support.
+ */
+export declare interface StyleConfigV2 extends StyleConfig {
+    /** Emit data-md-scope attributes for CSS @scope anchoring (default: false) */
+    emitScopeAnchors?: boolean;
+}
+
+/**
+ * A token handler knows how to convert a single marked token into a ContentNode.
+ * Handlers are registered by token type name in the handler registry.
+ */
+export declare interface TokenHandler {
+    /** The marked token type this handler processes (e.g. 'heading', 'paragraph') */
+    readonly type: string;
+    /** Convert a marked token to a ContentNode (or null to skip) */
+    handle(token: Record<string, unknown>, ctx: ParseContext): ContentNode | null;
+}
+
+/**
+ * Registry of token handlers. Handlers can be added/overridden externally
+ * to extend the parser without modifying its internals.
+ *
+ * The registry uses a two-tier lookup:
+ * 1. First, check for a dedicated handler by token type name
+ * 2. If none found, fall back to the catch-all handler (registered as '*')
+ *
+ * The catch-all handler ensures no content is silently lost — unhandled
+ * token types are wrapped in a container node with `data-unhandled` attribute.
+ */
+export declare class TokenHandlerRegistry {
+    private handlers;
+    private catchAll;
+    constructor();
+    /** Register a handler. Overrides any existing handler for the same token type. */
+    register(handler: TokenHandler): void;
+    /** Unregister a handler by token type. */
+    unregister(type: string): void;
+    /**
+     * Get a handler for the given token type.
+     * Falls back to the catch-all handler if no dedicated handler is registered.
+     */
+    get(type: string): TokenHandler;
+    /** Check if a dedicated handler exists for the given token type (excludes catch-all). */
+    has(type: string): boolean;
+    /** Get all registered dedicated handler types. */
+    get types(): string[];
+    /** Replace the catch-all handler with a custom implementation. */
+    setCatchAll(handler: TokenHandler): void;
+    /** Get the current catch-all handler. */
+    getCatchAll(): TokenHandler;
+}
+
 export { }

package/dist/index.js

@@ -1,8 +1,251 @@
 import { marked } from "marked";
+const defaultAllowedHTMLTags = [
+  "img",
+  "style",
+  "div",
+  "span",
+  "section",
+  "article",
+  "aside",
+  "header",
+  "footer",
+  "nav",
+  "main",
+  "figure",
+  "figcaption",
+  "details",
+  "summary",
+  "mark",
+  "time",
+  "video",
+  "audio",
+  "source",
+  "iframe",
+  "embed"
+];
+const nodeTypeToScope = {
+  "text": "root",
+  "heading": "heading",
+  "paragraph": "paragraph",
+  "list": "list",
+  "list-item": "list-item",
+  "image": "image",
+  "code": "code",
+  "container": "container",
+  "strong": "strong",
+  "emphasis": "emphasis",
+  "link": "link"
+};
+class HeadingHandler {
+  constructor() {
+    this.type = "heading";
+  }
+  handle(token, ctx) {
+    return {
+      type: "heading",
+      content: ctx.processSlots(token.text),
+      attributes: { level: String(token.depth) }
+    };
+  }
+}
+class ParagraphHandler {
+  constructor() {
+    this.type = "paragraph";
+  }
+  handle(token, ctx) {
+    const tokens = token.tokens || [];
+    const hasInlineImage = tokens.some((t) => t.type === "image");
+    const hasInlineHTML = tokens.some((t) => t.type === "html");
+    if (hasInlineImage || ctx.preserveRawHTML && hasInlineHTML) {
+      const children = tokens.map((t) => {
+        if (t.type === "image") {
+          return {
+            type: "image",
+            src: ctx.processImagePath(t.href),
+            alt: t.text || ""
+          };
+        }
+        if (t.type === "html" && ctx.preserveRawHTML) {
+          const processed = ctx.processRawHTML(t.raw);
+          if (processed.trim()) {
+            return { type: "text", content: processed };
+          }
+          return null;
+        }
+        return {
+          type: "text",
+          content: ctx.processSlots(ctx.processInlineFormatting(t.text || ""))
+        };
+      }).filter(Boolean);
+      if (children.length === 0) return null;
+      return { type: "paragraph", children };
+    }
+    return {
+      type: "paragraph",
+      content: ctx.processSlots(ctx.processInlineFormatting(token.text))
+    };
+  }
+}
+class ListHandler {
+  constructor() {
+    this.type = "list";
+  }
+  handle(token, ctx) {
+    return {
+      type: "list",
+      ordered: token.ordered,
+      children: token.items.map((item) => ({
+        type: "list-item",
+        content: ctx.processSlots(ctx.processInlineFormatting(item.text))
+      }))
+    };
+  }
+}
+class ImageHandler {
+  constructor() {
+    this.type = "image";
+  }
+  handle(token, ctx) {
+    return {
+      type: "image",
+      src: ctx.processImagePath(token.href),
+      alt: token.title || ""
+    };
+  }
+}
+class CodeHandler {
+  constructor() {
+    this.type = "code";
+  }
+  handle(token, _ctx) {
+    return {
+      type: "code",
+      content: token.text,
+      attributes: { lang: token.lang || "" }
+    };
+  }
+}
+class HrHandler {
+  constructor() {
+    this.type = "hr";
+  }
+  handle(_token, _ctx) {
+    return { type: "container", attributes: { tag: "hr" } };
+  }
+}
+class BlockquoteHandler {
+  constructor() {
+    this.type = "blockquote";
+  }
+  handle(token, ctx) {
+    return {
+      type: "container",
+      attributes: { tag: "blockquote" },
+      children: ctx.parseTokens(token.tokens || [], ctx.maxRecursionDepth + 1)
+    };
+  }
+}
+class HtmlHandler {
+  constructor() {
+    this.type = "html";
+  }
+  handle(token, ctx) {
+    if (ctx.preserveRawHTML) {
+      const raw = token.raw;
+      const processed = ctx.processRawHTML(raw);
+      if (processed.trim()) {
+        return { type: "container", rawHTML: processed };
+      }
+      return null;
+    }
+    return { type: "container", content: token.raw };
+  }
+}
+class CatchAllHandler {
+  constructor() {
+    this.type = "*";
+  }
+  handle(token, ctx) {
+    const tokenType = token.type;
+    ctx.reportUnhandled(tokenType, token);
+    const raw = token.raw;
+    const text = token.text;
+    const content = raw || text || `[unhandled: ${tokenType}]`;
+    return {
+      type: "container",
+      content,
+      attributes: {
+        "data-unhandled": tokenType,
+        tag: "div"
+      }
+    };
+  }
+}
+class TokenHandlerRegistry {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.register(new HeadingHandler());
+    this.register(new ParagraphHandler());
+    this.register(new ListHandler());
+    this.register(new ImageHandler());
+    this.register(new CodeHandler());
+    this.register(new HrHandler());
+    this.register(new BlockquoteHandler());
+    this.register(new HtmlHandler());
+    this.catchAll = new CatchAllHandler();
+  }
+  /** Register a handler. Overrides any existing handler for the same token type. */
+  register(handler) {
+    this.handlers.set(handler.type, handler);
+  }
+  /** Unregister a handler by token type. */
+  unregister(type) {
+    this.handlers.delete(type);
+  }
+  /**
+   * Get a handler for the given token type.
+   * Falls back to the catch-all handler if no dedicated handler is registered.
+   */
+  get(type) {
+    return this.handlers.get(type) ?? this.catchAll;
+  }
+  /** Check if a dedicated handler exists for the given token type (excludes catch-all). */
+  has(type) {
+    return this.handlers.has(type);
+  }
+  /** Get all registered dedicated handler types. */
+  get types() {
+    return Array.from(this.handlers.keys());
+  }
+  /** Replace the catch-all handler with a custom implementation. */
+  setCatchAll(handler) {
+    this.catchAll = handler;
+  }
+  /** Get the current catch-all handler. */
+  getCatchAll() {
+    return this.catchAll;
+  }
+}
+const DEFAULT_SLOT_PATTERN = /\[\[(.*?)\]\]/g;
 class MarkdownParser {
   constructor(options) {
     this.imagePathPrefix = options?.imagePathPrefix || "";
     this.imageBaseUrl = options?.imageBaseUrl || "";
+    this.preserveRawHTML = options?.preserveRawHTML ?? false;
+    this.slotPattern = options?.slotPattern ?? DEFAULT_SLOT_PATTERN;
+    this.onSlot = options?.onSlot;
+    this.errorRecovery = options?.errorRecovery ?? "throw";
+    this.maxRecursionDepth = options?.maxRecursionDepth ?? 100;
+    this.allowedHTMLTags = /* @__PURE__ */ new Set([
+      ...defaultAllowedHTMLTags,
+      ...options?.allowedHTMLTags ?? []
+    ]);
+    this.handlerRegistry = new TokenHandlerRegistry();
+    this.onUnhandledToken = options?.onUnhandledToken;
+  }
+  /** Access the handler registry for customization. */
+  get handlers() {
+    return this.handlerRegistry;
   }
   processImagePath(src) {
     if (src.startsWith("http") || src.startsWith("/")) {
@@ -17,97 +260,93 @@ class MarkdownParser {
   processInlineFormatting(text) {
     return text.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/\*(.+?)\*/g, "<em>$1</em>");
   }
-  parseTokens(tokens) {
+  processSlots(text) {
+    if (!this.onSlot) return text;
+    return text.replace(this.slotPattern, (match, name) => {
+      return this.onSlot(name.trim());
+    });
+  }
+  processRawHTML(html) {
+    if (!this.allowedHTMLTags.has("script")) {
+      html = html.replace(/<script[\s\S]*?<\/script>/gi, "");
+      html = html.replace(/<\/?script[^>]*>/gi, "");
+    }
+    if (!this.allowedHTMLTags.has("style")) {
+      html = html.replace(/<style[\s\S]*?<\/style>/gi, "");
+      html = html.replace(/<\/?style[^>]*>/gi, "");
+    }
+    return html;
+  }
+  /**
+   * Build the ParseContext that is passed to every token handler.
+   * This is the bridge between the parser's private services and the handlers.
+   */
+  createContext() {
+    const self = this;
+    return {
+      get preserveRawHTML() {
+        return self.preserveRawHTML;
+      },
+      get errorRecovery() {
+        return self.errorRecovery;
+      },
+      get maxRecursionDepth() {
+        return self.maxRecursionDepth;
+      },
+      processImagePath: (src) => self.processImagePath(src),
+      processInlineFormatting: (text) => self.processInlineFormatting(text),
+      processSlots: (text) => self.processSlots(text),
+      processRawHTML: (html) => self.processRawHTML(html),
+      parseTokens: (tokens, depth) => self.parseTokens(tokens, depth),
+      reportUnhandled: (type, token) => {
+        self.onUnhandledToken?.(type, token);
+      }
+    };
+  }
+  parseTokens(tokens, depth = 0) {
+    if (depth > this.maxRecursionDepth) {
+      const msg = `[md2html] Max recursion depth (${this.maxRecursionDepth}) exceeded, truncating`;
+      if (this.errorRecovery === "warn") {
+        console.warn(msg);
+      }
+      return [];
+    }
     const nodes = [];
+    const ctx = this.createContext();
     for (const token of tokens) {
-      const node = this.parseToken(token);
+      const typedToken = token;
+      const handler = this.handlerRegistry.get(typedToken.type);
+      const node = handler.handle(typedToken, ctx);
       if (node) {
         nodes.push(node);
       }
     }
     return nodes;
   }
-  parseToken(token) {
-    switch (token.type) {
-      case "heading":
-        return {
-          type: "heading",
-          content: token.text,
-          attributes: { level: String(token.depth) }
-        };
-      case "paragraph":
-        const tokens = token.tokens || [];
-        const hasInlineImage = tokens.some((t) => t.type === "image");
-        if (hasInlineImage) {
-          const children = tokens.map((t) => {
-            if (t.type === "image") {
-              return {
-                type: "image",
-                src: this.processImagePath(t.href),
-                alt: t.text || ""
-              };
-            }
-            return {
-              type: "text",
-              content: this.processInlineFormatting(t.text || "")
-            };
-          });
-          return {
-            type: "paragraph",
-            children
-          };
-        }
-        return {
-          type: "paragraph",
-          content: this.processInlineFormatting(token.text)
-        };
-      case "list":
-        return {
-          type: "list",
-          ordered: token.ordered,
-          children: token.items.map((item) => ({
-            type: "list-item",
-            content: this.processInlineFormatting(item.text)
-          }))
-        };
-      case "image":
-        return {
-          type: "image",
-          src: this.processImagePath(token.href),
-          alt: token.title || ""
-        };
-      case "code":
-        return {
-          type: "code",
-          content: token.text,
-          attributes: { lang: token.lang || "" }
-        };
-      case "hr":
-        return { type: "container", attributes: { tag: "hr" } };
-      case "blockquote":
-        return {
-          type: "container",
-          attributes: { tag: "blockquote" },
-          children: this.parseTokens(token.tokens || [])
-        };
-      case "html":
-        return { type: "container", content: token.raw };
-      default:
-        return null;
-    }
-  }
   parse(markdown, options) {
     const parseOptions = {
       gfm: options?.gfm ?? true,
       breaks: options?.breaks ?? false,
       pedantic: options?.pedantic ?? false
     };
-    const tokens = marked.lexer(markdown, parseOptions);
-    const content = this.parseTokens(tokens);
-    return {
-      title: "",
-      content
-    };
+    try {
+      const tokens = marked.lexer(markdown, parseOptions);
+      const content = this.parseTokens(tokens);
+      return {
+        title: "",
+        content
+      };
+    } catch (err) {
+      if (this.errorRecovery === "throw") throw err;
+      const msg = `[md2html] Parse error: ${err instanceof Error ? err.message : String(err)}`;
+      if (this.errorRecovery === "warn") {
+        console.warn(msg);
+      }
+      return {
+        title: "",
+        content: [{ type: "text", content: markdown }]
+      };
+    }
   }
   parseToNodes(markdown, options) {
     return this.parse(markdown, options).content;
@@ -118,7 +357,8 @@ class HTMLRenderer {
     this.config = {
       classPrefix: config.classPrefix || "",
       customCSS: config.customCSS || "",
-      addHeadingIds: config.addHeadingIds ?? false
+      addHeadingIds: config.addHeadingIds ?? false,
+      emitScopeAnchors: config.emitScopeAnchors ?? false
     };
   }
   hasClassConfig() {
@@ -137,11 +377,21 @@ class HTMLRenderer {
     if (!content) return "";
     return content.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
   }
+  /**
+   * Get the scope attribute string for a node type.
+   * Returns empty string if emitScopeAnchors is disabled.
+   */
+  getScopeAttr(node) {
+    if (!this.config.emitScopeAnchors) return "";
+    const scopeValue = node.scope || nodeTypeToScope[node.type] || "container";
+    return ` data-md-scope="${scopeValue}"`;
+  }
   renderWithClass(tag, content, baseClass, nodeClass, extraAttrs) {
     const classAttr = this.hasClassConfig() && baseClass ? ` class="${this.getClass(baseClass, nodeClass)}"` : "";
     return `<${tag}${classAttr}${extraAttrs || ""}>${content}</${tag}>`;
   }
   renderNode(node) {
+    const scopeAttr = this.getScopeAttr(node);
     switch (node.type) {
       case "heading":
         const level = node.attributes?.level || "2";
@@ -153,41 +403,47 @@ class HTMLRenderer {
           headingClass = prefix ? `${prefix}${levelClass}` : levelClass;
         }
         if (!headingClass) {
-          return `<h${level}${headingId}>${node.content || ""}</h${level}>`;
+          return `<h${level}${headingId}${scopeAttr}>${node.content || ""}</h${level}>`;
         }
-        return `<h${level}${headingId} class="${headingClass}">${node.content || ""}</h${level}>`;
+        return `<h${level}${headingId}${scopeAttr} class="${headingClass}">${node.content || ""}</h${level}>`;
       case "paragraph":
         if (node.children) {
           const childrenHtml = node.children.map((child) => this.renderNode(child)).join("");
-          return this.renderWithClass("p", childrenHtml, "paragraph");
+          return this.renderWithClass("p", childrenHtml, "paragraph", void 0, scopeAttr);
         }
-        return this.renderWithClass("p", node.content || "", "paragraph");
+        return this.renderWithClass("p", node.content || "", "paragraph", void 0, scopeAttr);
       case "list":
         const tag = node.ordered ? "ol" : "ul";
         const items = node.children?.map((child) => this.renderNode(child)).join("") || "";
-        return this.renderWithClass(tag, items, "list");
+        return this.renderWithClass(tag, items, "list", void 0, scopeAttr);
       case "list-item":
-        return this.renderWithClass("li", node.content || "", "list-item");
+        return this.renderWithClass("li", node.content || "", "list-item", void 0, scopeAttr);
       case "image":
         const src = node.src || node.attributes?.src || "";
         const alt = node.alt || node.attributes?.alt || "";
         const classStr = this.getClass("image", node.className || void 0);
-        return `<img src="${src}" alt="${alt}"${classStr ? ` class="${classStr}"` : ""}>`;
+        return `<img src="${src}" alt="${alt}"${classStr ? ` class="${classStr}"` : ""}${scopeAttr}>`;
       case "code":
         const codeClass = this.hasClassConfig() ? ` class="${this.getClass("code")} language-${node.attributes?.lang || ""}"` : ` class="language-${node.attributes?.lang || ""}"`;
-        return `<pre><code${codeClass}>${node.content || ""}</code></pre>`;
+        return `<pre${scopeAttr}><code${codeClass}>${node.content || ""}</code></pre>`;
       case "container":
         if (node.attributes?.tag === "hr") return "<hr>";
         if (node.attributes?.tag === "blockquote") {
           const children = node.children?.map((child) => this.renderNode(child)).join("") || "";
-          return this.renderWithClass("blockquote", children, "blockquote");
+          return this.renderWithClass("blockquote", children, "blockquote", void 0, scopeAttr);
+        }
+        if (node.rawHTML) {
+          return node.rawHTML;
         }
         const containerChildren = node.children?.map((child) => this.renderNode(child)).join("") || "";
-        return this.renderWithClass("div", containerChildren, "container", node.className || void 0);
+        return this.renderWithClass("div", containerChildren, "container", node.className || void 0, scopeAttr);
       case "strong":
-        return `<strong>${node.content || ""}</strong>`;
+        return `<strong${scopeAttr}>${node.content || ""}</strong>`;
       case "emphasis":
-        return `<em>${node.content || ""}</em>`;
+        return `<em${scopeAttr}>${node.content || ""}</em>`;
+      case "link":
+        const href = node.attributes?.href || "";
+        return `<a href="${href}"${scopeAttr}>${node.content || ""}</a>`;
       case "text":
       default:
         return node.content || "";
@@ -197,6 +453,12 @@ class HTMLRenderer {
     if (!nodes || nodes.length === 0) {
       return "";
     }
+    if (this.config.emitScopeAnchors) {
+      const inner = nodes.map((node) => this.renderNode(node)).join("\n");
+      return `<div data-md-scope="root">
+${inner}
+</div>`;
+    }
     return nodes.map((node) => this.renderNode(node)).join("\n");
   }
   renderToHTMLString(nodes) {
@@ -222,12 +484,25 @@ class MarkdownPipeline {
       styleOptions: {
         classPrefix: config.styleOptions?.classPrefix || "",
         customCSS: config.styleOptions?.customCSS || "",
-        addHeadingIds: config.styleOptions?.addHeadingIds ?? false
-      }
+        addHeadingIds: config.styleOptions?.addHeadingIds ?? false,
+        emitScopeAnchors: config.styleOptions?.emitScopeAnchors ?? false
+      },
+      preserveRawHTML: config.preserveRawHTML ?? false,
+      slotPattern: config.slotPattern ?? /\[\[(.*?)\]\]/g,
+      onSlot: config.onSlot,
+      errorRecovery: config.errorRecovery ?? "throw",
+      maxRecursionDepth: config.maxRecursionDepth ?? 100,
+      allowedHTMLTags: config.allowedHTMLTags ?? []
     };
     this.parser = new MarkdownParser({
       imagePathPrefix: this.config.imagePathPrefix,
-      imageBaseUrl: this.config.imageBaseUrl
+      imageBaseUrl: this.config.imageBaseUrl,
+      preserveRawHTML: this.config.preserveRawHTML,
+      slotPattern: this.config.slotPattern,
+      onSlot: this.config.onSlot,
+      errorRecovery: this.config.errorRecovery,
+      maxRecursionDepth: this.config.maxRecursionDepth,
+      allowedHTMLTags: this.config.allowedHTMLTags
     });
     this.renderer = new HTMLRenderer(this.config.styleOptions);
   }
@@ -266,8 +541,20 @@ class MarkdownPipeline {
   }
 }
 export {
+  BlockquoteHandler,
+  CatchAllHandler,
+  CodeHandler,
   HTMLRenderer,
+  HeadingHandler,
+  HrHandler,
+  HtmlHandler,
+  ImageHandler,
+  ListHandler,
   MarkdownParser,
-  MarkdownPipeline
+  MarkdownPipeline,
+  ParagraphHandler,
+  TokenHandlerRegistry,
+  defaultAllowedHTMLTags,
+  nodeTypeToScope
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/parser.ts","../src/renderer.ts","../src/pipeline.ts"],"sourcesContent":["import { marked } from 'marked';\nimport { ContentNode, MarkdownContent, ParseOptions } from './types';\n\nexport class MarkdownParser {\n  private imagePathPrefix: string;\n  private imageBaseUrl: string;\n\n  constructor(options?: { imagePathPrefix?: string; imageBaseUrl?: string }) {\n    this.imagePathPrefix = options?.imagePathPrefix || '';\n    this.imageBaseUrl = options?.imageBaseUrl || '';\n  }\n\n  private processImagePath(src: string): string {\n    if (src.startsWith('http') || src.startsWith('/')) {\n      return src;\n    }\n    let path = this.imagePathPrefix ? `${this.imagePathPrefix}${src}` : src;\n    if (this.imageBaseUrl && !path.startsWith('http')) {\n      path = `${this.imageBaseUrl}${path}`;\n    }\n    return path;\n  }\n\n  private processInlineFormatting(text: string): string {\n    return text\n      .replace(/\\*\\*(.+?)\\*\\*/g, '<strong>$1</strong>')\n      .replace(/\\*(.+?)\\*/g, '<em>$1</em>');\n  }\n\n  private parseTokens(tokens: unknown[]): ContentNode[] {\n    const nodes: ContentNode[] = [];\n    \n    for (const token of tokens) {\n      const node = this.parseToken(token as Record<string, unknown>);\n      if (node) {\n        nodes.push(node);\n      }\n    }\n    \n    return nodes;\n  }\n\n  private parseToken(token: Record<string, unknown>): ContentNode | null {\n    switch (token.type) {\n      case 'heading':\n        return {\n          type: 'heading',\n          content: token.text as string,\n          attributes: { level: String(token.depth) }\n        };\n        \n      case 'paragraph':\n        const tokens = (token.tokens as Array<Record<string, unknown>>) || [];\n        const hasInlineImage = tokens.some(t => t.type === 'image');\n        \n        if (hasInlineImage) {\n          const children = tokens.map(t => {\n            if (t.type === 'image') {\n              return {\n                type: 'image' as const,\n                src: this.processImagePath(t.href as string),\n                alt: t.text as string || ''\n              };\n            }\n            return {\n              type: 'text' as const,\n              content: this.processInlineFormatting(t.text as string || '')\n            };\n          });\n          return {\n            type: 'paragraph',\n            children\n          };\n        }\n        \n        return {\n          type: 'paragraph',\n          content: this.processInlineFormatting(token.text as string)\n        };\n        \n      case 'list':\n        return {\n          type: 'list',\n          ordered: token.ordered as boolean,\n          children: (token.items as Array<Record<string, unknown>>).map((item) => ({\n            type: 'list-item',\n            content: this.processInlineFormatting(item.text as string)\n          }))\n        };\n        \n      case 'image':\n        return {\n          type: 'image',\n          src: this.processImagePath(token.href as string),\n          alt: token.title as string || ''\n        };\n\n      case 'code':\n        return {\n          type: 'code',\n          content: token.text as string,\n          attributes: { lang: token.lang as string || '' }\n        };\n      \n      case 'hr':\n        return { type: 'container', attributes: { tag: 'hr' } };\n      \n      case 'blockquote':\n        return {\n          type: 'container',\n          attributes: { tag: 'blockquote' },\n          children: this.parseTokens((token as Record<string, unknown>).tokens as unknown[] || [])\n        };\n      \n      case 'html':\n        return { type: 'container', content: token.raw as string };\n        \n      default:\n        return null;\n    }\n  }\n\n  parse(markdown: string, options?: ParseOptions): MarkdownContent {\n    const parseOptions = {\n      gfm: options?.gfm ?? true,\n      breaks: options?.breaks ?? false,\n      pedantic: options?.pedantic ?? false\n    };\n    \n    const tokens = marked.lexer(markdown, parseOptions as Parameters<typeof marked.lexer>[1]);\n    const content = this.parseTokens(tokens);\n    \n    return {\n      title: '',\n      content\n    };\n  }\n\n  parseToNodes(markdown: string, options?: ParseOptions): ContentNode[] {\n    return this.parse(markdown, options).content;\n  }\n}\n","import { ContentNode, StyleConfig } from './types.js';\n\nexport class HTMLRenderer {\n  private config: Required<StyleConfig>;\n\n  constructor(config: StyleConfig = {}) {\n    this.config = {\n      classPrefix: config.classPrefix || '',\n      customCSS: config.customCSS || '',\n      addHeadingIds: config.addHeadingIds ?? false\n    };\n  }\n\n  private hasClassConfig(): boolean {\n    return this.config.classPrefix !== '' || this.config.addHeadingIds;\n  }\n\n  private getClass(baseClass: string, nodeClass?: string): string {\n    if (!this.hasClassConfig()) {\n      return nodeClass || '';\n    }\n    const prefix = this.config.classPrefix;\n    const classes = [prefix ? `${prefix}${baseClass}` : baseClass];\n    if (nodeClass) classes.push(nodeClass);\n    return classes.join(' ');\n  }\n\n  private generateHeadingId(content?: string): string {\n    if (!content) return '';\n    return content\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, '-')\n      .replace(/(^-|-$)/g, '');\n  }\n\n  private renderWithClass(tag: string, content: string, baseClass?: string, nodeClass?: string, extraAttrs?: string): string {\n    const classAttr = this.hasClassConfig() && baseClass \n      ? ` class=\"${this.getClass(baseClass, nodeClass)}\"` \n      : '';\n    return `<${tag}${classAttr}${extraAttrs || ''}>${content}</${tag}>`;\n  }\n\n  renderNode(node: ContentNode): string {\n    switch (node.type) {\n      case 'heading':\n        const level = node.attributes?.level || '2';\n        const headingId = this.config.addHeadingIds \n          ? ` id=\"${this.generateHeadingId(node.content)}\"` \n          : '';\n        let headingClass = '';\n        if (this.hasClassConfig()) {\n          const prefix = this.config.classPrefix;\n          const levelClass = level === '1' ? 'h1' : level === '2' ? 'h2' : level === '3' ? 'h3' : level === '4' ? 'h4' : level === '5' ? 'h5' : 'h6';\n          headingClass = prefix ? `${prefix}${levelClass}` : levelClass;\n        }\n        if (!headingClass) {\n          return `<h${level}${headingId}>${node.content || ''}</h${level}>`;\n        }\n        return `<h${level}${headingId} class=\"${headingClass}\">${node.content || ''}</h${level}>`;\n        \n      case 'paragraph':\n        if (node.children) {\n          const childrenHtml = node.children.map(child => this.renderNode(child)).join('');\n          return this.renderWithClass('p', childrenHtml, 'paragraph');\n        }\n        return this.renderWithClass('p', node.content || '', 'paragraph');\n        \n      case 'list':\n        const tag = node.ordered ? 'ol' : 'ul';\n        const items = node.children?.map(child => this.renderNode(child)).join('') || '';\n        return this.renderWithClass(tag, items, 'list');\n        \n      case 'list-item':\n        return this.renderWithClass('li', node.content || '', 'list-item');\n        \n      case 'image':\n        const src = node.src || node.attributes?.src || '';\n        const alt = node.alt || node.attributes?.alt || '';\n        const classStr = this.getClass('image', node.className || undefined);\n        return `<img src=\"${src}\" alt=\"${alt}\"${classStr ? ` class=\"${classStr}\"` : ''}>`;\n        \n      case 'code':\n        const codeClass = this.hasClassConfig() \n          ? ` class=\"${this.getClass('code')} language-${node.attributes?.lang || ''}\"` \n          : ` class=\"language-${node.attributes?.lang || ''}\"`;\n        return `<pre><code${codeClass}>${node.content || ''}</code></pre>`;\n      \n      case 'container':\n        if (node.attributes?.tag === 'hr') return '<hr>';\n        if (node.attributes?.tag === 'blockquote') {\n          const children = node.children?.map(child => this.renderNode(child)).join('') || '';\n          return this.renderWithClass('blockquote', children, 'blockquote');\n        }\n        const containerChildren = node.children?.map(child => this.renderNode(child)).join('') || '';\n        return this.renderWithClass('div', containerChildren, 'container', node.className || undefined);\n      \n      case 'strong':\n        return `<strong>${node.content || ''}</strong>`;\n      \n      case 'emphasis':\n        return `<em>${node.content || ''}</em>`;\n      \n      case 'text':\n      default:\n        return node.content || '';\n    }\n  }\n\n  renderNodes(nodes: ContentNode[]): string {\n    if (!nodes || nodes.length === 0) {\n      return '';\n    }\n    return nodes.map(node => this.renderNode(node)).join('\\n');\n  }\n\n  renderToHTMLString(nodes: ContentNode[]): string {\n    return this.renderNodes(nodes);\n  }\n\n  render(markdown: string): string {\n    return markdown;\n  }\n\n  getCustomCSS(): string {\n    return this.config.customCSS;\n  }\n}\n","import { MarkdownParser } from './parser.js';\nimport { HTMLRenderer } from './renderer.js';\nimport { ContentNode, MarkdownContent, PipelineConfig, StyleConfig } from './types.js';\n\nexport class MarkdownPipeline {\n  private parser: MarkdownParser;\n  private renderer: HTMLRenderer;\n  private config: Required<PipelineConfig>;\n\n  constructor(config: PipelineConfig = {}) {\n    this.config = {\n      imagePathPrefix: config.imagePathPrefix || '',\n      imageBaseUrl: config.imageBaseUrl || '',\n      parseOptions: {\n        gfm: config.parseOptions?.gfm ?? true,\n        breaks: config.parseOptions?.breaks ?? false,\n        pedantic: config.parseOptions?.pedantic ?? false\n      },\n      styleOptions: {\n        classPrefix: config.styleOptions?.classPrefix || '',\n        customCSS: config.styleOptions?.customCSS || '',\n        addHeadingIds: config.styleOptions?.addHeadingIds ?? false\n      }\n    };\n\n    this.parser = new MarkdownParser({\n      imagePathPrefix: this.config.imagePathPrefix,\n      imageBaseUrl: this.config.imageBaseUrl\n    });\n    this.renderer = new HTMLRenderer(this.config.styleOptions);\n  }\n\n  parse(markdown: string): ContentNode[] {\n    return this.parser.parseToNodes(markdown, this.config.parseOptions);\n  }\n\n  parseWithMetadata(markdown: string): MarkdownContent {\n    return this.parser.parse(markdown, this.config.parseOptions);\n  }\n\n  render(nodes: ContentNode[]): string {\n    return this.renderer.renderNodes(nodes);\n  }\n\n  renderMarkdown(markdown: string): string {\n    const nodes = this.parse(markdown);\n    return this.render(nodes);\n  }\n\n  renderPage(title: string, nodes: ContentNode[], options?: {\n    lang?: string;\n    charset?: string;\n  }): string {\n    const html = this.render(nodes);\n    return `<!DOCTYPE html>\n<html lang=\"${options?.lang || 'en'}\">\n<head>\n  <meta charset=\"${options?.charset || 'UTF-8'}\">\n  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n  <title>${title}</title>\n</head>\n<body>\n  ${html}\n</body>\n</html>`;\n  }\n\n  getConfig(): Readonly<Required<PipelineConfig>> {\n    return { ...this.config };\n  }\n\n  getCustomCSS(): string {\n    return this.renderer.getCustomCSS();\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/types.ts","../src/handlers/heading-handler.ts","../src/handlers/paragraph-handler.ts","../src/handlers/list-handler.ts","../src/handlers/image-handler.ts","../src/handlers/code-handler.ts","../src/handlers/hr-handler.ts","../src/handlers/blockquote-handler.ts","../src/handlers/html-handler.ts","../src/handlers/catchall-handler.ts","../src/handlers/registry.ts","../src/parser.ts","../src/renderer.ts","../src/pipeline.ts"],"sourcesContent":["export type ContentNodeType = \n  | 'text' \n  | 'heading' \n  | 'paragraph' \n  | 'list' \n  | 'list-item' \n  | 'image' \n  | 'code' \n  | 'container'\n  | 'strong'\n  | 'emphasis'\n  | 'link';\n\nexport interface ContentNode {\n  type: ContentNodeType;\n  content?: string;\n  children?: ContentNode[];\n  attributes?: Record<string, unknown>;\n  className?: string;\n  src?: string;\n  alt?: string;\n  ordered?: boolean;\n  /** Raw HTML content for passthrough mode */\n  rawHTML?: string;\n  /** Scope anchor value for data-md-scope */\n  scope?: string;\n}\n\nexport interface MarkdownContent {\n  title: string;\n  metadata?: Record<string, unknown>;\n  content: ContentNode[];\n}\n\nexport interface ParseOptions {\n  gfm?: boolean;\n  breaks?: boolean;\n  pedantic?: boolean;\n}\n\nexport interface StyleConfig {\n  classPrefix?: string;\n  customCSS?: string;\n  addHeadingIds?: boolean;\n}\n\n/**\n * v2: Extended StyleConfig with scope anchor support.\n */\nexport interface StyleConfigV2 extends StyleConfig {\n  /** Emit data-md-scope attributes for CSS @scope anchoring (default: false) */\n  emitScopeAnchors?: boolean;\n}\n\nexport interface PipelineConfig {\n  imagePathPrefix?: string;\n  imageBaseUrl?: string;\n  parseOptions?: ParseOptions;\n  styleOptions?: StyleConfig;\n}\n\n/**\n * v2: Extended PipelineConfig with raw HTML passthrough, slot hooks, and error recovery.\n */\nexport interface PipelineConfigV2 extends PipelineConfig {\n  styleOptions?: StyleConfigV2;\n  /** Preserve raw HTML tags in markdown (img, style, div, span, etc.) (default: false) */\n  preserveRawHTML?: boolean;\n  /** Regex pattern for slot placeholders like [[SLOT_NAME]] (default: /\\[\\[(.*?)\\]\\]/g) */\n  slotPattern?: RegExp;\n  /** Callback to resolve slot values. Called with the slot name, returns replacement string. */\n  onSlot?: (name: string) => string;\n  /** Error recovery mode (default: 'throw' — backward compatible) */\n  errorRecovery?: 'throw' | 'warn' | 'silent';\n  /** Max recursion depth to prevent stack overflow (default: 100) */\n  maxRecursionDepth?: number;\n  /** Additional allowed HTML tags for preserveRawHTML mode */\n  allowedHTMLTags?: string[];\n}\n\n/** Default allowed HTML tags for preserveRawHTML mode */\nexport const defaultAllowedHTMLTags = [\n  'img', 'style', 'div', 'span', 'section', 'article',\n  'aside', 'header', 'footer', 'nav', 'main', 'figure',\n  'figcaption', 'details', 'summary', 'mark', 'time',\n  'video', 'audio', 'source', 'iframe', 'embed'\n];\n\n/** Scope hierarchy values for data-md-scope */\nexport type ScopeValue =\n  | 'root'\n  | 'heading'\n  | 'paragraph'\n  | 'list'\n  | 'list-item'\n  | 'image'\n  | 'code'\n  | 'strong'\n  | 'emphasis'\n  | 'link'\n  | 'container';\n\n/** Maps ContentNodeType to ScopeValue */\nexport const nodeTypeToScope: Record<ContentNodeType, ScopeValue> = {\n  'text': 'root',\n  'heading': 'heading',\n  'paragraph': 'paragraph',\n  'list': 'list',\n  'list-item': 'list-item',\n  'image': 'image',\n  'code': 'code',\n  'container': 'container',\n  'strong': 'strong',\n  'emphasis': 'emphasis',\n  'link': 'link',\n};\n","import { TokenHandler, ParseContext } from './types.js';\n\n/**\n * Handles 'heading' tokens (h1-h6).\n */\nexport class HeadingHandler implements TokenHandler {\n  readonly type = 'heading';\n\n  handle(token: Record<string, unknown>, ctx: ParseContext) {\n    return {\n      type: 'heading' as const,\n      content: ctx.processSlots(token.text as string),\n      attributes: { level: String(token.depth) }\n    };\n  }\n}\n","import { ContentNode } from '../types.js';\nimport { TokenHandler, ParseContext } from './types.js';\n\n/**\n * Handles 'paragraph' tokens, including inline images and raw HTML.\n */\nexport class ParagraphHandler implements TokenHandler {\n  readonly type = 'paragraph';\n\n  handle(token: Record<string, unknown>, ctx: ParseContext) {\n    const tokens = (token.tokens as Array<Record<string, unknown>>) || [];\n    const hasInlineImage = tokens.some(t => t.type === 'image');\n    const hasInlineHTML = tokens.some(t => t.type === 'html');\n\n    if (hasInlineImage || (ctx.preserveRawHTML && hasInlineHTML)) {\n      const children = tokens.map(t => {\n        if (t.type === 'image') {\n          return {\n            type: 'image' as const,\n            src: ctx.processImagePath(t.href as string),\n            alt: t.text as string || ''\n          };\n        }\n        if (t.type === 'html' && ctx.preserveRawHTML) {\n          const processed = ctx.processRawHTML(t.raw as string);\n          if (processed.trim()) {\n            return { type: 'text' as const, content: processed };\n          }\n          return null;\n        }\n        return {\n          type: 'text' as const,\n          content: ctx.processSlots(ctx.processInlineFormatting(t.text as string || ''))\n        };\n      }).filter(Boolean) as ContentNode[];\n\n      if (children.length === 0) return null;\n\n      return { type: 'paragraph' as const, children };\n    }\n\n    return {\n      type: 'paragraph' as const,\n      content: ctx.processSlots(ctx.processInlineFormatting(token.text as string))\n    };\n  }\n}\n","import { TokenHandler, ParseContext } from './types.js';\n\n/**\n * Handles 'list' tokens (ordered and unordered).\n */\nexport class ListHandler implements TokenHandler {\n  readonly type = 'list';\n\n  handle(token: Record<string, unknown>, ctx: ParseContext) {\n    return {\n      type: 'list' as const,\n      ordered: token.ordered as boolean,\n      children: (token.items as Array<Record<string, unknown>>).map((item) => ({\n        type: 'list-item' as const,\n        content: ctx.processSlots(ctx.processInlineFormatting(item.text as string))\n      }))\n    };\n  }\n}\n","import { TokenHandler, ParseContext } from './types.js';\n\n/**\n * Handles standalone 'image' tokens.\n */\nexport class ImageHandler implements TokenHandler {\n  readonly type = 'image';\n\n  handle(token: Record<string, unknown>, ctx: ParseContext) {\n    return {\n      type: 'image' as const,\n      src: ctx.processImagePath(token.href as string),\n      alt: token.title as string || ''\n    };\n  }\n}\n","import { TokenHandler, ParseContext } from './types.js';\n\n/**\n * Handles 'code' tokens (fenced code blocks).\n */\nexport class CodeHandler implements TokenHandler {\n  readonly type = 'code';\n\n  handle(token: Record<string, unknown>, _ctx: ParseContext) {\n    return {\n      type: 'code' as const,\n      content: token.text as string,\n      attributes: { lang: token.lang as string || '' }\n    };\n  }\n}\n","import { TokenHandler, ParseContext } from './types.js';\n\n/**\n * Handles 'hr' tokens (horizontal rules).\n */\nexport class HrHandler implements TokenHandler {\n  readonly type = 'hr';\n\n  handle(_token: Record<string, unknown>, _ctx: ParseContext) {\n    return { type: 'container' as const, attributes: { tag: 'hr' } };\n  }\n}\n","import { TokenHandler, ParseContext } from './types.js';\n\n/**\n * Handles 'blockquote' tokens.\n */\nexport class BlockquoteHandler implements TokenHandler {\n  readonly type = 'blockquote';\n\n  handle(token: Record<string, unknown>, ctx: ParseContext) {\n    return {\n      type: 'container' as const,\n      attributes: { tag: 'blockquote' },\n      children: ctx.parseTokens((token.tokens as unknown[]) || [], ctx.maxRecursionDepth + 1)\n    };\n  }\n}\n","import { TokenHandler, ParseContext } from './types.js';\n\n/**\n * Handles 'html' tokens (inline or block-level raw HTML).\n * In preserveRawHTML mode, passes through allowed HTML tags.\n * Otherwise, stores the raw content as a container node.\n */\nexport class HtmlHandler implements TokenHandler {\n  readonly type = 'html';\n\n  handle(token: Record<string, unknown>, ctx: ParseContext) {\n    if (ctx.preserveRawHTML) {\n      const raw = token.raw as string;\n      const processed = ctx.processRawHTML(raw);\n      if (processed.trim()) {\n        return { type: 'container' as const, rawHTML: processed };\n      }\n      return null;\n    }\n    return { type: 'container' as const, content: token.raw as string };\n  }\n}\n","import { TokenHandler, ParseContext } from './types.js';\n\n/**\n * Catch-all handler for any token type that doesn't have a dedicated handler.\n * Wraps the raw token content in a container node so content is never silently lost.\n * Reports the unhandled type via the context's reportUnhandled callback.\n */\nexport class CatchAllHandler implements TokenHandler {\n  readonly type = '*';\n\n  handle(token: Record<string, unknown>, ctx: ParseContext) {\n    const tokenType = token.type as string;\n\n    // Report the unhandled token so callers can be notified\n    ctx.reportUnhandled(tokenType, token);\n\n    // Try to extract meaningful content from the raw token\n    const raw = token.raw as string | undefined;\n    const text = token.text as string | undefined;\n    const content = raw || text || `[unhandled: ${tokenType}]`;\n\n    return {\n      type: 'container' as const,\n      content,\n      attributes: {\n        'data-unhandled': tokenType,\n        tag: 'div'\n      }\n    };\n  }\n}\n","import type { TokenHandler } from './types.js';\nimport { HeadingHandler } from './heading-handler.js';\nimport { ParagraphHandler } from './paragraph-handler.js';\nimport { ListHandler } from './list-handler.js';\nimport { ImageHandler } from './image-handler.js';\nimport { CodeHandler } from './code-handler.js';\nimport { HrHandler } from './hr-handler.js';\nimport { BlockquoteHandler } from './blockquote-handler.js';\nimport { HtmlHandler } from './html-handler.js';\nimport { CatchAllHandler } from './catchall-handler.js';\n\n/**\n * Registry of token handlers. Handlers can be added/overridden externally\n * to extend the parser without modifying its internals.\n *\n * The registry uses a two-tier lookup:\n * 1. First, check for a dedicated handler by token type name\n * 2. If none found, fall back to the catch-all handler (registered as '*')\n *\n * The catch-all handler ensures no content is silently lost — unhandled\n * token types are wrapped in a container node with `data-unhandled` attribute.\n */\nexport class TokenHandlerRegistry {\n  private handlers = new Map<string, TokenHandler>();\n  private catchAll: TokenHandler;\n\n  constructor() {\n    // Register all built-in handlers\n    this.register(new HeadingHandler());\n    this.register(new ParagraphHandler());\n    this.register(new ListHandler());\n    this.register(new ImageHandler());\n    this.register(new CodeHandler());\n    this.register(new HrHandler());\n    this.register(new BlockquoteHandler());\n    this.register(new HtmlHandler());\n\n    // Catch-all handler for any unregistered token types\n    this.catchAll = new CatchAllHandler();\n  }\n\n  /** Register a handler. Overrides any existing handler for the same token type. */\n  register(handler: TokenHandler): void {\n    this.handlers.set(handler.type, handler);\n  }\n\n  /** Unregister a handler by token type. */\n  unregister(type: string): void {\n    this.handlers.delete(type);\n  }\n\n  /**\n   * Get a handler for the given token type.\n   * Falls back to the catch-all handler if no dedicated handler is registered.\n   */\n  get(type: string): TokenHandler {\n    return this.handlers.get(type) ?? this.catchAll;\n  }\n\n  /** Check if a dedicated handler exists for the given token type (excludes catch-all). */\n  has(type: string): boolean {\n    return this.handlers.has(type);\n  }\n\n  /** Get all registered dedicated handler types. */\n  get types(): string[] {\n    return Array.from(this.handlers.keys());\n  }\n\n  /** Replace the catch-all handler with a custom implementation. */\n  setCatchAll(handler: TokenHandler): void {\n    this.catchAll = handler;\n  }\n\n  /** Get the current catch-all handler. */\n  getCatchAll(): TokenHandler {\n    return this.catchAll;\n  }\n}\n","import { marked } from 'marked';\nimport { ContentNode, MarkdownContent, ParseOptions, defaultAllowedHTMLTags } from './types.js';\nimport { TokenHandlerRegistry, ParseContext } from './handlers/index.js';\n\nexport interface ParserOptions {\n  imagePathPrefix?: string;\n  imageBaseUrl?: string;\n  preserveRawHTML?: boolean;\n  slotPattern?: RegExp;\n  onSlot?: (name: string) => string;\n  errorRecovery?: 'throw' | 'warn' | 'silent';\n  maxRecursionDepth?: number;\n  allowedHTMLTags?: string[];\n  /**\n   * Callback invoked when a token type has no dedicated handler.\n   * The catch-all handler will still produce a container node for the content,\n   * but this callback allows callers to log, warn, or track unhandled types.\n   *\n   * @param type - The unhandled token type name (e.g. 'table', 'def')\n   * @param token - The raw marked token\n   */\n  onUnhandledToken?: (type: string, token: Record<string, unknown>) => void;\n}\n\nconst DEFAULT_SLOT_PATTERN = /\\[\\[(.*?)\\]\\]/g;\n\n// Re-export handler types for convenience\nexport { TokenHandlerRegistry } from './handlers/index.js';\nexport type { TokenHandler, ParseContext } from './handlers/index.js';\n\n// ─── MarkdownParser ───────────────────────────────────────────────────────────\n\nexport class MarkdownParser {\n  private imagePathPrefix: string;\n  private imageBaseUrl: string;\n  private preserveRawHTML: boolean;\n  private slotPattern: RegExp;\n  private onSlot: ((name: string) => string) | undefined;\n  private errorRecovery: 'throw' | 'warn' | 'silent';\n  private maxRecursionDepth: number;\n  private allowedHTMLTags: Set<string>;\n  private handlerRegistry: TokenHandlerRegistry;\n  private onUnhandledToken?: (type: string, token: Record<string, unknown>) => void;\n\n  constructor(options?: ParserOptions) {\n    this.imagePathPrefix = options?.imagePathPrefix || '';\n    this.imageBaseUrl = options?.imageBaseUrl || '';\n    this.preserveRawHTML = options?.preserveRawHTML ?? false;\n    this.slotPattern = options?.slotPattern ?? DEFAULT_SLOT_PATTERN;\n    this.onSlot = options?.onSlot;\n    this.errorRecovery = options?.errorRecovery ?? 'throw';\n    this.maxRecursionDepth = options?.maxRecursionDepth ?? 100;\n    this.allowedHTMLTags = new Set([\n      ...defaultAllowedHTMLTags,\n      ...(options?.allowedHTMLTags ?? [])\n    ]);\n    this.handlerRegistry = new TokenHandlerRegistry();\n    this.onUnhandledToken = options?.onUnhandledToken;\n  }\n\n  /** Access the handler registry for customization. */\n  get handlers(): TokenHandlerRegistry {\n    return this.handlerRegistry;\n  }\n\n  private processImagePath(src: string): string {\n    if (src.startsWith('http') || src.startsWith('/')) {\n      return src;\n    }\n    let path = this.imagePathPrefix ? `${this.imagePathPrefix}${src}` : src;\n    if (this.imageBaseUrl && !path.startsWith('http')) {\n      path = `${this.imageBaseUrl}${path}`;\n    }\n    return path;\n  }\n\n  private processInlineFormatting(text: string): string {\n    return text\n      .replace(/\\*\\*(.+?)\\*\\*/g, '<strong>$1</strong>')\n      .replace(/\\*(.+?)\\*/g, '<em>$1</em>');\n  }\n\n  private processSlots(text: string): string {\n    if (!this.onSlot) return text;\n    return text.replace(this.slotPattern, (match, name: string) => {\n      return this.onSlot!(name.trim());\n    });\n  }\n\n  private processRawHTML(html: string): string {\n    if (!this.allowedHTMLTags.has('script')) {\n      html = html.replace(/<script[\\s\\S]*?<\\/script>/gi, '');\n      html = html.replace(/<\\/?script[^>]*>/gi, '');\n    }\n    if (!this.allowedHTMLTags.has('style')) {\n      html = html.replace(/<style[\\s\\S]*?<\\/style>/gi, '');\n      html = html.replace(/<\\/?style[^>]*>/gi, '');\n    }\n    return html;\n  }\n\n  /**\n   * Build the ParseContext that is passed to every token handler.\n   * This is the bridge between the parser's private services and the handlers.\n   */\n  private createContext(): ParseContext {\n    const self = this;\n    return {\n      get preserveRawHTML() { return self.preserveRawHTML; },\n      get errorRecovery() { return self.errorRecovery; },\n      get maxRecursionDepth() { return self.maxRecursionDepth; },\n      processImagePath: (src: string) => self.processImagePath(src),\n      processInlineFormatting: (text: string) => self.processInlineFormatting(text),\n      processSlots: (text: string) => self.processSlots(text),\n      processRawHTML: (html: string) => self.processRawHTML(html),\n      parseTokens: (tokens: unknown[], depth: number) => self.parseTokens(tokens, depth),\n      reportUnhandled: (type: string, token: Record<string, unknown>) => {\n        self.onUnhandledToken?.(type, token);\n      }\n    };\n  }\n\n  private parseTokens(tokens: unknown[], depth: number = 0): ContentNode[] {\n    if (depth > this.maxRecursionDepth) {\n      const msg = `[md2html] Max recursion depth (${this.maxRecursionDepth}) exceeded, truncating`;\n      if (this.errorRecovery === 'warn') {\n        console.warn(msg);\n      }\n      return [];\n    }\n\n    const nodes: ContentNode[] = [];\n    const ctx = this.createContext();\n\n    for (const token of tokens) {\n      const typedToken = token as Record<string, unknown>;\n      // The registry automatically falls back to the catch-all handler\n      const handler = this.handlerRegistry.get(typedToken.type as string);\n      const node = handler.handle(typedToken, ctx);\n      if (node) {\n        nodes.push(node);\n      }\n    }\n\n    return nodes;\n  }\n\n  parse(markdown: string, options?: ParseOptions): MarkdownContent {\n    const parseOptions = {\n      gfm: options?.gfm ?? true,\n      breaks: options?.breaks ?? false,\n      pedantic: options?.pedantic ?? false\n    };\n\n    try {\n      const tokens = marked.lexer(markdown, parseOptions as Parameters<typeof marked.lexer>[1]);\n      const content = this.parseTokens(tokens);\n\n      return {\n        title: '',\n        content\n      };\n    } catch (err) {\n      if (this.errorRecovery === 'throw') throw err;\n\n      const msg = `[md2html] Parse error: ${err instanceof Error ? err.message : String(err)}`;\n      if (this.errorRecovery === 'warn') {\n        console.warn(msg);\n      }\n\n      return {\n        title: '',\n        content: [{ type: 'text', content: markdown }]\n      };\n    }\n  }\n\n  parseToNodes(markdown: string, options?: ParseOptions): ContentNode[] {\n    return this.parse(markdown, options).content;\n  }\n}\n","import { ContentNode, StyleConfig, StyleConfigV2, nodeTypeToScope } from './types.js';\n\nexport class HTMLRenderer {\n  private config: Required<StyleConfigV2>;\n\n  constructor(config: StyleConfigV2 = {}) {\n    this.config = {\n      classPrefix: config.classPrefix || '',\n      customCSS: config.customCSS || '',\n      addHeadingIds: config.addHeadingIds ?? false,\n      emitScopeAnchors: config.emitScopeAnchors ?? false\n    };\n  }\n\n  private hasClassConfig(): boolean {\n    return this.config.classPrefix !== '' || this.config.addHeadingIds;\n  }\n\n  private getClass(baseClass: string, nodeClass?: string): string {\n    if (!this.hasClassConfig()) {\n      return nodeClass || '';\n    }\n    const prefix = this.config.classPrefix;\n    const classes = [prefix ? `${prefix}${baseClass}` : baseClass];\n    if (nodeClass) classes.push(nodeClass);\n    return classes.join(' ');\n  }\n\n  private generateHeadingId(content?: string): string {\n    if (!content) return '';\n    return content\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, '-')\n      .replace(/(^-|-$)/g, '');\n  }\n\n  /**\n   * Get the scope attribute string for a node type.\n   * Returns empty string if emitScopeAnchors is disabled.\n   */\n  private getScopeAttr(node: ContentNode): string {\n    if (!this.config.emitScopeAnchors) return '';\n    const scopeValue = node.scope || nodeTypeToScope[node.type] || 'container';\n    return ` data-md-scope=\"${scopeValue}\"`;\n  }\n\n  private renderWithClass(tag: string, content: string, baseClass?: string, nodeClass?: string, extraAttrs?: string): string {\n    const classAttr = this.hasClassConfig() && baseClass \n      ? ` class=\"${this.getClass(baseClass, nodeClass)}\"` \n      : '';\n    return `<${tag}${classAttr}${extraAttrs || ''}>${content}</${tag}>`;\n  }\n\n  renderNode(node: ContentNode): string {\n    const scopeAttr = this.getScopeAttr(node);\n\n    switch (node.type) {\n      case 'heading':\n        const level = node.attributes?.level || '2';\n        const headingId = this.config.addHeadingIds \n          ? ` id=\"${this.generateHeadingId(node.content)}\"` \n          : '';\n        let headingClass = '';\n        if (this.hasClassConfig()) {\n          const prefix = this.config.classPrefix;\n          const levelClass = level === '1' ? 'h1' : level === '2' ? 'h2' : level === '3' ? 'h3' : level === '4' ? 'h4' : level === '5' ? 'h5' : 'h6';\n          headingClass = prefix ? `${prefix}${levelClass}` : levelClass;\n        }\n        if (!headingClass) {\n          return `<h${level}${headingId}${scopeAttr}>${node.content || ''}</h${level}>`;\n        }\n        return `<h${level}${headingId}${scopeAttr} class=\"${headingClass}\">${node.content || ''}</h${level}>`;\n        \n      case 'paragraph':\n        if (node.children) {\n          const childrenHtml = node.children.map(child => this.renderNode(child)).join('');\n          return this.renderWithClass('p', childrenHtml, 'paragraph', undefined, scopeAttr);\n        }\n        return this.renderWithClass('p', node.content || '', 'paragraph', undefined, scopeAttr);\n        \n      case 'list':\n        const tag = node.ordered ? 'ol' : 'ul';\n        const items = node.children?.map(child => this.renderNode(child)).join('') || '';\n        return this.renderWithClass(tag, items, 'list', undefined, scopeAttr);\n        \n      case 'list-item':\n        return this.renderWithClass('li', node.content || '', 'list-item', undefined, scopeAttr);\n        \n      case 'image':\n        const src = node.src || node.attributes?.src || '';\n        const alt = node.alt || node.attributes?.alt || '';\n        const classStr = this.getClass('image', node.className || undefined);\n        return `<img src=\"${src}\" alt=\"${alt}\"${classStr ? ` class=\"${classStr}\"` : ''}${scopeAttr}>`;\n        \n      case 'code':\n        const codeClass = this.hasClassConfig() \n          ? ` class=\"${this.getClass('code')} language-${node.attributes?.lang || ''}\"` \n          : ` class=\"language-${node.attributes?.lang || ''}\"`;\n        return `<pre${scopeAttr}><code${codeClass}>${node.content || ''}</code></pre>`;\n      \n      case 'container':\n        if (node.attributes?.tag === 'hr') return '<hr>';\n        if (node.attributes?.tag === 'blockquote') {\n          const children = node.children?.map(child => this.renderNode(child)).join('') || '';\n          return this.renderWithClass('blockquote', children, 'blockquote', undefined, scopeAttr);\n        }\n        // If node has rawHTML, emit it directly\n        if (node.rawHTML) {\n          return node.rawHTML;\n        }\n        const containerChildren = node.children?.map(child => this.renderNode(child)).join('') || '';\n        return this.renderWithClass('div', containerChildren, 'container', node.className || undefined, scopeAttr);\n      \n      case 'strong':\n        return `<strong${scopeAttr}>${node.content || ''}</strong>`;\n      \n      case 'emphasis':\n        return `<em${scopeAttr}>${node.content || ''}</em>`;\n      \n      case 'link':\n        const href = node.attributes?.href || '';\n        return `<a href=\"${href}\"${scopeAttr}>${node.content || ''}</a>`;\n      \n      case 'text':\n      default:\n        return node.content || '';\n    }\n  }\n\n  renderNodes(nodes: ContentNode[]): string {\n    if (!nodes || nodes.length === 0) {\n      return '';\n    }\n    // Wrap in scope root if emitScopeAnchors is enabled\n    if (this.config.emitScopeAnchors) {\n      const inner = nodes.map(node => this.renderNode(node)).join('\\n');\n      return `<div data-md-scope=\"root\">\\n${inner}\\n</div>`;\n    }\n    return nodes.map(node => this.renderNode(node)).join('\\n');\n  }\n\n  renderToHTMLString(nodes: ContentNode[]): string {\n    return this.renderNodes(nodes);\n  }\n\n  render(markdown: string): string {\n    return markdown;\n  }\n\n  getCustomCSS(): string {\n    return this.config.customCSS;\n  }\n}\n","import { MarkdownParser } from './parser.js';\nimport { HTMLRenderer } from './renderer.js';\nimport { ContentNode, MarkdownContent, PipelineConfigV2 } from './types.js';\n\ntype NormalizedPipelineConfig = Required<Omit<PipelineConfigV2, 'onSlot' | 'slotPattern'>> & {\n  onSlot?: (name: string) => string;\n  slotPattern: RegExp;\n};\n\nexport class MarkdownPipeline {\n  private parser: MarkdownParser;\n  private renderer: HTMLRenderer;\n  private config: NormalizedPipelineConfig;\n\n  constructor(config: PipelineConfigV2 = {}) {\n    this.config = {\n      imagePathPrefix: config.imagePathPrefix || '',\n      imageBaseUrl: config.imageBaseUrl || '',\n      parseOptions: {\n        gfm: config.parseOptions?.gfm ?? true,\n        breaks: config.parseOptions?.breaks ?? false,\n        pedantic: config.parseOptions?.pedantic ?? false\n      },\n      styleOptions: {\n        classPrefix: config.styleOptions?.classPrefix || '',\n        customCSS: config.styleOptions?.customCSS || '',\n        addHeadingIds: config.styleOptions?.addHeadingIds ?? false,\n        emitScopeAnchors: config.styleOptions?.emitScopeAnchors ?? false\n      },\n      preserveRawHTML: config.preserveRawHTML ?? false,\n      slotPattern: config.slotPattern ?? /\\[\\[(.*?)\\]\\]/g,\n      onSlot: config.onSlot,\n      errorRecovery: config.errorRecovery ?? 'throw',\n      maxRecursionDepth: config.maxRecursionDepth ?? 100,\n      allowedHTMLTags: config.allowedHTMLTags ?? []\n    };\n\n    this.parser = new MarkdownParser({\n      imagePathPrefix: this.config.imagePathPrefix,\n      imageBaseUrl: this.config.imageBaseUrl,\n      preserveRawHTML: this.config.preserveRawHTML,\n      slotPattern: this.config.slotPattern,\n      onSlot: this.config.onSlot,\n      errorRecovery: this.config.errorRecovery,\n      maxRecursionDepth: this.config.maxRecursionDepth,\n      allowedHTMLTags: this.config.allowedHTMLTags\n    });\n    this.renderer = new HTMLRenderer(this.config.styleOptions);\n  }\n\n  parse(markdown: string): ContentNode[] {\n    return this.parser.parseToNodes(markdown, this.config.parseOptions);\n  }\n\n  parseWithMetadata(markdown: string): MarkdownContent {\n    return this.parser.parse(markdown, this.config.parseOptions);\n  }\n\n  render(nodes: ContentNode[]): string {\n    return this.renderer.renderNodes(nodes);\n  }\n\n  renderMarkdown(markdown: string): string {\n    const nodes = this.parse(markdown);\n    return this.render(nodes);\n  }\n\n  renderPage(title: string, nodes: ContentNode[], options?: {\n    lang?: string;\n    charset?: string;\n  }): string {\n    const html = this.render(nodes);\n    return `<!DOCTYPE html>\n<html lang=\"${options?.lang || 'en'}\">\n<head>\n  <meta charset=\"${options?.charset || 'UTF-8'}\">\n  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n  <title>${title}</title>\n</head>\n<body>\n  ${html}\n</body>\n</html>`;\n  }\n\n  getConfig(): Readonly<PipelineConfigV2> {\n    return { ...this.config };\n  }\n\n  getCustomCSS(): string {\n    return this.renderer.getCustomCSS();\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/lit-renderer.d.ts

@@ -9,9 +9,13 @@ declare interface ContentNode {
     src?: string;
     alt?: string;
     ordered?: boolean;
+    /** Raw HTML content for passthrough mode */
+    rawHTML?: string;
+    /** Scope anchor value for data-md-scope */
+    scope?: string;
 }
 
-declare type ContentNodeType = 'text' | 'heading' | 'paragraph' | 'list' | 'list-item' | 'image' | 'code' | 'container' | 'strong' | 'emphasis';
+declare type ContentNodeType = 'text' | 'heading' | 'paragraph' | 'list' | 'list-item' | 'image' | 'code' | 'container' | 'strong' | 'emphasis' | 'link';
 
 export declare class LitRenderer {
     private renderTextNode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leadertechie/md2html",
-  "version": "0.1.0-alpha.13",
+  "version": "0.1.0-alpha.14",
   "description": "Markdown to HTML pipeline - parse markdown to AST, render to HTML or Lit templates",
   "type": "module",
   "main": "./dist/index.js",