@leadertechie/md2html 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/index.js

@@ -1,6 +1,1116 @@
-export * from './types';
-export * from './parser';
-export * from './renderer';
-export * from './lit-renderer';
-export * from './pipeline';
-export { LitRenderer as HTMLRenderer } from './lit-renderer';
+import { d as defaultAllowedHTMLTags, H as HTMLRenderer } from "./renderer-Ba-j0YEq.js";
+import { R, n } from "./renderer-Ba-j0YEq.js";
+import { marked } from "marked";
+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 hasInlineLink = tokens.some((t) => t.type === "link");
+    const hasInlineHTML = tokens.some((t) => t.type === "html");
+    if (hasInlineImage || hasInlineLink || 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 === "link") {
+          return {
+            type: "link",
+            content: ctx.processSlots(ctx.processInlineFormatting(t.text || "")),
+            attributes: {
+              href: t.href || "",
+              ...t.title ? { title: t.title } : {}
+            }
+          };
+        }
+        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 LinkHandler {
+  constructor() {
+    this.type = "link";
+  }
+  handle(token, ctx) {
+    const text = token.text || "";
+    const href = token.href || "";
+    const title = token.title || "";
+    return {
+      type: "link",
+      content: ctx.processSlots(ctx.processInlineFormatting(text)),
+      attributes: {
+        href,
+        ...title ? { title } : {}
+      }
+    };
+  }
+}
+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 FrontmatterHandler {
+  constructor() {
+    this.type = "frontmatter";
+  }
+  handle(token, ctx) {
+    const raw = token.raw || "";
+    const lines = raw.split("\n");
+    const parsed = {};
+    let currentKey = null;
+    let currentArray = [];
+    for (const line of lines) {
+      const listMatch = line.match(/^\s+-\s+(.+)$/);
+      if (listMatch && currentKey) {
+        currentArray.push(listMatch[1].trim());
+        continue;
+      }
+      if (currentKey && currentArray.length > 0) {
+        parsed[currentKey] = [...currentArray];
+        currentArray = [];
+        currentKey = null;
+      }
+      const keyMatch = line.match(/^(\w[\w_-]*)\s*:\s*(.*)$/);
+      if (keyMatch) {
+        currentKey = keyMatch[1];
+        const val = keyMatch[2].trim();
+        if (val === "") {
+          continue;
+        } else if (val.startsWith("[") && val.endsWith("]")) {
+          parsed[currentKey] = val.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+          currentKey = null;
+        } else {
+          parsed[currentKey] = val.replace(/^["']|["']$/g, "");
+          currentKey = null;
+        }
+      }
+    }
+    if (currentKey && currentArray.length > 0) {
+      parsed[currentKey] = [...currentArray];
+    }
+    if (ctx.metadata) {
+      Object.assign(ctx.metadata, parsed);
+    }
+    return null;
+  }
+}
+class ContainerBlockHandler {
+  constructor() {
+    this.type = "containerBlock";
+  }
+  handle(token, ctx) {
+    const specifier = token.specifier;
+    const childTokens = token.tokens;
+    if (!specifier) return null;
+    const tagMatch = specifier.match(/^(\w+)/);
+    const idMatch = specifier.match(/#([\w-]+)/);
+    const classMatches = [...specifier.matchAll(/\.([\w-]+)/g)];
+    const tag = tagMatch?.[1] || "div";
+    const id = idMatch?.[1] || "";
+    const classes = classMatches.map((m) => m[1]);
+    const children = ctx.parseTokens(childTokens, 0);
+    return {
+      type: "container",
+      children,
+      attributes: {
+        tag,
+        id: id || void 0
+      },
+      className: classes.length > 0 ? classes.join(" ") : void 0
+    };
+  }
+}
+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.register(new FrontmatterHandler());
+    this.register(new ContainerBlockHandler());
+    this.register(new LinkHandler());
+    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;
+  }
+}
+var h = /* @__PURE__ */ ((t) => (t[t.DEBUG = 1] = "DEBUG", t[t.INFO = 9] = "INFO", t[t.WARN = 13] = "WARN", t[t.ERROR = 17] = "ERROR", t))(h || {});
+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 e = new Error().stack;
+  if (!e) return;
+  const s = e.split(`
+`);
+  for (let r = 1; r < s.length; r++) {
+    const o = s[r].trim(), n2 = $(o);
+    if (!n2) continue;
+    const { file: l } = n2;
+    if (!(l && E.some((m) => l.includes(m))) && !(l && l.includes("/node_modules/")) && l)
+      return n2;
+  }
+}
+function $(t) {
+  const e = t.match(
+    /at\s+(?:(?:async\s+)?(?:(.+?)\s+\()?)?(?:(.+?):(\d+):(\d+)\)?)$/
+  );
+  if (!e) return null;
+  const s = e[1] || "<anonymous>", r = e[2], o = parseInt(e[3], 10), n2 = parseInt(e[4], 10);
+  return r ? { file: r, line: o, column: n2, functionName: s } : null;
+}
+class g {
+  constructor(e = [], s, r = {}) {
+    this.processors = [...e], this.resource = s ?? { serviceName: "unknown" }, this.baseAttributes = { ...r };
+  }
+  // ── Public API ───────────────────────────────────────────────────────────
+  debug(e, s) {
+    this.emit(h.DEBUG, e, void 0, s);
+  }
+  info(e, s) {
+    this.emit(h.INFO, e, void 0, s);
+  }
+  warn(e, s) {
+    this.emit(h.WARN, e, void 0, s);
+  }
+  error(e, s, r) {
+    this.emit(h.ERROR, e, s, r);
+  }
+  /**
+   * Create a child logger with merged base attributes.
+   * Returns a NEW Logger — original is immutable.
+   */
+  withContext(e) {
+    return new g(this.processors, this.resource, {
+      ...this.baseAttributes,
+      ...e
+    });
+  }
+  /**
+   * Append a processor to the pipeline.
+   * Returns a NEW Logger — original is immutable.
+   */
+  withProcessor(e) {
+    return new g(
+      [...this.processors, e],
+      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((e) => e.forceFlush()));
+  }
+  /**
+   * Shutdown: flush + release resources. No logging after shutdown.
+   */
+  async shutdown() {
+    await this.flush(), await Promise.all(this.processors.map((e) => e.shutdown()));
+  }
+  // ── Internal ────────────────────────────────────────────────────────────
+  emit(e, s, r, o) {
+    if (this.processors.length === 0) return;
+    const n2 = (/* @__PURE__ */ new Date()).toISOString(), l = {
+      severityNumber: e,
+      severityText: S[e],
+      body: s,
+      timestamp: n2,
+      observedTimestamp: n2,
+      attributes: { ...this.baseAttributes, ...o },
+      caller: N(),
+      ...r ? { error: r } : {},
+      resource: { ...this.resource }
+    };
+    for (const m of this.processors)
+      try {
+        m.onEmit(l);
+      } catch (f) {
+        console.error(
+          "[telemetry] Processor threw in onEmit:",
+          f
+        );
+      }
+  }
+}
+class T {
+  constructor(e) {
+    this.shutdownFlag = false, this.pendingExport = Promise.resolve(), this.adapter = e;
+  }
+  onEmit(e) {
+    this.shutdownFlag || (this.pendingExport = this.pendingExport.then(() => this.adapter.export([e])).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(e) {
+    this.processors = [], this.resource = {
+      serviceName: e?.serviceName ?? "unknown",
+      environment: e?.environment,
+      version: e?.version,
+      processName: e?.processName
+    };
+  }
+  /**
+   * Register an adapter via a SimpleLogProcessor (immediate export).
+   * For batching, use addProcessor(new BatchLogProcessor(adapter, opts)).
+   */
+  addAdapter(e) {
+    return this.addProcessor(new T(e));
+  }
+  /**
+   * Register a custom processor (SimpleLogProcessor, BatchLogProcessor,
+   * or your own implementation).
+   */
+  addProcessor(e) {
+    return this.processors.push(e), this;
+  }
+  /**
+   * Get a named Logger instance.
+   * The logger inherits the provider's resource and processors.
+   * Optionally provide initial context attributes.
+   */
+  getLogger(e, s) {
+    const r = {
+      ...this.resource,
+      ...e ? { processName: e } : {}
+    };
+    return new g(this.processors, r, s);
+  }
+  /**
+   * Force-flush all registered processors.
+   */
+  async flush() {
+    await Promise.all(this.processors.map((e) => e.forceFlush()));
+  }
+  /**
+   * Shutdown: flush + release all processor resources.
+   */
+  async shutdown() {
+    await this.flush(), await Promise.all(this.processors.map((e) => e.shutdown()));
+  }
+}
+function U(t) {
+  const e = t?.level ?? h.DEBUG, s = t?.json ?? false;
+  return {
+    name: "console",
+    async export(r) {
+      for (const o of r)
+        o.severityNumber < e || (s ? I(o) : R2(o));
+    }
+  };
+}
+function R2(t) {
+  const e = F(t.severityNumber), s = t.timestamp, r = t.severityText, o = t.caller ? ` (${t.caller.file}:${t.caller.line})` : "", n2 = Object.keys(t.attributes).length > 0;
+  !!t.error ? e(
+    `[${s}] [${r}]${o} ${t.body}`,
+    t.attributes,
+    t.error
+  ) : n2 ? e(`[${s}] [${r}]${o} ${t.body}`, t.attributes) : e(`[${s}] [${r}]${o} ${t.body}`);
+}
+function I(t) {
+  const e = {
+    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 && (e.error = {
+    name: t.error.name,
+    message: t.error.message,
+    stack: t.error.stack
+  }), console.log(JSON.stringify(e));
+}
+function F(t) {
+  switch (t) {
+    case h.ERROR:
+      return console.error.bind(console);
+    case h.WARN:
+      return console.warn.bind(console);
+    case h.INFO:
+      return console.log.bind(console);
+    case h.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: h.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) {
+    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.log = options?.logger ?? getDefaultLogger("md2html");
+    this.errorRecovery = options?.errorRecovery ?? "throw";
+    this.maxRecursionDepth = options?.maxRecursionDepth ?? 100;
+    this.allowedHTMLTags = /* @__PURE__ */ new Set([
+      ...defaultAllowedHTMLTags,
+      ...options?.allowedHTMLTags ?? []
+    ]);
+    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;
+    }
+    let path = this.imagePathPrefix ? `${this.imagePathPrefix}${src}` : src;
+    if (this.imageBaseUrl && !path.startsWith("http")) {
+      path = `${this.imageBaseUrl}${path}`;
+    }
+    return path;
+  }
+  processInlineFormatting(text) {
+    return text.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/\*(.+?)\*/g, "<em>$1</em>");
+  }
+  processSlots(text) {
+    if (!this.onSlot) return text;
+    return text.replace(this.slotPattern, (match, name) => {
+      return this.onSlot(name.trim());
+    });
+  }
+  /**
+   * Check if an attribute name is allowed for a given tag.
+   * Supports "data-*" wildcard prefix matching.
+   */
+  isAttributeAllowed(tagName, attrName) {
+    const globalAllowed = this.allowedAttributes["*"];
+    if (globalAllowed && this.matchesAttributeList(attrName, globalAllowed)) {
+      return true;
+    }
+    const tagAllowed = this.allowedAttributes[tagName];
+    if (tagAllowed && this.matchesAttributeList(attrName, tagAllowed)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Check if an attribute name matches a list of allowed patterns.
+   * Supports "data-*" wildcard prefix matching.
+   */
+  matchesAttributeList(attrName, allowed) {
+    const lower = attrName.toLowerCase();
+    for (const pattern of allowed) {
+      if (pattern.endsWith("-*")) {
+        const prefix = pattern.slice(0, -1).toLowerCase();
+        if (lower.startsWith(prefix)) return true;
+      } else if (pattern.toLowerCase() === lower) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Filter attributes on an HTML tag, keeping only allowed ones.
+   */
+  filterTagAttributes(tag) {
+    const tagMatch = tag.match(/^<\/?(\w+)/);
+    if (!tagMatch) return tag;
+    const tagName = tagMatch[1].toLowerCase();
+    const hasRules = Object.keys(this.allowedAttributes).length > 0;
+    if (!hasRules) return tag;
+    const attrRegex = /(\S+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+))/g;
+    const selfClosing = tag.endsWith("/>");
+    const tagOpen = tagMatch[0];
+    const remaining = tag.slice(tagOpen.length);
+    let filtered = tagOpen;
+    let match;
+    while ((match = attrRegex.exec(remaining)) !== null) {
+      const attrName = match[1];
+      const attrValue = match[2] ?? match[3] ?? match[4] ?? "";
+      if (this.isAttributeAllowed(tagName, attrName)) {
+        filtered += ` ${attrName}="${attrValue.replace(/"/g, '"')}"`;
+      }
+    }
+    if (selfClosing) {
+      filtered += " /";
+    }
+    filtered += ">";
+    return filtered;
+  }
+  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, "");
+    }
+    const hasAttrRules = Object.keys(this.allowedAttributes).length > 0;
+    if (hasAttrRules) {
+      html = html.replace(/<[^>]+>/g, (match) => this.filterTagAttributes(match));
+    }
+    return html;
+  }
+  /**
+   * Build a ParserServices object that bridges the parser's private methods
+   * to the ParseContext factory. This keeps context creation decoupled.
+   */
+  buildServices() {
+    return {
+      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
+    };
+  }
+  /**
+   * Process an array of marked tokens into ContentNodes.
+   * When depth === 0 (root), creates a shared context that accumulates metadata.
+   * For recursive calls (depth > 0), creates a fresh context for each level.
+   */
+  parseTokens(tokens, depth = 0, sharedCtx) {
+    if (depth > this.maxRecursionDepth) {
+      const msg = `[md2html] Max recursion depth (${this.maxRecursionDepth}) exceeded, truncating`;
+      if (this.errorRecovery === "warn") {
+        this.log.warn(msg);
+      }
+      return [];
+    }
+    const nodes = [];
+    const ctx = sharedCtx || createParseContext(this.buildServices());
+    for (const token of tokens) {
+      const typedToken = token;
+      const handler = this.handlerRegistry.get(typedToken.type);
+      const node = handler.handle(typedToken, ctx);
+      if (node) {
+        nodes.push(node);
+      }
+    }
+    return nodes;
+  }
+  parse(markdown, options) {
+    const parseOptions = {
+      gfm: options?.gfm ?? true,
+      breaks: options?.breaks ?? false,
+      pedantic: options?.pedantic ?? false
+    };
+    try {
+      const processed = this.preprocessor.process(markdown);
+      const rawTokens = marked.lexer(processed, parseOptions);
+      const tokens = this.postprocessor.process(rawTokens);
+      const ctx = createParseContext(this.buildServices());
+      const content = this.parseTokens(tokens, 0, ctx);
+      return {
+        title: "",
+        metadata: { ...ctx.metadata },
+        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") {
+        this.log.warn(msg);
+      }
+      return {
+        title: "",
+        content: [{ type: "text", content: markdown }]
+      };
+    }
+  }
+  parseToNodes(markdown, options) {
+    return this.parse(markdown, options).content;
+  }
+}
+class MarkdownPipeline {
+  constructor(config = {}) {
+    this.log = config.logger ?? getDefaultLogger("md2html");
+    this.config = {
+      imagePathPrefix: config.imagePathPrefix || "",
+      imageBaseUrl: config.imageBaseUrl || "",
+      parseOptions: {
+        gfm: config.parseOptions?.gfm ?? true,
+        breaks: config.parseOptions?.breaks ?? false,
+        pedantic: config.parseOptions?.pedantic ?? false
+      },
+      styleOptions: {
+        classPrefix: config.styleOptions?.classPrefix || "",
+        customCSS: config.styleOptions?.customCSS || "",
+        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 ?? [],
+      allowedAttributes: config.allowedAttributes ?? {}
+    };
+    this.parser = new MarkdownParser({
+      imagePathPrefix: this.config.imagePathPrefix,
+      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,
+      allowedAttributes: this.config.allowedAttributes
+    });
+    this.renderer = new HTMLRenderer(this.config.styleOptions);
+  }
+  parse(markdown) {
+    return this.parser.parseToNodes(markdown, this.config.parseOptions);
+  }
+  parseWithMetadata(markdown) {
+    return this.parser.parse(markdown, this.config.parseOptions);
+  }
+  render(nodes) {
+    return this.renderer.renderNodes(nodes);
+  }
+  renderMarkdown(markdown) {
+    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);
+    return `<!DOCTYPE html>
+<html lang="${options?.lang || "en"}">
+<head>
+  <meta charset="${options?.charset || "UTF-8"}">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+</head>
+<body>
+  ${html}
+</body>
+</html>`;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  getCustomCSS() {
+    return this.renderer.getCustomCSS();
+  }
+}
+function walkTree(root, visitor) {
+  return walkNode(root, null, 0, visitor);
+}
+function walkNode(node, parent, depth, visitor) {
+  let processed = visitor.enter ? visitor.enter(node, parent, depth) : node;
+  if (processed === null) return null;
+  if (processed.children && processed.children.length > 0) {
+    processed = {
+      ...processed,
+      children: processed.children.map((child) => walkNode(child, processed, depth + 1, visitor)).filter(Boolean)
+    };
+  }
+  processed = visitor.exit ? visitor.exit(processed, parent, depth) : processed;
+  if (processed === null) return null;
+  return processed;
+}
+function collectFromTree(root, collector) {
+  const results = [];
+  collectNode(root, null, 0, collector, results);
+  return results;
+}
+function collectNode(node, parent, depth, collector, results) {
+  const result = collector(node, parent, depth);
+  if (result !== null) {
+    results.push(result);
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      collectNode(child, node, depth + 1, collector, results);
+    }
+  }
+}
+function collectByType(root, type) {
+  return collectFromTree(
+    root,
+    (node) => node.type === type ? node : null
+  );
+}
+function collectHeadings(root) {
+  return collectFromTree(root, (node) => {
+    if (node.type === "heading") {
+      return {
+        level: node.attributes?.level || "2",
+        text: node.content || "",
+        id: node.attributes?.id
+      };
+    }
+    return null;
+  });
+}
+function collectImages(root) {
+  return collectFromTree(root, (node) => {
+    if (node.type === "image") {
+      return { src: node.src || "", alt: node.alt || "" };
+    }
+    return null;
+  });
+}
+class NodeFactory {
+  static heading(content, attributes) {
+    return {
+      type: "heading",
+      content,
+      attributes: { level: attributes?.level || "2", ...attributes }
+    };
+  }
+  static paragraph(contentOrChildren, children) {
+    if (typeof contentOrChildren === "string") {
+      return { type: "paragraph", content: contentOrChildren };
+    }
+    return { type: "paragraph", children: contentOrChildren ?? children };
+  }
+  static list(items, ordered, attributes) {
+    return {
+      type: "list",
+      ordered: ordered ?? false,
+      children: items,
+      ...attributes ? { attributes } : {}
+    };
+  }
+  static listItem(content) {
+    return { type: "list-item", content };
+  }
+  static image(src, alt, className) {
+    return { type: "image", src, alt: alt || "", ...className ? { className } : {} };
+  }
+  static code(content, lang) {
+    return {
+      type: "code",
+      content,
+      attributes: { lang: lang || "" }
+    };
+  }
+  static container(children, config) {
+    const node = { type: "container" };
+    if (children && children.length > 0) node.children = children;
+    if (config?.rawHTML) node.rawHTML = config.rawHTML;
+    if (config?.scope) node.scope = config.scope;
+    const attrs = {};
+    if (config?.tag) attrs.tag = config.tag;
+    if (config?.id) attrs.id = config.id;
+    if (Object.keys(attrs).length > 0) node.attributes = attrs;
+    if (config?.className) node.className = config.className;
+    return node;
+  }
+  static text(content) {
+    return { type: "text", content };
+  }
+  static strong(content) {
+    return { type: "strong", content };
+  }
+  static emphasis(content) {
+    return { type: "emphasis", content };
+  }
+  static link(href, content) {
+    return { type: "link", content, attributes: { href } };
+  }
+}
+export {
+  BlockquoteHandler,
+  CatchAllHandler,
+  CodeHandler,
+  CompositePreprocessor,
+  CompositeTokenPostprocessor,
+  ContainerBlockHandler,
+  ContainerBlockPostprocessor,
+  ContainerBlockPreprocessor,
+  FrontmatterHandler,
+  HTMLRenderer,
+  HeadingHandler,
+  HrHandler,
+  HtmlHandler,
+  ImageHandler,
+  LinkHandler,
+  ListHandler,
+  MarkdownParser,
+  MarkdownPipeline,
+  NodeFactory,
+  ParagraphHandler,
+  R as RendererStrategyRegistry,
+  TokenHandlerRegistry,
+  collectByType,
+  collectFromTree,
+  collectHeadings,
+  collectImages,
+  createDefaultPostprocessor,
+  createDefaultPreprocessor,
+  createParseContext,
+  defaultAllowedHTMLTags,
+  n as nodeTypeToScope,
+  walkTree
+};
+//# sourceMappingURL=index.js.map