@leadertechie/md2html 0.1.0-alpha.18 → 0.1.0-alpha.19

package/dist/index.js

@@ -1,41 +1,6 @@
+import { d as defaultAllowedHTMLTags, H as HTMLRenderer } from "./lit-renderer-Bp1Q6wYL.js";
+import { L, a, b, c, e, f, g, h, i, j, k, l, m, n, R, o } from "./lit-renderer-Bp1Q6wYL.js";
 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";
@@ -268,7 +233,7 @@ class ContainerBlockHandler {
     const classMatches = [...specifier.matchAll(/\.([\w-]+)/g)];
     const tag = tagMatch?.[1] || "div";
     const id = idMatch?.[1] || "";
-    const classes = classMatches.map((m) => m[1]);
+    const classes = classMatches.map((m2) => m2[1]);
     const children = ctx.parseTokens(childTokens, 0);
     return {
       type: "container",
@@ -329,6 +294,392 @@ class TokenHandlerRegistry {
     return this.catchAll;
   }
 }
+var h2 = /* @__PURE__ */ ((t) => (t[t.DEBUG = 1] = "DEBUG", t[t.INFO = 9] = "INFO", t[t.WARN = 13] = "WARN", t[t.ERROR = 17] = "ERROR", t))(h2 || {});
+const S = {
+  1: "DEBUG",
+  9: "INFO",
+  13: "WARN",
+  17: "ERROR"
+}, E = [
+  "/telemetry/src/logger.ts",
+  "/telemetry/src/caller.ts",
+  "/telemetry/src/index.ts"
+];
+function N() {
+  const e2 = new Error().stack;
+  if (!e2) return;
+  const s = e2.split(`
+`);
+  for (let r = 1; r < s.length; r++) {
+    const o2 = s[r].trim(), n2 = $(o2);
+    if (!n2) continue;
+    const { file: l2 } = n2;
+    if (!(l2 && E.some((m2) => l2.includes(m2))) && !(l2 && l2.includes("/node_modules/")) && l2)
+      return n2;
+  }
+}
+function $(t) {
+  const e2 = t.match(
+    /at\s+(?:(?:async\s+)?(?:(.+?)\s+\()?)?(?:(.+?):(\d+):(\d+)\)?)$/
+  );
+  if (!e2) return null;
+  const s = e2[1] || "<anonymous>", r = e2[2], o2 = parseInt(e2[3], 10), n2 = parseInt(e2[4], 10);
+  return r ? { file: r, line: o2, column: n2, functionName: s } : null;
+}
+class g2 {
+  constructor(e2 = [], s, r = {}) {
+    this.processors = [...e2], this.resource = s ?? { serviceName: "unknown" }, this.baseAttributes = { ...r };
+  }
+  // ── Public API ───────────────────────────────────────────────────────────
+  debug(e2, s) {
+    this.emit(h2.DEBUG, e2, void 0, s);
+  }
+  info(e2, s) {
+    this.emit(h2.INFO, e2, void 0, s);
+  }
+  warn(e2, s) {
+    this.emit(h2.WARN, e2, void 0, s);
+  }
+  error(e2, s, r) {
+    this.emit(h2.ERROR, e2, s, r);
+  }
+  /**
+   * Create a child logger with merged base attributes.
+   * Returns a NEW Logger — original is immutable.
+   */
+  withContext(e2) {
+    return new g2(this.processors, this.resource, {
+      ...this.baseAttributes,
+      ...e2
+    });
+  }
+  /**
+   * Append a processor to the pipeline.
+   * Returns a NEW Logger — original is immutable.
+   */
+  withProcessor(e2) {
+    return new g2(
+      [...this.processors, e2],
+      this.resource,
+      this.baseAttributes
+    );
+  }
+  /**
+   * Force-flush all pending records in all processors.
+   * Await before the end of a CF Worker request (inside ctx.waitUntil).
+   */
+  async flush() {
+    await Promise.all(this.processors.map((e2) => e2.forceFlush()));
+  }
+  /**
+   * Shutdown: flush + release resources. No logging after shutdown.
+   */
+  async shutdown() {
+    await this.flush(), await Promise.all(this.processors.map((e2) => e2.shutdown()));
+  }
+  // ── Internal ────────────────────────────────────────────────────────────
+  emit(e2, s, r, o2) {
+    if (this.processors.length === 0) return;
+    const n2 = (/* @__PURE__ */ new Date()).toISOString(), l2 = {
+      severityNumber: e2,
+      severityText: S[e2],
+      body: s,
+      timestamp: n2,
+      observedTimestamp: n2,
+      attributes: { ...this.baseAttributes, ...o2 },
+      caller: N(),
+      ...r ? { error: r } : {},
+      resource: { ...this.resource }
+    };
+    for (const m2 of this.processors)
+      try {
+        m2.onEmit(l2);
+      } catch (f2) {
+        console.error(
+          "[telemetry] Processor threw in onEmit:",
+          f2
+        );
+      }
+  }
+}
+class T {
+  constructor(e2) {
+    this.shutdownFlag = false, this.pendingExport = Promise.resolve(), this.adapter = e2;
+  }
+  onEmit(e2) {
+    this.shutdownFlag || (this.pendingExport = this.pendingExport.then(() => this.adapter.export([e2])).catch((s) => {
+      console.error(
+        `[telemetry] SimpleLogProcessor: adapter "${this.adapter.name}" export failed:`,
+        s
+      );
+    }));
+  }
+  async forceFlush() {
+    await this.pendingExport;
+  }
+  async shutdown() {
+    this.shutdownFlag = true, await this.forceFlush(), await this.adapter.shutdown?.();
+  }
+}
+class M {
+  constructor(e2) {
+    this.processors = [], this.resource = {
+      serviceName: e2?.serviceName ?? "unknown",
+      environment: e2?.environment,
+      version: e2?.version,
+      processName: e2?.processName
+    };
+  }
+  /**
+   * Register an adapter via a SimpleLogProcessor (immediate export).
+   * For batching, use addProcessor(new BatchLogProcessor(adapter, opts)).
+   */
+  addAdapter(e2) {
+    return this.addProcessor(new T(e2));
+  }
+  /**
+   * Register a custom processor (SimpleLogProcessor, BatchLogProcessor,
+   * or your own implementation).
+   */
+  addProcessor(e2) {
+    return this.processors.push(e2), this;
+  }
+  /**
+   * Get a named Logger instance.
+   * The logger inherits the provider's resource and processors.
+   * Optionally provide initial context attributes.
+   */
+  getLogger(e2, s) {
+    const r = {
+      ...this.resource,
+      ...e2 ? { processName: e2 } : {}
+    };
+    return new g2(this.processors, r, s);
+  }
+  /**
+   * Force-flush all registered processors.
+   */
+  async flush() {
+    await Promise.all(this.processors.map((e2) => e2.forceFlush()));
+  }
+  /**
+   * Shutdown: flush + release all processor resources.
+   */
+  async shutdown() {
+    await this.flush(), await Promise.all(this.processors.map((e2) => e2.shutdown()));
+  }
+}
+function U(t) {
+  const e2 = t?.level ?? h2.DEBUG, s = t?.json ?? false;
+  return {
+    name: "console",
+    async export(r) {
+      for (const o2 of r)
+        o2.severityNumber < e2 || (s ? I(o2) : R2(o2));
+    }
+  };
+}
+function R2(t) {
+  const e2 = F(t.severityNumber), s = t.timestamp, r = t.severityText, o2 = t.caller ? ` (${t.caller.file}:${t.caller.line})` : "", n2 = Object.keys(t.attributes).length > 0;
+  !!t.error ? e2(
+    `[${s}] [${r}]${o2} ${t.body}`,
+    t.attributes,
+    t.error
+  ) : n2 ? e2(`[${s}] [${r}]${o2} ${t.body}`, t.attributes) : e2(`[${s}] [${r}]${o2} ${t.body}`);
+}
+function I(t) {
+  const e2 = {
+    timestamp: t.timestamp,
+    level: t.severityText,
+    message: t.body,
+    service: t.resource.serviceName,
+    environment: t.resource.environment,
+    attributes: t.attributes,
+    caller: t.caller
+  };
+  t.error && (e2.error = {
+    name: t.error.name,
+    message: t.error.message,
+    stack: t.error.stack
+  }), console.log(JSON.stringify(e2));
+}
+function F(t) {
+  switch (t) {
+    case h2.ERROR:
+      return console.error.bind(console);
+    case h2.WARN:
+      return console.warn.bind(console);
+    case h2.INFO:
+      return console.log.bind(console);
+    case h2.DEBUG:
+    default:
+      return console.debug.bind(console);
+  }
+}
+const defaultLoggers = /* @__PURE__ */ new Map();
+function getDefaultLogger(serviceName) {
+  let log = defaultLoggers.get(serviceName);
+  if (!log) {
+    const provider = new M({ serviceName });
+    provider.addAdapter(U({ level: h2.WARN }));
+    log = provider.getLogger();
+    defaultLoggers.set(serviceName, log);
+  }
+  return log;
+}
+function createParseContext(services) {
+  const metadata = {};
+  return {
+    get preserveRawHTML() {
+      return services.preserveRawHTML;
+    },
+    get errorRecovery() {
+      return services.errorRecovery;
+    },
+    get maxRecursionDepth() {
+      return services.maxRecursionDepth;
+    },
+    processImagePath: (src) => services.processImagePath(src),
+    processInlineFormatting: (text) => services.processInlineFormatting(text),
+    processSlots: (text) => services.processSlots(text),
+    processRawHTML: (html) => services.processRawHTML(html),
+    parseTokens: (tokens, depth) => services.parseTokens(tokens, depth),
+    reportUnhandled: (type, token) => {
+      services.onUnhandledToken?.(type, token);
+    },
+    metadata
+  };
+}
+class ContainerBlockPreprocessor {
+  constructor() {
+    this.name = "container-blocks";
+  }
+  process(markdown) {
+    return markdown.replace(/^:::(?:(\w+(?:[.#][\w-]+)*)\s*)?$/gm, (_match, specifier) => {
+      if (!specifier) {
+        return "<!-- /md-container -->";
+      }
+      const normalized = specifier.match(/^\w/) ? specifier : `div${specifier}`;
+      return `<!-- md-container:${normalized} -->`;
+    });
+  }
+}
+class CompositePreprocessor {
+  constructor(processors) {
+    this.name = "composite";
+    this.processors = [];
+    if (processors) {
+      this.processors = [...processors];
+    }
+  }
+  /** Add a preprocessor to the chain. Returns `this` for fluent API. */
+  add(processor) {
+    this.processors.push(processor);
+    return this;
+  }
+  /** Remove a preprocessor by name. */
+  remove(name) {
+    this.processors = this.processors.filter((p) => p.name !== name);
+  }
+  /** Get the list of registered preprocessors. */
+  getProcessors() {
+    return [...this.processors];
+  }
+  process(markdown) {
+    let result = markdown;
+    for (const processor of this.processors) {
+      result = processor.process(result);
+    }
+    return result;
+  }
+}
+function createDefaultPreprocessor() {
+  return new CompositePreprocessor([
+    new ContainerBlockPreprocessor()
+  ]);
+}
+class ContainerBlockPostprocessor {
+  constructor() {
+    this.name = "container-blocks";
+  }
+  process(tokens) {
+    const result = [];
+    const stack = [];
+    for (const token of tokens) {
+      const t = token;
+      if (t.type === "html") {
+        const raw = t.raw.trim();
+        const openMatch = raw.match(/^<!--\s*md-container:\s*(\S+)\s*-->$/);
+        const closeMatch = raw.match(/^<!--\s*\/md-container\s*-->$/);
+        if (openMatch) {
+          stack.push({
+            specifier: openMatch[1],
+            tokens: []
+          });
+          continue;
+        }
+        if (closeMatch) {
+          if (stack.length === 0) {
+            continue;
+          }
+          const container = stack.pop();
+          const processedInner = this.process(container.tokens);
+          const containerToken = {
+            type: "containerBlock",
+            specifier: container.specifier,
+            tokens: processedInner
+          };
+          if (stack.length > 0) {
+            stack[stack.length - 1].tokens.push(containerToken);
+          } else {
+            result.push(containerToken);
+          }
+          continue;
+        }
+      }
+      if (stack.length > 0) {
+        stack[stack.length - 1].tokens.push(token);
+      } else {
+        result.push(token);
+      }
+    }
+    return result;
+  }
+}
+class CompositeTokenPostprocessor {
+  constructor(processors) {
+    this.name = "composite";
+    this.processors = [];
+    if (processors) {
+      this.processors = [...processors];
+    }
+  }
+  /** Add a postprocessor to the chain. Returns `this` for fluent API. */
+  add(processor) {
+    this.processors.push(processor);
+    return this;
+  }
+  /** Remove a postprocessor by name. */
+  remove(name) {
+    this.processors = this.processors.filter((p) => p.name !== name);
+  }
+  /** Get the list of registered postprocessors. */
+  getProcessors() {
+    return [...this.processors];
+  }
+  process(tokens) {
+    let result = tokens;
+    for (const processor of this.processors) {
+      result = processor.process(result);
+    }
+    return result;
+  }
+}
+function createDefaultPostprocessor() {
+  return new CompositeTokenPostprocessor([
+    new ContainerBlockPostprocessor()
+  ]);
+}
 const DEFAULT_SLOT_PATTERN = /\[\[(.*?)\]\]/g;
 class MarkdownParser {
   constructor(options) {
@@ -337,6 +688,7 @@ class MarkdownParser {
     this.preserveRawHTML = options?.preserveRawHTML ?? false;
     this.slotPattern = options?.slotPattern ?? DEFAULT_SLOT_PATTERN;
     this.onSlot = options?.onSlot;
+    this.log = options?.logger ?? getDefaultLogger("md2html");
     this.errorRecovery = options?.errorRecovery ?? "throw";
     this.maxRecursionDepth = options?.maxRecursionDepth ?? 100;
     this.allowedHTMLTags = /* @__PURE__ */ new Set([
@@ -346,11 +698,21 @@ class MarkdownParser {
     this.allowedAttributes = options?.allowedAttributes ?? {};
     this.handlerRegistry = new TokenHandlerRegistry();
     this.onUnhandledToken = options?.onUnhandledToken;
+    this.preprocessor = createDefaultPreprocessor();
+    this.postprocessor = createDefaultPostprocessor();
   }
   /** Access the handler registry for customization. */
   get handlers() {
     return this.handlerRegistry;
   }
+  /** Access the preprocessor chain for customization. */
+  get preprocessors() {
+    return this.preprocessor;
+  }
+  /** Access the token postprocessor chain for customization. */
+  get postprocessors() {
+    return this.postprocessor;
+  }
   processImagePath(src) {
     if (src.startsWith("http") || src.startsWith("/")) {
       return src;
@@ -445,31 +807,20 @@ class MarkdownParser {
     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.
+   * Build a ParserServices object that bridges the parser's private methods
+   * to the ParseContext factory. This keeps context creation decoupled.
    */
-  createContext() {
-    const self = this;
-    const metadata = {};
+  buildServices() {
     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);
-      },
-      metadata
+      preserveRawHTML: this.preserveRawHTML,
+      errorRecovery: this.errorRecovery,
+      maxRecursionDepth: this.maxRecursionDepth,
+      processImagePath: (src) => this.processImagePath(src),
+      processInlineFormatting: (text) => this.processInlineFormatting(text),
+      processSlots: (text) => this.processSlots(text),
+      processRawHTML: (html) => this.processRawHTML(html),
+      parseTokens: (tokens, depth) => this.parseTokens(tokens, depth),
+      onUnhandledToken: this.onUnhandledToken
     };
   }
   /**
@@ -481,12 +832,12 @@ class MarkdownParser {
     if (depth > this.maxRecursionDepth) {
       const msg = `[md2html] Max recursion depth (${this.maxRecursionDepth}) exceeded, truncating`;
       if (this.errorRecovery === "warn") {
-        console.warn(msg);
+        this.log.warn(msg);
       }
       return [];
     }
     const nodes = [];
-    const ctx = sharedCtx || this.createContext();
+    const ctx = sharedCtx || createParseContext(this.buildServices());
     for (const token of tokens) {
       const typedToken = token;
       const handler = this.handlerRegistry.get(typedToken.type);
@@ -497,82 +848,6 @@ class MarkdownParser {
     }
     return nodes;
   }
-  /**
-   * Pre-process markdown: convert `:::tag#id.class` container syntax
-   * into HTML comment markers that marked will preserve as html tokens,
-   * but won't affect markdown parsing of the inner content.
-   *
-   * Example:
-   *   :::section#header
-   *   # Heading inside container
-   *   Some text
-   *   :::
-   *
-   * Becomes:
-   *   <!-- md-container:section#header -->
-   *   # Heading inside container
-   *   Some text
-   *   <!-- /md-container -->
-   */
-  preprocessContainerBlocks(markdown) {
-    return markdown.replace(/^:::(?:(\w+(?:[.#][\w-]+)*)\s*)?$/gm, (match, specifier) => {
-      if (!specifier) {
-        return "<!-- /md-container -->";
-      }
-      const normalized = specifier.match(/^\w/) ? specifier : `div${specifier}`;
-      return `<!-- md-container:${normalized} -->`;
-    });
-  }
-  /**
-   * Post-process marked tokens to collapse container block markers
-   * into structured containerBlock tokens with proper nesting.
-   *
-   * This handles nesting depth up to maxRecursionDepth.
-   */
-  postprocessTokens(tokens) {
-    const result = [];
-    const stack = [];
-    for (const token of tokens) {
-      const t = token;
-      if (t.type === "html") {
-        const raw = t.raw.trim();
-        const openMatch = raw.match(/^<!--\s*md-container:\s*(\S+)\s*-->$/);
-        const closeMatch = raw.match(/^<!--\s*\/md-container\s*-->$/);
-        if (openMatch) {
-          const newContainer = {
-            specifier: openMatch[1],
-            tokens: []
-          };
-          stack.push(newContainer);
-          continue;
-        }
-        if (closeMatch) {
-          if (stack.length === 0) {
-            continue;
-          }
-          const container = stack.pop();
-          const processedInner = this.postprocessTokens(container.tokens);
-          const containerToken = {
-            type: "containerBlock",
-            specifier: container.specifier,
-            tokens: processedInner
-          };
-          if (stack.length > 0) {
-            stack[stack.length - 1].tokens.push(containerToken);
-          } else {
-            result.push(containerToken);
-          }
-          continue;
-        }
-      }
-      if (stack.length > 0) {
-        stack[stack.length - 1].tokens.push(token);
-      } else {
-        result.push(token);
-      }
-    }
-    return result;
-  }
   parse(markdown, options) {
     const parseOptions = {
       gfm: options?.gfm ?? true,
@@ -580,10 +855,10 @@ class MarkdownParser {
       pedantic: options?.pedantic ?? false
     };
     try {
-      const processed = this.preprocessContainerBlocks(markdown);
+      const processed = this.preprocessor.process(markdown);
       const rawTokens = marked.lexer(processed, parseOptions);
-      const tokens = this.postprocessTokens(rawTokens);
-      const ctx = this.createContext();
+      const tokens = this.postprocessor.process(rawTokens);
+      const ctx = createParseContext(this.buildServices());
       const content = this.parseTokens(tokens, 0, ctx);
       return {
         title: "",
@@ -594,7 +869,7 @@ class MarkdownParser {
       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);
+        this.log.warn(msg);
       }
       return {
         title: "",
@@ -606,296 +881,9 @@ class MarkdownParser {
     return this.parse(markdown, options).content;
   }
 }
-class HeadingRendererStrategy {
-  constructor() {
-    this.type = "heading";
-  }
-  render(node, _renderChild, ctx) {
-    const level = node.attributes?.level || "2";
-    const headingId = ctx.addHeadingIds ? ` id="${ctx.generateHeadingId(node.content)}"` : "";
-    const scopeAttr = ctx.getScopeAttr(node);
-    if (!ctx.hasClassConfig()) {
-      return `<h${level}${headingId}${scopeAttr}>${node.content || ""}</h${level}>`;
-    }
-    const prefix = ctx.classPrefix;
-    const levelClass = level === "1" ? "h1" : level === "2" ? "h2" : level === "3" ? "h3" : level === "4" ? "h4" : level === "5" ? "h5" : "h6";
-    const headingClass = prefix ? `${prefix}${levelClass}` : levelClass;
-    return `<h${level}${headingId}${scopeAttr} class="${headingClass}">${node.content || ""}</h${level}>`;
-  }
-}
-class ParagraphRendererStrategy {
-  constructor() {
-    this.type = "paragraph";
-  }
-  render(node, renderChild, ctx) {
-    const scopeAttr = ctx.getScopeAttr(node);
-    if (node.children) {
-      const childrenHtml = node.children.map(renderChild).join("");
-      return ctx.hasClassConfig() && ctx.classPrefix ? `<p class="${ctx.classPrefix}paragraph"${scopeAttr}>${childrenHtml}</p>` : `<p${scopeAttr}>${childrenHtml}</p>`;
-    }
-    return ctx.hasClassConfig() && ctx.classPrefix ? `<p class="${ctx.classPrefix}paragraph"${scopeAttr}>${node.content || ""}</p>` : `<p${scopeAttr}>${node.content || ""}</p>`;
-  }
-}
-class ListRendererStrategy {
-  constructor() {
-    this.type = "list";
-  }
-  render(node, renderChild, ctx) {
-    const tag = node.ordered ? "ol" : "ul";
-    const items = node.children?.map(renderChild).join("") || "";
-    const scopeAttr = ctx.getScopeAttr(node);
-    return ctx.hasClassConfig() && ctx.classPrefix ? `<${tag} class="${ctx.classPrefix}list"${scopeAttr}>${items}</${tag}>` : `<${tag}${scopeAttr}>${items}</${tag}>`;
-  }
-}
-class ListItemRendererStrategy {
-  constructor() {
-    this.type = "list-item";
-  }
-  render(node, _renderChild, ctx) {
-    const scopeAttr = ctx.getScopeAttr(node);
-    return ctx.hasClassConfig() && ctx.classPrefix ? `<li class="${ctx.classPrefix}list-item"${scopeAttr}>${node.content || ""}</li>` : `<li${scopeAttr}>${node.content || ""}</li>`;
-  }
-}
-class ImageRendererStrategy {
-  constructor() {
-    this.type = "image";
-  }
-  render(node, _renderChild, ctx) {
-    const src = node.src || node.attributes?.src || "";
-    const alt = node.alt || node.attributes?.alt || "";
-    const scopeAttr = ctx.getScopeAttr(node);
-    let classStr = "";
-    if (ctx.hasClassConfig()) {
-      const prefix = ctx.classPrefix;
-      classStr = prefix ? `${prefix}image` : "image";
-      if (node.className) classStr += ` ${node.className}`;
-      return `<img src="${src}" alt="${alt}" class="${classStr}"${scopeAttr}>`;
-    }
-    if (node.className) {
-      return `<img src="${src}" alt="${alt}" class="${node.className}"${scopeAttr}>`;
-    }
-    return `<img src="${src}" alt="${alt}"${scopeAttr}>`;
-  }
-}
-class CodeRendererStrategy {
-  constructor() {
-    this.type = "code";
-  }
-  render(node, _renderChild, ctx) {
-    const scopeAttr = ctx.getScopeAttr(node);
-    const lang = node.attributes?.lang || "";
-    if (ctx.hasClassConfig()) {
-      const prefix = ctx.classPrefix;
-      const codeClass = prefix ? `${prefix}code` : "code";
-      return `<pre${scopeAttr}><code class="${codeClass} language-${lang}">${node.content || ""}</code></pre>`;
-    }
-    return `<pre${scopeAttr}><code class="language-${lang}">${node.content || ""}</code></pre>`;
-  }
-}
-class ContainerRendererStrategy {
-  constructor() {
-    this.type = "container";
-  }
-  render(node, renderChild, ctx) {
-    if (node.rawHTML) {
-      return node.rawHTML;
-    }
-    const tag = node.attributes?.tag || "div";
-    const children = node.children?.map(renderChild).join("") || "";
-    const id = node.attributes?.id;
-    const idAttr = id ? ` id="${id}"` : "";
-    const scopeAttr = ctx.getScopeAttr(node);
-    if (tag === "hr") return "<hr>";
-    if (ctx.hasClassConfig()) {
-      const containerClass = ctx.getContainerClass(tag);
-      const prefix = ctx.classPrefix;
-      if (prefix) {
-        const classes2 = [prefix + (containerClass || "container")];
-        if (node.className) classes2.push(node.className);
-        return `<${tag} class="${classes2.join(" ")}"${idAttr}${scopeAttr}>${children}</${tag}>`;
-      }
-      const classes = [containerClass || "container"];
-      if (node.className) classes.push(node.className);
-      return `<${tag} class="${classes.join(" ")}"${idAttr}${scopeAttr}>${children}</${tag}>`;
-    }
-    if (node.className) {
-      return `<${tag} class="${node.className}"${idAttr}${scopeAttr}>${children}</${tag}>`;
-    }
-    return `<${tag}${idAttr}${scopeAttr}>${children}</${tag}>`;
-  }
-}
-class StrongRendererStrategy {
-  constructor() {
-    this.type = "strong";
-  }
-  render(node, _renderChild, ctx) {
-    return `<strong${ctx.getScopeAttr(node)}>${node.content || ""}</strong>`;
-  }
-}
-class EmphasisRendererStrategy {
-  constructor() {
-    this.type = "emphasis";
-  }
-  render(node, _renderChild, ctx) {
-    return `<em${ctx.getScopeAttr(node)}>${node.content || ""}</em>`;
-  }
-}
-class LinkRendererStrategy {
-  constructor() {
-    this.type = "link";
-  }
-  render(node, _renderChild, ctx) {
-    const href = node.attributes?.href || "";
-    return `<a href="${href}"${ctx.getScopeAttr(node)}>${node.content || ""}</a>`;
-  }
-}
-class TextRendererStrategy {
-  constructor() {
-    this.type = "text";
-  }
-  render(node, _renderChild, _ctx) {
-    return node.content || "";
-  }
-}
-class RendererStrategyRegistry {
-  constructor() {
-    this.strategies = /* @__PURE__ */ new Map();
-    this.register(new HeadingRendererStrategy());
-    this.register(new ParagraphRendererStrategy());
-    this.register(new ListRendererStrategy());
-    this.register(new ListItemRendererStrategy());
-    this.register(new ImageRendererStrategy());
-    this.register(new CodeRendererStrategy());
-    this.register(new ContainerRendererStrategy());
-    this.register(new StrongRendererStrategy());
-    this.register(new EmphasisRendererStrategy());
-    this.register(new LinkRendererStrategy());
-    this.register(new TextRendererStrategy());
-    this.fallback = new TextRendererStrategy();
-  }
-  /** Register a strategy for a node type. Overrides any existing strategy. */
-  register(strategy) {
-    this.strategies.set(strategy.type, strategy);
-  }
-  /** Unregister a strategy by node type. */
-  unregister(type) {
-    this.strategies.delete(type);
-  }
-  /** Get a strategy for the given node type, falling back to catch-all. */
-  get(type) {
-    return this.strategies.get(type) ?? this.fallback;
-  }
-  /** Check if a dedicated strategy exists for the given node type. */
-  has(type) {
-    return this.strategies.has(type);
-  }
-  /** Get all registered dedicated strategy types. */
-  get types() {
-    return Array.from(this.strategies.keys());
-  }
-  /** Replace the fallback strategy. */
-  setFallback(strategy) {
-    this.fallback = strategy;
-  }
-}
-class HTMLRenderer {
-  constructor(config = {}) {
-    this.config = {
-      classPrefix: config.classPrefix || "",
-      customCSS: config.customCSS || "",
-      addHeadingIds: config.addHeadingIds ?? false,
-      emitScopeAnchors: config.emitScopeAnchors ?? false
-    };
-    this.strategyRegistry = new RendererStrategyRegistry();
-  }
-  /** Access the strategy registry for customization. */
-  get strategies() {
-    return this.strategyRegistry;
-  }
-  hasClassConfig() {
-    return this.config.classPrefix !== "" || this.config.addHeadingIds;
-  }
-  getClass(baseClass, nodeClass) {
-    if (!this.hasClassConfig()) {
-      return nodeClass || "";
-    }
-    const prefix = this.config.classPrefix;
-    const classes = [prefix ? `${prefix}${baseClass}` : baseClass];
-    if (nodeClass) classes.push(nodeClass);
-    return classes.join(" ");
-  }
-  generateHeadingId(content) {
-    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}"`;
-  }
-  /**
-   * Get the CSS class for a container's tag-based rendering.
-   * Returns just the tag name since renderWithClass applies the prefix.
-   */
-  getContainerClass(tag) {
-    if (!this.hasClassConfig()) return "";
-    return tag;
-  }
-  buildRenderContext() {
-    const self = this;
-    return {
-      get classPrefix() {
-        return self.config.classPrefix;
-      },
-      get addHeadingIds() {
-        return self.config.addHeadingIds;
-      },
-      get emitScopeAnchors() {
-        return self.config.emitScopeAnchors;
-      },
-      get customCSS() {
-        return self.config.customCSS;
-      },
-      hasClassConfig: () => self.hasClassConfig(),
-      getClass: (baseClass, nodeClass) => self.getClass(baseClass, nodeClass),
-      getScopeAttr: (node) => self.getScopeAttr(node),
-      generateHeadingId: (content) => self.generateHeadingId(content),
-      getContainerClass: (tag) => self.getContainerClass(tag)
-    };
-  }
-  renderNode(node) {
-    const ctx = this.buildRenderContext();
-    const strategy = this.strategyRegistry.get(node.type);
-    return strategy.render(node, (child) => this.renderNode(child), ctx);
-  }
-  renderNodes(nodes) {
-    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) {
-    return this.renderNodes(nodes);
-  }
-  render(markdown) {
-    return markdown;
-  }
-  getCustomCSS() {
-    return this.config.customCSS;
-  }
-}
 class MarkdownPipeline {
   constructor(config = {}) {
+    this.log = config.logger ?? getDefaultLogger("md2html");
     this.config = {
       imagePathPrefix: config.imagePathPrefix || "",
       imageBaseUrl: config.imageBaseUrl || "",
@@ -941,8 +929,16 @@ class MarkdownPipeline {
     return this.renderer.renderNodes(nodes);
   }
   renderMarkdown(markdown) {
-    const nodes = this.parse(markdown);
-    return this.render(nodes);
+    try {
+      const nodes = this.parse(markdown);
+      return this.render(nodes);
+    } catch (err) {
+      this.log.error("Markdown render failed", err, {
+        length: markdown.length,
+        recovery: this.config.errorRecovery
+      });
+      throw err;
+    }
   }
   renderPage(title, nodes, options) {
     const html = this.render(nodes);
@@ -1087,7 +1083,11 @@ export {
   BlockquoteHandler,
   CatchAllHandler,
   CodeHandler,
+  CompositePreprocessor,
+  CompositeTokenPostprocessor,
   ContainerBlockHandler,
+  ContainerBlockPostprocessor,
+  ContainerBlockPreprocessor,
   FrontmatterHandler,
   HTMLRenderer,
   HeadingHandler,
@@ -1096,18 +1096,35 @@ export {
   ImageHandler,
   LinkHandler,
   ListHandler,
+  L as LitCodeStrategy,
+  a as LitContainerStrategy,
+  b as LitEmphasisStrategy,
+  c as LitFallbackStrategy,
+  e as LitHeadingStrategy,
+  f as LitImageStrategy,
+  g as LitLinkStrategy,
+  h as LitListItemStrategy,
+  i as LitListStrategy,
+  j as LitParagraphStrategy,
+  k as LitRenderer,
+  l as LitStrategyRegistry,
+  m as LitStrongStrategy,
+  n as LitTextStrategy,
   MarkdownParser,
   MarkdownPipeline,
   NodeFactory,
   ParagraphHandler,
-  RendererStrategyRegistry,
+  R as RendererStrategyRegistry,
   TokenHandlerRegistry,
   collectByType,
   collectFromTree,
   collectHeadings,
   collectImages,
+  createDefaultPostprocessor,
+  createDefaultPreprocessor,
+  createParseContext,
   defaultAllowedHTMLTags,
-  nodeTypeToScope,
+  o as nodeTypeToScope,
   walkTree
 };
 //# sourceMappingURL=index.js.map