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

package/dist/index.js

@@ -55,8 +55,9 @@ class ParagraphHandler {
   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 || ctx.preserveRawHTML && hasInlineHTML) {
+    if (hasInlineImage || hasInlineLink || ctx.preserveRawHTML && hasInlineHTML) {
       const children = tokens.map((t) => {
         if (t.type === "image") {
           return {
@@ -65,6 +66,16 @@ class ParagraphHandler {
             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()) {
@@ -161,6 +172,24 @@ class HtmlHandler {
     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 = "*";
@@ -181,6 +210,77 @@ class CatchAllHandler {
     };
   }
 }
+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();
@@ -192,6 +292,9 @@ class TokenHandlerRegistry {
     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. */
@@ -347,6 +450,7 @@ class MarkdownParser {
    */
   createContext() {
     const self = this;
+    const metadata = {};
     return {
       get preserveRawHTML() {
         return self.preserveRawHTML;
@@ -364,10 +468,16 @@ class MarkdownParser {
       parseTokens: (tokens, depth) => self.parseTokens(tokens, depth),
       reportUnhandled: (type, token) => {
         self.onUnhandledToken?.(type, token);
-      }
+      },
+      metadata
     };
   }
-  parseTokens(tokens, depth = 0) {
+  /**
+   * 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") {
@@ -376,7 +486,7 @@ class MarkdownParser {
       return [];
     }
     const nodes = [];
-    const ctx = this.createContext();
+    const ctx = sharedCtx || this.createContext();
     for (const token of tokens) {
       const typedToken = token;
       const handler = this.handlerRegistry.get(typedToken.type);
@@ -387,6 +497,82 @@ 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,
@@ -394,10 +580,14 @@ class MarkdownParser {
       pedantic: options?.pedantic ?? false
     };
     try {
-      const tokens = marked.lexer(markdown, parseOptions);
-      const content = this.parseTokens(tokens);
+      const processed = this.preprocessContainerBlocks(markdown);
+      const rawTokens = marked.lexer(processed, parseOptions);
+      const tokens = this.postprocessTokens(rawTokens);
+      const ctx = this.createContext();
+      const content = this.parseTokens(tokens, 0, ctx);
       return {
         title: "",
+        metadata: { ...ctx.metadata },
         content
       };
     } catch (err) {
@@ -416,6 +606,198 @@ 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 = {
@@ -424,6 +806,11 @@ class HTMLRenderer {
       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;
@@ -450,68 +837,40 @@ class HTMLRenderer {
     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}>`;
+  /**
+   * 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 scopeAttr = this.getScopeAttr(node);
-    switch (node.type) {
-      case "heading":
-        const level = node.attributes?.level || "2";
-        const headingId = this.config.addHeadingIds ? ` id="${this.generateHeadingId(node.content)}"` : "";
-        let headingClass = "";
-        if (this.hasClassConfig()) {
-          const prefix = this.config.classPrefix;
-          const levelClass = level === "1" ? "h1" : level === "2" ? "h2" : level === "3" ? "h3" : level === "4" ? "h4" : level === "5" ? "h5" : "h6";
-          headingClass = prefix ? `${prefix}${levelClass}` : levelClass;
-        }
-        if (!headingClass) {
-          return `<h${level}${headingId}${scopeAttr}>${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", void 0, scopeAttr);
-        }
-        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", void 0, scopeAttr);
-      case "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}"` : ""}${scopeAttr}>`;
-      case "code":
-        const codeClass = this.hasClassConfig() ? ` class="${this.getClass("code")} language-${node.attributes?.lang || ""}"` : ` class="language-${node.attributes?.lang || ""}"`;
-        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", 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, scopeAttr);
-      case "strong":
-        return `<strong${scopeAttr}>${node.content || ""}</strong>`;
-      case "emphasis":
-        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 || "";
-    }
+    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) {
@@ -606,21 +965,149 @@ class MarkdownPipeline {
     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,
+  ContainerBlockHandler,
+  FrontmatterHandler,
   HTMLRenderer,
   HeadingHandler,
   HrHandler,
   HtmlHandler,
   ImageHandler,
+  LinkHandler,
   ListHandler,
   MarkdownParser,
   MarkdownPipeline,
+  NodeFactory,
   ParagraphHandler,
+  RendererStrategyRegistry,
   TokenHandlerRegistry,
+  collectByType,
+  collectFromTree,
+  collectHeadings,
+  collectImages,
   defaultAllowedHTMLTags,
-  nodeTypeToScope
+  nodeTypeToScope,
+  walkTree
 };
 //# sourceMappingURL=index.js.map