@changerawr/markdown 1.0.0

package/dist/index.js

@@ -0,0 +1,2275 @@
+"use client";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AlertExtension: () => AlertExtension,
+  ButtonExtension: () => ButtonExtension,
+  ChangerawrMarkdown: () => ChangerawrMarkdown,
+  EmbedExtension: () => EmbedExtension,
+  Logger: () => Logger,
+  MarkdownParser: () => MarkdownParser,
+  MarkdownRenderer: () => MarkdownRenderer,
+  PerformanceTimer: () => PerformanceTimer,
+  astToJSONString: () => astToJSONString,
+  astToTokens: () => astToTokens,
+  basicSanitize: () => basicSanitize,
+  compareTokens: () => compareTokens,
+  createCumEngine: () => createCumEngine,
+  createCustomEngine: () => createCustomEngine,
+  createDebugEngine: () => createDebugEngine,
+  createEngine: () => createEngine,
+  createEngineWithPreset: () => createEngineWithPreset,
+  createHTMLEngine: () => createHTMLEngine,
+  createMinimalEngine: () => createMinimalEngine,
+  createTailwindEngine: () => createTailwindEngine,
+  debounce: () => debounce,
+  deepMerge: () => deepMerge,
+  default: () => index_default,
+  defaultTailwindClasses: () => defaultTailwindClasses,
+  escapeHtml: () => escapeHtml,
+  extractDomain: () => extractDomain,
+  generateId: () => generateId,
+  getASTStats: () => getASTStats,
+  getTokenStats: () => getTokenStats,
+  isBrowser: () => isBrowser,
+  isNode: () => isNode,
+  isValidUrl: () => isValidUrl,
+  markdown: () => markdown2,
+  minimalClasses: () => minimalClasses,
+  parseASTFromJSON: () => parseASTFromJSON,
+  parseCum: () => parseCum,
+  parseMarkdown: () => parseMarkdown,
+  parseOptions: () => parseOptions,
+  parseTokensFromJSON: () => parseTokensFromJSON,
+  presets: () => presets,
+  proseClasses: () => proseClasses,
+  renderCum: () => renderCum,
+  renderCumToHtml: () => renderCumToHtml,
+  renderCumToJson: () => renderCumToJson,
+  renderCumToTailwind: () => renderCumToTailwind,
+  renderMarkdown: () => renderMarkdown,
+  renderToAST: () => renderToAST,
+  renderToHTML: () => renderToHTML,
+  renderToHTMLUnsafe: () => renderToHTMLUnsafe,
+  renderToHTMLWithConfig: () => renderToHTMLWithConfig,
+  renderToJSON: () => renderToJSON,
+  renderToTailwind: () => renderToTailwind,
+  renderToTailwindWithClasses: () => renderToTailwindWithClasses,
+  renderToTailwindWithConfig: () => renderToTailwindWithConfig,
+  sanitizeHtml: () => sanitizeHtml,
+  tokensToAST: () => tokensToAST,
+  tokensToJSONString: () => tokensToJSONString
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parser.ts
+var MarkdownParser = class {
+  constructor(config) {
+    this.rules = [];
+    this.warnings = [];
+    this.config = config || {};
+  }
+  addRule(rule) {
+    this.rules.push(rule);
+    this.rules.sort((a, b) => {
+      if (a.name.includes("alert") || a.name.includes("embed") || a.name.includes("button")) return -1;
+      if (b.name.includes("alert") || b.name.includes("embed") || b.name.includes("button")) return 1;
+      if (a.name === "task-list") return -1;
+      if (b.name === "task-list") return 1;
+      if (a.name === "list" && b.name === "task-list") return 1;
+      if (b.name === "list" && a.name === "task-list") return -1;
+      return a.name.localeCompare(b.name);
+    });
+  }
+  setupDefaultRulesIfEmpty() {
+    const hasDefaultRules = this.rules.some(
+      (rule) => !["alert", "button", "embed"].includes(rule.name)
+    );
+    if (!hasDefaultRules) {
+      this.setupDefaultRules();
+    }
+  }
+  hasRule(name) {
+    return this.rules.some((rule) => rule.name === name);
+  }
+  parse(markdown3) {
+    this.warnings = [];
+    this.setupDefaultRulesIfEmpty();
+    const processedMarkdown = this.preprocessMarkdown(markdown3);
+    const tokens = [];
+    let remaining = processedMarkdown;
+    let iterationCount = 0;
+    const maxIterations = this.config.maxIterations || markdown3.length * 2;
+    while (remaining.length > 0 && iterationCount < maxIterations) {
+      iterationCount++;
+      let matched = false;
+      let bestMatch = null;
+      for (const rule of this.rules) {
+        try {
+          const pattern = new RegExp(rule.pattern.source, rule.pattern.flags.replace("g", ""));
+          const match = remaining.match(pattern);
+          if (match && match.index !== void 0) {
+            const priority = match.index === 0 ? 1e3 : 1e3 - match.index;
+            if (!bestMatch || priority > bestMatch.priority || priority === bestMatch.priority && match.index < (bestMatch.match.index || 0)) {
+              bestMatch = { rule, match, priority };
+            }
+          }
+        } catch (error) {
+          if (this.config.debugMode) {
+            console.warn(`Error in rule "${rule.name}":`, error);
+          }
+        }
+      }
+      if (bestMatch && bestMatch.match.index !== void 0) {
+        const { rule, match } = bestMatch;
+        const matchIndex = match.index;
+        if (matchIndex > 0) {
+          const textBefore = remaining.slice(0, matchIndex);
+          tokens.push({
+            type: "text",
+            content: textBefore,
+            raw: textBefore
+          });
+          remaining = remaining.slice(matchIndex);
+          continue;
+        }
+        try {
+          const token = rule.render(match);
+          tokens.push({
+            ...token,
+            raw: match[0] || ""
+          });
+          remaining = remaining.slice(match[0]?.length || 0);
+          matched = true;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          this.warnings.push(`Failed to render ${rule.name}: ${errorMessage}`);
+          const char = remaining[0];
+          if (char) {
+            tokens.push({
+              type: "text",
+              content: char,
+              raw: char
+            });
+            remaining = remaining.slice(1);
+          }
+        }
+      }
+      if (!matched) {
+        const char = remaining[0];
+        if (char) {
+          tokens.push({
+            type: "text",
+            content: char,
+            raw: char
+          });
+          remaining = remaining.slice(1);
+        }
+      }
+    }
+    if (iterationCount >= maxIterations) {
+      this.warnings.push("Parser hit maximum iterations - possible infinite loop detected");
+    }
+    const processedTokens = this.postProcessTokens(tokens);
+    return processedTokens;
+  }
+  getWarnings() {
+    return [...this.warnings];
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  setDebugMode(enabled) {
+    this.config.debugMode = enabled;
+  }
+  clearWarnings() {
+    this.warnings = [];
+  }
+  getIterationCount() {
+    return 0;
+  }
+  preprocessMarkdown(markdown3) {
+    if (this.config.validateMarkdown) {
+      this.validateMarkdown(markdown3);
+    }
+    return markdown3.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  }
+  validateMarkdown(markdown3) {
+    const boldMatches = markdown3.match(/\*\*/g);
+    if (boldMatches && boldMatches.length % 2 !== 0) {
+      this.warnings.push("Unclosed bold markers (**) detected - some bold formatting may not work");
+    }
+    const italicMatches = markdown3.match(/(?<!\*)\*(?!\*)/g);
+    if (italicMatches && italicMatches.length % 2 !== 0) {
+      this.warnings.push("Unclosed italic markers (*) detected - some italic formatting may not work");
+    }
+    const codeBlockMatches = markdown3.match(/```/g);
+    if (codeBlockMatches && codeBlockMatches.length % 2 !== 0) {
+      this.warnings.push("Unclosed code blocks (```) detected - some code formatting may not work");
+    }
+    const inlineCodeMatches = markdown3.match(/`/g);
+    if (inlineCodeMatches && inlineCodeMatches.length % 2 !== 0) {
+      this.warnings.push("Unclosed inline code markers (`) detected - some code formatting may not work");
+    }
+  }
+  postProcessTokens(tokens) {
+    const processed = [];
+    let i = 0;
+    while (i < tokens.length) {
+      const token = tokens[i];
+      if (token && token.type === "text") {
+        let textContent = token.content || token.raw || "";
+        let j = i + 1;
+        while (j < tokens.length && tokens[j] && tokens[j].type === "text") {
+          const nextToken = tokens[j];
+          textContent += nextToken.content || nextToken.raw || "";
+          j++;
+        }
+        if (textContent.trim().length > 0 || textContent.includes("\n")) {
+          processed.push({
+            type: "text",
+            content: textContent,
+            raw: textContent
+          });
+        }
+        i = j;
+      } else if (token) {
+        processed.push(token);
+        i++;
+      } else {
+        i++;
+      }
+    }
+    return processed;
+  }
+  setupDefaultRules() {
+    this.addRule({
+      name: "heading",
+      pattern: /^(#{1,6})\s+(.+)$/m,
+      render: (match) => ({
+        type: "heading",
+        content: match[2]?.trim() || "",
+        raw: match[0] || "",
+        attributes: {
+          level: String(match[1]?.length || 1)
+        }
+      })
+    });
+    this.addRule({
+      name: "codeblock",
+      pattern: /```(\w+)?\s*\n([\s\S]*?)\n```/,
+      render: (match) => ({
+        type: "codeblock",
+        content: match[2] || "",
+        raw: match[0] || "",
+        attributes: {
+          language: match[1] || "text"
+        }
+      })
+    });
+    this.addRule({
+      name: "hard-break-backslash",
+      pattern: /\\\s*\n/,
+      render: (match) => ({
+        type: "line-break",
+        content: "",
+        raw: match[0] || ""
+      })
+    });
+    this.addRule({
+      name: "hard-break-spaces",
+      pattern: /  +\n/,
+      render: (match) => ({
+        type: "line-break",
+        content: "",
+        raw: match[0] || ""
+      })
+    });
+    this.addRule({
+      name: "paragraph-break",
+      pattern: /\n\s*\n/,
+      render: (match) => ({
+        type: "paragraph-break",
+        content: "",
+        raw: match[0] || ""
+      })
+    });
+    this.addRule({
+      name: "bold",
+      pattern: /\*\*((?:(?!\*\*).)+)\*\*/,
+      render: (match) => ({
+        type: "bold",
+        content: match[1] || "",
+        raw: match[0] || ""
+      })
+    });
+    this.addRule({
+      name: "italic",
+      pattern: /\*((?:(?!\*).)+)\*/,
+      render: (match) => ({
+        type: "italic",
+        content: match[1] || "",
+        raw: match[0] || ""
+      })
+    });
+    this.addRule({
+      name: "code",
+      pattern: /`([^`]+)`/,
+      render: (match) => ({
+        type: "code",
+        content: match[1] || "",
+        raw: match[0] || ""
+      })
+    });
+    this.addRule({
+      name: "image",
+      pattern: /!\[([^\]]*)\]\(([^)]+?)(?:\s+"([^"]+)")?\)/,
+      render: (match) => ({
+        type: "image",
+        content: match[1] || "",
+        raw: match[0] || "",
+        attributes: {
+          alt: match[1] || "",
+          src: match[2] || "",
+          title: match[3] || ""
+        }
+      })
+    });
+    this.addRule({
+      name: "link",
+      pattern: /\[([^\]]+)\]\(([^)]+)\)/,
+      render: (match) => ({
+        type: "link",
+        content: match[1] || "",
+        raw: match[0] || "",
+        attributes: {
+          href: match[2] || ""
+        }
+      })
+    });
+    this.addRule({
+      name: "task-list",
+      pattern: /^(\s*)-\s*\[([ xX])\]\s*(.+)$/m,
+      render: (match) => ({
+        type: "task-item",
+        content: match[3] || "",
+        raw: match[0] || "",
+        attributes: {
+          checked: String((match[2] || "").toLowerCase() === "x")
+        }
+      })
+    });
+    this.addRule({
+      name: "list",
+      pattern: /^(\s*)[-*+]\s+(.+)$/m,
+      render: (match) => ({
+        type: "list-item",
+        content: match[2] || "",
+        raw: match[0] || ""
+      })
+    });
+    this.addRule({
+      name: "blockquote",
+      pattern: /^>\s+(.+)$/m,
+      render: (match) => ({
+        type: "blockquote",
+        content: match[1] || "",
+        raw: match[0] || ""
+      })
+    });
+    this.addRule({
+      name: "hr",
+      pattern: /^---$/m,
+      render: (match) => ({
+        type: "hr",
+        content: "",
+        raw: match[0] || ""
+      })
+    });
+    this.addRule({
+      name: "soft-break",
+      pattern: /\n/,
+      render: (match) => ({
+        type: "soft-break",
+        content: " ",
+        // Convert to space for inline text
+        raw: match[0] || ""
+      })
+    });
+  }
+};
+
+// src/utils.ts
+var DOMPurify = {
+  sanitize: (html) => html
+};
+if (typeof window !== "undefined") {
+  import("dompurify").then((module2) => {
+    DOMPurify = module2.default;
+  }).catch((err) => {
+    console.error("Failed to load DOMPurify", err);
+  });
+}
+var ALLOWED_TAGS = [
+  // Standard HTML
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "p",
+  "br",
+  "strong",
+  "em",
+  "del",
+  "ins",
+  "a",
+  "img",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "pre",
+  "code",
+  "table",
+  "thead",
+  "tbody",
+  "tr",
+  "th",
+  "td",
+  "div",
+  "span",
+  "sup",
+  "sub",
+  "hr",
+  "input",
+  // Embeds
+  "iframe",
+  "embed",
+  "object",
+  "param",
+  "video",
+  "audio",
+  "source",
+  // SVG
+  "svg",
+  "path",
+  "polyline",
+  "line",
+  "circle",
+  "rect",
+  "g",
+  "defs",
+  "use",
+  // Form elements
+  "form",
+  "fieldset",
+  "legend",
+  "label",
+  "select",
+  "option",
+  "textarea",
+  "button"
+];
+var ALLOWED_ATTR = [
+  // Standard attributes
+  "href",
+  "title",
+  "alt",
+  "src",
+  "class",
+  "id",
+  "target",
+  "rel",
+  "type",
+  "checked",
+  "disabled",
+  "loading",
+  "width",
+  "height",
+  "style",
+  "role",
+  // Iframe attributes
+  "frameborder",
+  "allowfullscreen",
+  "allow",
+  "sandbox",
+  "scrolling",
+  "allowtransparency",
+  "name",
+  "seamless",
+  "srcdoc",
+  // Data attributes (for embeds)
+  "data-*",
+  // SVG attributes
+  "viewBox",
+  "fill",
+  "stroke",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "d",
+  "points",
+  "x1",
+  "y1",
+  "x2",
+  "y2",
+  "cx",
+  "cy",
+  "r",
+  "rx",
+  "ry",
+  // Media attributes
+  "autoplay",
+  "controls",
+  "loop",
+  "muted",
+  "preload",
+  "poster",
+  // Form attributes
+  "value",
+  "placeholder",
+  "required",
+  "readonly",
+  "maxlength",
+  "minlength",
+  "max",
+  "min",
+  "step",
+  "pattern",
+  "autocomplete",
+  "autofocus"
+];
+function escapeHtml(text) {
+  const map = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return text.replace(/[&<>"']/g, (char) => map[char] || char);
+}
+function generateId(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").trim();
+}
+function sanitizeHtml(html) {
+  try {
+    if (html.includes("codepen.io/") || html.includes("youtube.com/embed/")) {
+      return html;
+    }
+    if (typeof DOMPurify?.sanitize === "function") {
+      const sanitized = DOMPurify.sanitize(html, {
+        ALLOWED_TAGS,
+        ALLOWED_ATTR,
+        ALLOW_DATA_ATTR: true,
+        ALLOW_UNKNOWN_PROTOCOLS: false,
+        SAFE_FOR_TEMPLATES: false,
+        WHOLE_DOCUMENT: false,
+        RETURN_DOM: false,
+        RETURN_DOM_FRAGMENT: false,
+        FORCE_BODY: false,
+        SANITIZE_DOM: false,
+        SANITIZE_NAMED_PROPS: false,
+        FORBID_ATTR: ["onload", "onerror", "onclick", "onmouseover", "onmouseout", "onfocus", "onblur"],
+        ADD_TAGS: ["iframe", "embed", "object", "param"],
+        ADD_ATTR: [
+          "allow",
+          "allowfullscreen",
+          "frameborder",
+          "scrolling",
+          "allowtransparency",
+          "sandbox",
+          "loading",
+          "style",
+          "title",
+          "name",
+          "seamless",
+          "srcdoc"
+        ],
+        ALLOWED_URI_REGEXP: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp|xxx):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
+      });
+      if (sanitized.length < html.length * 0.7) {
+        return basicSanitize(html);
+      }
+      return sanitized;
+    }
+    return basicSanitize(html);
+  } catch (error) {
+    console.error("Sanitization failed:", error);
+    return basicSanitize(html);
+  }
+}
+function basicSanitize(html) {
+  return html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/on\w+\s*=\s*"[^"]*"/gi, "").replace(/on\w+\s*=\s*'[^']*'/gi, "").replace(/javascript:/gi, "");
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function debounce(func, wait) {
+  let timeout;
+  return function executedFunction(...args) {
+    const later = () => {
+      clearTimeout(timeout);
+      func(...args);
+    };
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+  };
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  for (const key in source) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      if (key in target && typeof target[key] === "object" && !Array.isArray(target[key])) {
+        output[key] = deepMerge(target[key], source[key]);
+      } else {
+        output[key] = source[key];
+      }
+    } else {
+      output[key] = source[key];
+    }
+  }
+  return output;
+}
+function extractDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseOptions(options) {
+  const parsed = {};
+  if (!options) return parsed;
+  options.split(",").forEach((option) => {
+    const [key, value] = option.split(":").map((s) => s.trim());
+    if (key && value) {
+      parsed[key] = value;
+    }
+  });
+  return parsed;
+}
+var PerformanceTimer = class {
+  constructor() {
+    this.marks = {};
+    this.startTime = performance.now();
+  }
+  mark(name) {
+    this.marks[name] = performance.now() - this.startTime;
+  }
+  getTime(name) {
+    if (name && this.marks[name] !== void 0) {
+      return this.marks[name];
+    }
+    return performance.now() - this.startTime;
+  }
+  getAllMarks() {
+    return { ...this.marks };
+  }
+};
+var Logger = class {
+  constructor(debugMode = false) {
+    this.debugMode = debugMode;
+  }
+  debug(...args) {
+    if (this.debugMode) {
+      console.log("[DEBUG]", ...args);
+    }
+  }
+  info(...args) {
+    console.info("[INFO]", ...args);
+  }
+  warn(...args) {
+    console.warn("[WARN]", ...args);
+  }
+  error(...args) {
+    console.error("[ERROR]", ...args);
+  }
+  setDebugMode(enabled) {
+    this.debugMode = enabled;
+  }
+};
+
+// src/renderer.ts
+var MarkdownRenderer = class {
+  constructor(config) {
+    this.rules = /* @__PURE__ */ new Map();
+    this.warnings = [];
+    this.config = {
+      format: "tailwind",
+      sanitize: true,
+      allowUnsafeHtml: false,
+      debugMode: false,
+      ...config
+    };
+    this.setupDefaultRules();
+  }
+  addRule(rule) {
+    this.rules.set(rule.type, rule);
+  }
+  hasRule(type) {
+    return this.rules.has(type);
+  }
+  render(tokens) {
+    this.warnings = [];
+    const htmlParts = tokens.map((token) => this.renderToken(token));
+    const combinedHtml = htmlParts.join("");
+    if (this.config.sanitize && !this.config.allowUnsafeHtml) {
+      return sanitizeHtml(combinedHtml);
+    }
+    return combinedHtml;
+  }
+  getWarnings() {
+    return [...this.warnings];
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  setDebugMode(enabled) {
+    this.config.debugMode = enabled;
+  }
+  clearWarnings() {
+    this.warnings = [];
+  }
+  renderToken(token) {
+    const rule = this.rules.get(token.type);
+    if (rule) {
+      try {
+        return rule.render(token);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.warnings.push(`Render error for ${token.type}: ${errorMessage}`);
+        return this.createErrorBlock(`Render error for ${token.type}: ${errorMessage}`);
+      }
+    }
+    if (token.type === "text") {
+      return escapeHtml(token.content || token.raw || "");
+    }
+    if (this.config.debugMode) {
+      return this.createDebugBlock(token);
+    }
+    return escapeHtml(token.content || token.raw || "");
+  }
+  createErrorBlock(message) {
+    if (this.config.format === "html") {
+      return `<div style="background-color: #fee; border: 1px solid #fcc; color: #c66; padding: 8px; border-radius: 4px; margin: 8px 0; font-size: 14px;">
+        <strong>Render Error:</strong> ${escapeHtml(message)}
+      </div>`;
+    }
+    return `<div class="bg-red-100 border border-red-300 text-red-800 p-2 rounded text-sm mb-2">
+      <strong>Render Error:</strong> ${escapeHtml(message)}
+    </div>`;
+  }
+  createDebugBlock(token) {
+    if (this.config.format === "html") {
+      return `<div style="background-color: #fffbf0; border: 1px solid #fed; color: #b8860b; padding: 8px; border-radius: 4px; margin: 8px 0; font-size: 14px;">
+        <strong>Unknown token type:</strong> ${escapeHtml(token.type)}<br>
+        <strong>Content:</strong> ${escapeHtml(token.content || token.raw || "")}
+      </div>`;
+    }
+    return `<div class="bg-yellow-100 border border-yellow-300 text-yellow-800 p-2 rounded text-sm mb-2">
+      <strong>Unknown token type:</strong> ${escapeHtml(token.type)}<br>
+      <strong>Content:</strong> ${escapeHtml(token.content || token.raw || "")}
+    </div>`;
+  }
+  setupDefaultRules() {
+    this.addRule({
+      type: "heading",
+      render: (token) => {
+        const level = parseInt(token.attributes?.level || "1");
+        const text = token.content;
+        const id = generateId(text);
+        const escapedContent = escapeHtml(text);
+        if (this.config.format === "html") {
+          return `<h${level} id="${id}">${escapedContent}</h${level}>`;
+        }
+        let headingClasses = "group relative flex items-center gap-2";
+        switch (level) {
+          case 1:
+            headingClasses += " text-3xl font-bold mt-8 mb-4";
+            break;
+          case 2:
+            headingClasses += " text-2xl font-semibold mt-6 mb-3";
+            break;
+          case 3:
+            headingClasses += " text-xl font-medium mt-5 mb-3";
+            break;
+          case 4:
+            headingClasses += " text-lg font-medium mt-4 mb-2";
+            break;
+          case 5:
+            headingClasses += " text-base font-medium mt-3 mb-2";
+            break;
+          case 6:
+            headingClasses += " text-sm font-medium mt-3 mb-2";
+            break;
+        }
+        return `<h${level} id="${id}" class="${headingClasses}">
+          ${escapedContent}
+          <a href="#${id}" class="opacity-0 group-hover:opacity-100 text-muted-foreground transition-opacity">
+            <svg width="16" height="16" viewBox="0 0 16 16" fill="currentColor">
+              <path d="M7.5 4H5.75A3.75 3.75 0 002 7.75v.5a3.75 3.75 0 003.75 3.75h1.5m-1.5-4h3m1.5-4h1.75A3.75 3.75 0 0114 7.75v.5a3.75 3.75 0 01-3.75 3.75H8.5"/>
+            </svg>
+          </a>
+        </h${level}>`;
+      }
+    });
+    this.addRule({
+      type: "bold",
+      render: (token) => {
+        const content = escapeHtml(token.content);
+        if (this.config.format === "html") {
+          return `<strong>${content}</strong>`;
+        }
+        return `<strong class="font-bold">${content}</strong>`;
+      }
+    });
+    this.addRule({
+      type: "italic",
+      render: (token) => {
+        const content = escapeHtml(token.content);
+        if (this.config.format === "html") {
+          return `<em>${content}</em>`;
+        }
+        return `<em class="italic">${content}</em>`;
+      }
+    });
+    this.addRule({
+      type: "code",
+      render: (token) => {
+        const content = escapeHtml(token.content);
+        if (this.config.format === "html") {
+          return `<code style="background-color: #f3f4f6; padding: 2px 6px; border-radius: 4px; font-family: monospace; font-size: 0.875rem;">${content}</code>`;
+        }
+        return `<code class="bg-muted px-1.5 py-0.5 rounded text-sm font-mono">${content}</code>`;
+      }
+    });
+    this.addRule({
+      type: "codeblock",
+      render: (token) => {
+        const language = token.attributes?.language || "text";
+        const escapedCode = escapeHtml(token.content);
+        if (this.config.format === "html") {
+          return `<pre style="background-color: #f3f4f6; padding: 16px; border-radius: 6px; overflow-x: auto; margin: 16px 0;"><code class="language-${escapeHtml(language)}">${escapedCode}</code></pre>`;
+        }
+        return `<pre class="bg-muted p-4 rounded-md overflow-x-auto my-4"><code class="language-${escapeHtml(language)}">${escapedCode}</code></pre>`;
+      }
+    });
+    this.addRule({
+      type: "link",
+      render: (token) => {
+        const href = token.attributes?.href || "#";
+        const escapedHref = escapeHtml(href);
+        const escapedText = escapeHtml(token.content);
+        if (this.config.format === "html") {
+          return `<a href="${escapedHref}" target="_blank" rel="noopener noreferrer">${escapedText}</a>`;
+        }
+        return `<a href="${escapedHref}" class="text-primary hover:underline inline-flex items-center gap-1" target="_blank" rel="noopener noreferrer">
+          ${escapedText}
+          <svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-external-link">
+            <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path>
+            <polyline points="15 3 21 3 21 9"></polyline>
+            <line x1="10" y1="14" x2="21" y2="3"></line>
+          </svg>
+        </a>`;
+      }
+    });
+    this.addRule({
+      type: "list-item",
+      render: (token) => `<li>${escapeHtml(token.content)}</li>`
+    });
+    this.addRule({
+      type: "blockquote",
+      render: (token) => {
+        const content = escapeHtml(token.content);
+        if (this.config.format === "html") {
+          return `<blockquote style="border-left: 2px solid #d1d5db; padding: 8px 0 8px 16px; margin: 16px 0; font-style: italic; color: #6b7280;">${content}</blockquote>`;
+        }
+        return `<blockquote class="pl-4 py-2 border-l-2 border-border italic text-muted-foreground my-4">${content}</blockquote>`;
+      }
+    });
+    this.addRule({
+      type: "text",
+      render: (token) => {
+        if (!token.content) return "";
+        return escapeHtml(token.content);
+      }
+    });
+    this.addRule({
+      type: "paragraph",
+      render: (token) => {
+        if (!token.content) return "";
+        const content = token.content.trim();
+        if (!content) return "";
+        const processedContent = content.includes("<br>") ? content : escapeHtml(content);
+        if (this.config.format === "html") {
+          return `<p style="line-height: 1.75; margin-bottom: 16px;">${processedContent}</p>`;
+        }
+        return `<p class="leading-7 mb-4">${processedContent}</p>`;
+      }
+    });
+    this.addRule({
+      type: "task-item",
+      render: (token) => {
+        const isChecked = token.attributes?.checked === "true";
+        const escapedContent = escapeHtml(token.content);
+        if (this.config.format === "html") {
+          return `<div style="display: flex; align-items: center; gap: 8px; margin: 8px 0;">
+            <input type="checkbox" ${isChecked ? "checked" : ""} disabled style="margin: 0;" />
+            <span${isChecked ? ' style="text-decoration: line-through; color: #6b7280;"' : ""}>${escapedContent}</span>
+          </div>`;
+        }
+        return `<div class="flex items-center gap-2 my-2 task-list-item">
+          <input type="checkbox" ${isChecked ? "checked" : ""} disabled 
+            class="form-checkbox h-4 w-4 rounded border-gray-300 text-primary focus:ring-primary" />
+          <span${isChecked ? ' class="line-through text-muted-foreground"' : ""}>${escapedContent}</span>
+        </div>`;
+      }
+    });
+    this.addRule({
+      type: "image",
+      render: (token) => {
+        const src = token.attributes?.src || "";
+        const alt = token.attributes?.alt || "";
+        const title = token.attributes?.title || "";
+        const titleAttr = title ? ` title="${escapeHtml(title)}"` : "";
+        if (this.config.format === "html") {
+          return `<img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}"${titleAttr} style="max-width: 100%; height: auto; border-radius: 8px; margin: 16px 0;" loading="lazy" />`;
+        }
+        return `<img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}"${titleAttr} class="max-w-full h-auto rounded-lg my-4" loading="lazy" />`;
+      }
+    });
+    this.addRule({
+      type: "hr",
+      render: () => {
+        if (this.config.format === "html") {
+          return '<hr style="margin: 24px 0; border: none; border-top: 1px solid #d1d5db;">';
+        }
+        return '<hr class="my-6 border-t border-border">';
+      }
+    });
+    this.addRule({
+      type: "line-break",
+      render: () => "<br>"
+    });
+    this.addRule({
+      type: "paragraph-break",
+      render: () => "</p><p>"
+    });
+    this.addRule({
+      type: "soft-break",
+      render: (token) => token.content || " "
+    });
+  }
+};
+
+// src/extensions/alert.ts
+var AlertExtension = {
+  name: "alert",
+  parseRules: [
+    {
+      name: "alert",
+      pattern: /:::(\w+)(?:\s+(.*?))?\s*\n([\s\S]*?)\n:::/,
+      render: (match) => {
+        return {
+          type: "alert",
+          content: match[3]?.trim() || "",
+          raw: match[0] || "",
+          attributes: {
+            type: match[1] || "info",
+            title: match[2] || ""
+          }
+        };
+      }
+    }
+  ],
+  renderRules: [
+    {
+      type: "alert",
+      render: (token) => {
+        const type = token.attributes?.type || "info";
+        const title = token.attributes?.title || "";
+        const typeConfig = {
+          info: {
+            icon: "\u2139\uFE0F",
+            classes: "bg-blue-500/10 border-blue-500/30 text-blue-600 border-l-blue-500"
+          },
+          warning: {
+            icon: "\u26A0\uFE0F",
+            classes: "bg-amber-500/10 border-amber-500/30 text-amber-600 border-l-amber-500"
+          },
+          error: {
+            icon: "\u274C",
+            classes: "bg-red-500/10 border-red-500/30 text-red-600 border-l-red-500"
+          },
+          success: {
+            icon: "\u2705",
+            classes: "bg-green-500/10 border-green-500/30 text-green-600 border-l-green-500"
+          },
+          tip: {
+            icon: "\u{1F4A1}",
+            classes: "bg-purple-500/10 border-purple-500/30 text-purple-600 border-l-purple-500"
+          },
+          note: {
+            icon: "\u{1F4DD}",
+            classes: "bg-gray-500/10 border-gray-500/30 text-gray-600 border-l-gray-500"
+          }
+        };
+        const config = typeConfig[type] || typeConfig.info;
+        const baseClasses = "border-l-4 p-4 mb-4 rounded-md transition-colors duration-200";
+        const classes = `${baseClasses} ${config?.classes}`;
+        const titleHtml = title ? `<div class="font-medium mb-2 flex items-center gap-2">
+               <span class="text-lg" role="img" aria-label="${type}">${config?.icon}</span>
+               <span>${title}</span>
+             </div>` : `<div class="font-medium mb-2 flex items-center gap-2">
+               <span class="text-lg" role="img" aria-label="${type}">${config?.icon}</span>
+               <span>${type.charAt(0).toUpperCase() + type.slice(1)}</span>
+             </div>`;
+        return `<div class="${classes}" role="alert" aria-live="polite">
+                  ${titleHtml}
+                  <div class="leading-relaxed">${token.content}</div>
+                </div>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/button.ts
+var ButtonExtension = {
+  name: "button",
+  parseRules: [
+    {
+      name: "button",
+      pattern: /\[button:([^\]]+)\]\(([^)]+)\)(?:\{([^}]+)\})?/,
+      render: (match) => {
+        const text = match[1] || "";
+        const href = match[2] || "";
+        const optionsString = match[3] || "";
+        const options = optionsString.split(",").map((opt) => opt.trim()).filter(Boolean);
+        const styleOptions = ["default", "primary", "secondary", "success", "danger", "outline", "ghost"];
+        const style = options.find((opt) => styleOptions.includes(opt)) || "primary";
+        const sizeOptions = ["sm", "md", "lg"];
+        const size = options.find((opt) => sizeOptions.includes(opt)) || "md";
+        const disabled = options.includes("disabled");
+        const target = options.includes("self") ? "_self" : "_blank";
+        return {
+          type: "button",
+          content: text,
+          raw: match[0] || "",
+          attributes: {
+            href,
+            style,
+            size,
+            disabled: disabled.toString(),
+            target
+          }
+        };
+      }
+    }
+  ],
+  renderRules: [
+    {
+      type: "button",
+      render: (token) => {
+        const href = token.attributes?.href || "#";
+        const style = token.attributes?.style || "primary";
+        const size = token.attributes?.size || "md";
+        const disabled = token.attributes?.disabled === "true";
+        const target = token.attributes?.target || "_blank";
+        const text = token.content;
+        const classes = buildButtonClasses(style, size);
+        const targetAttr = target === "_blank" ? ' target="_blank" rel="noopener noreferrer"' : target === "_self" ? ' target="_self"' : "";
+        const disabledAttr = disabled ? ' aria-disabled="true" tabindex="-1"' : "";
+        const externalIcon = target === "_blank" && !disabled ? '<svg class="w-4 h-4 ml-1" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14"/></svg>' : "";
+        return `<a href="${href}" class="${classes}"${targetAttr}${disabledAttr}>
+          ${text}${externalIcon}
+        </a>`;
+      }
+    }
+  ]
+};
+function buildButtonClasses(style, size) {
+  const base = [
+    "inline-flex",
+    "items-center",
+    "justify-center",
+    "font-medium",
+    "rounded-lg",
+    "transition-colors",
+    "focus:outline-none",
+    "focus:ring-2",
+    "focus:ring-offset-2",
+    "disabled:opacity-50",
+    "disabled:cursor-not-allowed"
+  ];
+  const sizes = {
+    sm: ["px-3", "py-1.5", "text-sm"],
+    md: ["px-4", "py-2", "text-base"],
+    lg: ["px-6", "py-3", "text-lg"]
+  };
+  const styles = {
+    default: ["bg-slate-600", "text-white", "hover:bg-slate-700", "focus:ring-slate-500"],
+    primary: ["bg-blue-600", "text-white", "hover:bg-blue-700", "focus:ring-blue-500"],
+    secondary: ["bg-gray-600", "text-white", "hover:bg-gray-700", "focus:ring-gray-500"],
+    success: ["bg-green-600", "text-white", "hover:bg-green-700", "focus:ring-green-500"],
+    danger: ["bg-red-600", "text-white", "hover:bg-red-700", "focus:ring-red-500"],
+    outline: ["border", "border-blue-600", "text-blue-600", "hover:bg-blue-50", "focus:ring-blue-500"],
+    ghost: ["text-gray-700", "hover:bg-gray-100", "focus:ring-gray-500"]
+  };
+  const allClasses = [
+    ...base,
+    ...sizes[size] ?? sizes.md ?? [],
+    ...styles[style] ?? styles.primary ?? []
+  ];
+  return allClasses.join(" ");
+}
+
+// src/extensions/embed.ts
+var EmbedExtension = {
+  name: "embed",
+  parseRules: [
+    {
+      name: "embed",
+      pattern: /\[embed:(\w+)\]\(([^)]+)\)(?:\{([^}]+)\})?/,
+      render: (match) => {
+        return {
+          type: "embed",
+          content: match[2] || "",
+          // URL
+          raw: match[0] || "",
+          attributes: {
+            provider: match[1] || "generic",
+            url: match[2] || "",
+            options: match[3] || ""
+          }
+        };
+      }
+    }
+  ],
+  renderRules: [
+    {
+      type: "embed",
+      render: (token) => {
+        const provider = token.attributes?.provider || "generic";
+        const url = token.attributes?.url || "";
+        const options = token.attributes?.options || "";
+        return renderEmbed(provider, url, options);
+      }
+    }
+  ]
+};
+function renderEmbed(provider, url, options) {
+  const baseClasses = "rounded-lg border bg-card text-card-foreground shadow-sm mb-6 overflow-hidden";
+  const parsedOptions = parseOptions(options);
+  switch (provider.toLowerCase()) {
+    case "youtube":
+      return renderYouTubeEmbed(url, parsedOptions, baseClasses);
+    case "codepen":
+      return renderCodePenEmbed(url, parsedOptions, baseClasses);
+    case "figma":
+      return renderFigmaEmbed(url, parsedOptions, baseClasses);
+    case "twitter":
+    case "tweet":
+      return renderTwitterEmbed(url, parsedOptions, baseClasses);
+    case "github":
+      return renderGitHubEmbed(url, parsedOptions, baseClasses);
+    case "vimeo":
+      return renderVimeoEmbed(url, parsedOptions, baseClasses);
+    case "spotify":
+      return renderSpotifyEmbed(url, parsedOptions, baseClasses);
+    case "codesandbox":
+      return renderCodeSandboxEmbed(url, parsedOptions, baseClasses);
+    default:
+      return renderGenericEmbed(url, parsedOptions, baseClasses);
+  }
+}
+function renderYouTubeEmbed(url, options, classes) {
+  const videoId = extractYouTubeId(url);
+  if (!videoId) {
+    return createErrorEmbed("Invalid YouTube URL", url, classes);
+  }
+  const params = new URLSearchParams();
+  if (options.autoplay === "1") params.set("autoplay", "1");
+  if (options.mute === "1") params.set("mute", "1");
+  if (options.loop === "1") {
+    params.set("loop", "1");
+    params.set("playlist", videoId);
+  }
+  if (options.controls === "0") params.set("controls", "0");
+  if (options.start) params.set("start", options.start);
+  params.set("rel", "0");
+  params.set("modestbranding", "1");
+  const embedUrl = `https://www.youtube.com/embed/${videoId}?${params.toString()}`;
+  return `
+  <div class="${classes}">
+    <div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden;">
+      <iframe 
+        style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 0;"
+        src="${embedUrl}" 
+        title="YouTube video player"
+        frameborder="0" 
+        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+        allowfullscreen>
+      </iframe>
+    </div>
+  </div>`;
+}
+function renderCodePenEmbed(url, options, classes) {
+  const match = url.match(/codepen\.io\/([^\/]+)\/(?:pen|embed)\/([^\/\?#]+)/);
+  if (!match) {
+    return createErrorEmbed("Invalid CodePen URL", url, classes);
+  }
+  const [, user, penId] = match;
+  const height = options.height || "400";
+  const theme = options.theme === "light" ? "light" : "dark";
+  const defaultTab = options.tab || "result";
+  const embedParams = new URLSearchParams({
+    "default-tab": defaultTab,
+    "theme-id": theme,
+    "editable": "true"
+  });
+  const embedUrl = `https://codepen.io/${user}/embed/${penId}?${embedParams.toString()}`;
+  return `
+  <div class="${classes}">
+    <iframe 
+      height="${height}" 
+      style="width: 100%; border: 0;" 
+      scrolling="no" 
+      title="CodePen Embed - ${penId}" 
+      src="${embedUrl}" 
+      frameborder="0" 
+      loading="lazy" 
+      allowtransparency="true" 
+      allowfullscreen="true">
+    </iframe>
+  </div>`;
+}
+function renderVimeoEmbed(url, options, classes) {
+  const videoId = extractVimeoId(url);
+  if (!videoId) {
+    return createErrorEmbed("Invalid Vimeo URL", url, classes);
+  }
+  const params = new URLSearchParams();
+  if (options.autoplay === "1") params.set("autoplay", "1");
+  if (options.mute === "1") params.set("muted", "1");
+  if (options.loop === "1") params.set("loop", "1");
+  const embedUrl = `https://player.vimeo.com/video/${videoId}?${params.toString()}`;
+  return `
+  <div class="${classes}">
+    <div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden;">
+      <iframe 
+        style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 0;"
+        src="${embedUrl}" 
+        title="Vimeo video player"
+        frameborder="0" 
+        allow="autoplay; fullscreen; picture-in-picture"
+        allowfullscreen>
+      </iframe>
+    </div>
+  </div>`;
+}
+function renderSpotifyEmbed(url, options, classes) {
+  const embedUrl = url.replace("open.spotify.com", "open.spotify.com/embed");
+  const height = options.height || "380";
+  return `
+  <div class="${classes}">
+    <iframe 
+      style="border-radius: 12px;" 
+      src="${embedUrl}" 
+      width="100%" 
+      height="${height}" 
+      frameborder="0" 
+      allowfullscreen="" 
+      allow="autoplay; clipboard-write; encrypted-media; fullscreen; picture-in-picture" 
+      loading="lazy">
+    </iframe>
+  </div>`;
+}
+function renderCodeSandboxEmbed(url, options, classes) {
+  let embedUrl = url;
+  if (url.includes("/s/")) {
+    embedUrl = url.replace("/s/", "/embed/");
+  }
+  const height = options.height || "500";
+  const view = options.view || "preview";
+  if (!embedUrl.includes("?")) {
+    embedUrl += `?view=${view}`;
+  }
+  return `
+  <div class="${classes}">
+    <iframe 
+      src="${embedUrl}"
+      style="width: 100%; height: ${height}px; border: 0; border-radius: 4px; overflow: hidden;"
+      title="CodeSandbox Embed"
+      allow="accelerometer; ambient-light-sensor; camera; encrypted-media; geolocation; gyroscope; hid; microphone; midi; payment; usb; vr; xr-spatial-tracking"
+      sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts">
+    </iframe>
+  </div>`;
+}
+function renderFigmaEmbed(url, options, classes) {
+  const embedUrl = `https://www.figma.com/embed?embed_host=share&url=${encodeURIComponent(url)}`;
+  const height = options.height || "450";
+  return `
+  <div class="${classes}">
+    <iframe 
+      style="border: none;" 
+      width="100%" 
+      height="${height}" 
+      src="${embedUrl}" 
+      allowfullscreen>
+    </iframe>
+  </div>`;
+}
+function renderTwitterEmbed(url, _options, classes) {
+  return `
+  <div class="${classes}">
+    <div class="p-4">
+      <div class="flex items-center gap-3 mb-3">
+        <svg class="w-6 h-6 fill-current text-blue-500" viewBox="0 0 24 24">
+          <path d="M23.953 4.57a10 10 0 01-2.825.775 4.958 4.958 0 002.163-2.723c-.951.555-2.005.959-3.127 1.184a4.92 4.92 0 00-8.384 4.482C7.69 8.095 4.067 6.13 1.64 3.162a4.822 4.822 0 00-.666 2.475c0 1.71.87 3.213 2.188 4.096a4.904 4.904 0 01-2.228-.616v.06a4.923 4.923 0 003.946 4.827 4.996 4.996 0 01-2.212.085 4.936 4.936 0 004.604 3.417 9.867 9.867 0 01-6.102 2.105c-.39 0-.779-.023-1.17-.067a13.995 13.995 0 007.557 2.209c9.053 0 13.998-7.496 13.998-13.985 0-.21 0-.42-.015-.63A9.935 9.935 0 0024 4.59z"/>
+        </svg>
+        <div>
+          <div class="font-semibold text-foreground">Twitter Post</div>
+          <div class="text-sm text-muted-foreground">External Link</div>
+        </div>
+      </div>
+      <a href="${url}" target="_blank" 
+         class="inline-flex items-center gap-2 text-primary hover:text-primary/80 font-medium transition-colors">
+        View on Twitter
+        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14"/>
+        </svg>
+      </a>
+    </div>
+  </div>`;
+}
+function renderGitHubEmbed(url, _options, classes) {
+  const parts = url.replace("https://github.com/", "").split("/");
+  const owner = parts[0];
+  const repo = parts[1];
+  if (!owner || !repo) {
+    return createErrorEmbed("Invalid GitHub URL", url, classes);
+  }
+  return `
+  <div class="${classes}">
+    <div class="p-4">
+      <div class="flex items-center gap-3 mb-3">
+        <svg class="w-6 h-6 fill-current" viewBox="0 0 24 24">
+          <path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/>
+        </svg>
+        <div>
+          <div class="font-semibold text-foreground text-lg">${owner}/${repo}</div>
+          <div class="text-sm text-muted-foreground">GitHub Repository</div>
+        </div>
+      </div>
+      <a href="${url}" target="_blank" 
+         class="inline-flex items-center gap-2 text-primary hover:text-primary/80 font-medium transition-colors">
+        View on GitHub
+        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14"/>
+        </svg>
+      </a>
+    </div>
+  </div>`;
+}
+function renderGenericEmbed(url, _options, classes) {
+  const domain = extractDomain(url);
+  return `
+  <div class="${classes}">
+    <div class="p-4">
+      <div class="flex items-center gap-3 mb-3">
+        <div class="w-10 h-10 rounded-lg bg-muted flex items-center justify-center">
+          <svg class="w-5 h-5 text-muted-foreground" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13.828 10.172a4 4 0 00-5.656 0l-4 4a4 4 0 105.656 5.656l1.102-1.101m-.758-4.899a4 4 0 005.656 0l4-4a4 4 0 00-5.656-5.656l-1.1 1.1"/>
+          </svg>
+        </div>
+        <div>
+          <div class="font-semibold text-foreground">External Link</div>
+          <div class="text-sm text-muted-foreground">${domain}</div>
+        </div>
+      </div>
+      <a href="${url}" target="_blank" 
+         class="inline-flex items-center gap-2 text-primary hover:text-primary/80 font-medium transition-colors break-all">
+        ${url}
+        <svg class="w-4 h-4 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14"/>
+        </svg>
+      </a>
+    </div>
+  </div>`;
+}
+function createErrorEmbed(error, url, classes) {
+  return `
+  <div class="${classes}">
+    <div class="p-4 text-destructive">
+      <div class="font-medium flex items-center gap-2">
+        <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/>
+        </svg>
+        ${error}
+      </div>
+      <div class="text-sm text-muted-foreground mt-1 break-all">${url}</div>
+    </div>
+  </div>`;
+}
+function extractYouTubeId(url) {
+  const patterns = [
+    /(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/|youtube\.com\/shorts\/)([^&\n?#]+)/,
+    /youtube\.com\/watch\?.*v=([^&\n?#]+)/
+  ];
+  for (const pattern of patterns) {
+    const match = url.match(pattern);
+    if (match) return match[1] || null;
+  }
+  return null;
+}
+function extractVimeoId(url) {
+  const match = url.match(/vimeo\.com\/(?:.*\/)?(\d+)/);
+  return match?.[1] ?? null;
+}
+
+// src/engine.ts
+var ChangerawrMarkdown = class {
+  constructor(config) {
+    this.extensions = /* @__PURE__ */ new Map();
+    this.parser = new MarkdownParser(config?.parser);
+    this.renderer = new MarkdownRenderer(config?.renderer);
+    this.registerBuiltInExtensions();
+    if (config?.extensions) {
+      config.extensions.forEach((extension) => {
+        this.registerExtension(extension);
+      });
+    }
+    this.parser.setupDefaultRulesIfEmpty();
+  }
+  /**
+   * Register a custom extension
+   */
+  registerExtension(extension) {
+    try {
+      this.extensions.set(extension.name, extension);
+      extension.parseRules.forEach((rule) => {
+        this.parser.addRule(rule);
+      });
+      extension.renderRules.forEach((rule) => {
+        this.renderer.addRule(rule);
+      });
+      return {
+        success: true,
+        extensionName: extension.name
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        extensionName: extension.name,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Unregister an extension
+   */
+  unregisterExtension(name) {
+    const extension = this.extensions.get(name);
+    if (!extension) {
+      return false;
+    }
+    try {
+      this.extensions.delete(name);
+      this.rebuildParserAndRenderer();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Parse markdown content into tokens
+   */
+  parse(markdown3) {
+    return this.parser.parse(markdown3);
+  }
+  /**
+   * Render tokens to HTML
+   */
+  render(tokens) {
+    return this.renderer.render(tokens);
+  }
+  /**
+   * Parse and render markdown to HTML in one step
+   */
+  toHtml(markdown3) {
+    const tokens = this.parse(markdown3);
+    return this.render(tokens);
+  }
+  /**
+   * Get list of registered extensions
+   */
+  getExtensions() {
+    return Array.from(this.extensions.keys());
+  }
+  /**
+   * Check if extension is registered
+   */
+  hasExtension(name) {
+    return this.extensions.has(name);
+  }
+  /**
+   * Get parser warnings
+   */
+  getWarnings() {
+    return [...this.parser.getWarnings(), ...this.renderer.getWarnings()];
+  }
+  /**
+   * Get debug information from last render
+   */
+  getDebugInfo() {
+    return {
+      warnings: this.getWarnings(),
+      parseTime: 0,
+      renderTime: 0,
+      tokenCount: 0,
+      iterationCount: 0
+    };
+  }
+  /**
+   * Get performance metrics for the last operation
+   */
+  getPerformanceMetrics() {
+    return {
+      parseTime: 0,
+      renderTime: 0,
+      totalTime: 0,
+      tokenCount: 0
+    };
+  }
+  /**
+   * Register built-in extensions
+   */
+  registerBuiltInExtensions() {
+    this.registerExtension(AlertExtension);
+    this.registerExtension(ButtonExtension);
+    this.registerExtension(EmbedExtension);
+  }
+  /**
+   * Rebuild parser and renderer with current extensions
+   */
+  rebuildParserAndRenderer() {
+    const parserConfig = this.parser.getConfig();
+    const rendererConfig = this.renderer.getConfig();
+    this.parser = new MarkdownParser(parserConfig);
+    this.renderer = new MarkdownRenderer(rendererConfig);
+    const extensionsToRegister = Array.from(this.extensions.values());
+    this.extensions.clear();
+    extensionsToRegister.forEach((extension) => {
+      this.registerExtension(extension);
+    });
+    this.parser.setupDefaultRulesIfEmpty();
+  }
+};
+var markdown = new ChangerawrMarkdown();
+function parseMarkdown(content) {
+  return markdown.parse(content);
+}
+function renderMarkdown(content) {
+  return markdown.toHtml(content);
+}
+
+// src/outputs/html.ts
+function renderToHTML(markdown3, config) {
+  const engine = new ChangerawrMarkdown({
+    ...config,
+    renderer: {
+      format: "html",
+      sanitize: true,
+      allowUnsafeHtml: false
+    }
+  });
+  return engine.toHtml(markdown3);
+}
+function renderToHTMLWithConfig(markdown3, rendererConfig) {
+  const engine = new ChangerawrMarkdown({
+    renderer: {
+      format: "html",
+      ...rendererConfig
+    }
+  });
+  return engine.toHtml(markdown3);
+}
+function renderToHTMLUnsafe(markdown3) {
+  return renderToHTMLWithConfig(markdown3, {
+    sanitize: false,
+    allowUnsafeHtml: true
+  });
+}
+
+// src/outputs/json.ts
+function renderToJSON(markdown3, config) {
+  const engine = new ChangerawrMarkdown(config);
+  return engine.parse(markdown3);
+}
+function renderToAST(markdown3, config) {
+  const tokens = renderToJSON(markdown3, config);
+  return tokensToAST(tokens);
+}
+function tokensToAST(tokens) {
+  const ast = [];
+  let currentList = null;
+  let currentBlockquote = null;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token) continue;
+    const node = {
+      type: token.type,
+      content: token.content,
+      ...token.attributes && { attributes: token.attributes }
+    };
+    if (token.type === "list-item" || token.type === "task-item") {
+      if (!currentList) {
+        currentList = {
+          type: token.type === "task-item" ? "task-list" : "list",
+          content: "",
+          children: []
+        };
+        ast.push(currentList);
+      }
+      if (!currentList.children) {
+        currentList.children = [];
+      }
+      currentList.children.push(node);
+      continue;
+    } else {
+      currentList = null;
+    }
+    if (token.type === "blockquote") {
+      if (!currentBlockquote) {
+        currentBlockquote = {
+          type: "blockquote-group",
+          content: "",
+          children: []
+        };
+        ast.push(currentBlockquote);
+      }
+      if (!currentBlockquote.children) {
+        currentBlockquote.children = [];
+      }
+      currentBlockquote.children.push(node);
+      continue;
+    } else {
+      currentBlockquote = null;
+    }
+    if (isParagraphContent(token)) {
+      const paragraphTokens = [token];
+      let j = i + 1;
+      while (j < tokens.length && tokens[j] && isParagraphContent(tokens[j])) {
+        paragraphTokens.push(tokens[j]);
+        j++;
+      }
+      if (paragraphTokens.length > 1 || token.type === "text") {
+        const paragraphNode = {
+          type: "paragraph",
+          content: paragraphTokens.map((t) => t.content).join(""),
+          children: paragraphTokens.map((t) => ({
+            type: t.type,
+            content: t.content,
+            ...t.attributes && { attributes: t.attributes }
+          }))
+        };
+        ast.push(paragraphNode);
+        i = j - 1;
+        continue;
+      }
+    }
+    ast.push(node);
+  }
+  return ast;
+}
+function astToTokens(ast) {
+  const tokens = [];
+  function processNode(node) {
+    if (node.children && node.children.length > 0) {
+      if (node.type === "list" || node.type === "task-list" || node.type === "blockquote-group") {
+        node.children.forEach(processNode);
+        return;
+      }
+      if (node.type === "paragraph") {
+        node.children.forEach((child, index) => {
+          const token2 = {
+            type: child.type,
+            content: child.content,
+            raw: child.content,
+            ...child.attributes && { attributes: child.attributes }
+          };
+          tokens.push(token2);
+          if (index < node.children.length - 1 && isInlineToken(child)) {
+            tokens.push({
+              type: "soft-break",
+              content: " ",
+              raw: " "
+            });
+          }
+        });
+        tokens.push({
+          type: "paragraph-break",
+          content: "",
+          raw: "\n\n"
+        });
+        return;
+      }
+    }
+    const token = {
+      type: node.type,
+      content: node.content,
+      raw: node.content,
+      ...node.attributes && { attributes: node.attributes }
+    };
+    tokens.push(token);
+  }
+  ast.forEach(processNode);
+  return tokens;
+}
+function tokensToJSONString(tokens, pretty = true) {
+  if (pretty) {
+    return JSON.stringify(tokens, null, 2);
+  }
+  return JSON.stringify(tokens);
+}
+function astToJSONString(ast, pretty = true) {
+  if (pretty) {
+    return JSON.stringify(ast, null, 2);
+  }
+  return JSON.stringify(ast);
+}
+function parseTokensFromJSON(jsonString) {
+  try {
+    const parsed = JSON.parse(jsonString);
+    if (!Array.isArray(parsed)) {
+      throw new Error("JSON must be an array of tokens");
+    }
+    for (const token of parsed) {
+      if (!token.type || typeof token.type !== "string") {
+        throw new Error("Invalid token structure: missing or invalid type");
+      }
+      if (token.content === void 0 && token.raw === void 0) {
+        throw new Error("Invalid token structure: missing content and raw");
+      }
+    }
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse tokens from JSON: ${message}`);
+  }
+}
+function parseASTFromJSON(jsonString) {
+  try {
+    const parsed = JSON.parse(jsonString);
+    if (!Array.isArray(parsed)) {
+      throw new Error("JSON must be an array of AST nodes");
+    }
+    for (const node of parsed) {
+      if (!node.type || typeof node.type !== "string") {
+        throw new Error("Invalid AST node: missing or invalid type");
+      }
+    }
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse AST from JSON: ${message}`);
+  }
+}
+function getTokenStats(tokens) {
+  const tokenTypes = {};
+  const extensionTokens = {};
+  let totalContent = 0;
+  let totalRaw = 0;
+  let tokensWithAttributes = 0;
+  for (const token of tokens) {
+    tokenTypes[token.type] = (tokenTypes[token.type] || 0) + 1;
+    if (["alert", "button", "embed"].includes(token.type)) {
+      extensionTokens[token.type] = (extensionTokens[token.type] || 0) + 1;
+    }
+    totalContent += (token.content || "").length;
+    totalRaw += (token.raw || "").length;
+    if (token.attributes && Object.keys(token.attributes).length > 0) {
+      tokensWithAttributes++;
+    }
+  }
+  const totalTokens = tokens.length;
+  return {
+    totalTokens,
+    tokenTypes,
+    extensionTokens,
+    totalContent,
+    totalRaw,
+    tokensWithAttributes,
+    averageContentLength: totalTokens > 0 ? Math.round(totalContent / totalTokens) : 0,
+    averageRawLength: totalTokens > 0 ? Math.round(totalRaw / totalTokens) : 0,
+    attributeUsageRate: totalTokens > 0 ? Math.round(tokensWithAttributes / totalTokens * 100) : 0
+  };
+}
+function getASTStats(ast) {
+  let totalNodes = 0;
+  let maxDepth = 0;
+  let nodesWithChildren = 0;
+  let totalChildren = 0;
+  const nodeTypes = {};
+  function analyzeNode(node, depth = 0) {
+    totalNodes++;
+    maxDepth = Math.max(maxDepth, depth);
+    nodeTypes[node.type] = (nodeTypes[node.type] || 0) + 1;
+    if (node.children && node.children.length > 0) {
+      nodesWithChildren++;
+      totalChildren += node.children.length;
+      node.children.forEach((child) => analyzeNode(child, depth + 1));
+    }
+  }
+  ast.forEach((node) => analyzeNode(node));
+  return {
+    totalNodes,
+    maxDepth,
+    nodesWithChildren,
+    totalChildren,
+    nodeTypes,
+    averageChildrenPerParent: nodesWithChildren > 0 ? Math.round(totalChildren / nodesWithChildren) : 0,
+    hierarchyComplexity: maxDepth > 0 ? Math.round(totalChildren / totalNodes * maxDepth) : 0
+  };
+}
+function compareTokens(tokensA, tokensB) {
+  const differences = [];
+  const maxLength = Math.max(tokensA.length, tokensB.length);
+  for (let i = 0; i < maxLength; i++) {
+    const tokenA = tokensA[i];
+    const tokenB = tokensB[i];
+    if (!tokenA && tokenB) {
+      differences.push({
+        index: i,
+        type: "added",
+        tokenB
+      });
+    } else if (tokenA && !tokenB) {
+      differences.push({
+        index: i,
+        type: "removed",
+        tokenA
+      });
+    } else if (tokenA && tokenB) {
+      if (tokenA.type !== tokenB.type || tokenA.content !== tokenB.content) {
+        differences.push({
+          index: i,
+          type: "modified",
+          tokenA,
+          tokenB
+        });
+      }
+    }
+  }
+  return {
+    identical: differences.length === 0,
+    differences,
+    addedCount: differences.filter((d) => d.type === "added").length,
+    removedCount: differences.filter((d) => d.type === "removed").length,
+    modifiedCount: differences.filter((d) => d.type === "modified").length
+  };
+}
+function isParagraphContent(token) {
+  return ["text", "bold", "italic", "code", "link", "soft-break"].includes(token.type);
+}
+function isInlineToken(node) {
+  return ["bold", "italic", "code", "link"].includes(node.type);
+}
+
+// src/outputs/tailwind.ts
+function renderToTailwind(markdown3, config) {
+  const engine = new ChangerawrMarkdown({
+    ...config,
+    renderer: {
+      format: "tailwind",
+      sanitize: true,
+      allowUnsafeHtml: false
+    }
+  });
+  return engine.toHtml(markdown3);
+}
+function renderToTailwindWithClasses(markdown3, customClasses) {
+  const engine = new ChangerawrMarkdown({
+    renderer: {
+      format: "tailwind",
+      ...customClasses && { customClasses }
+    }
+  });
+  return engine.toHtml(markdown3);
+}
+function renderToTailwindWithConfig(markdown3, rendererConfig) {
+  const engine = new ChangerawrMarkdown({
+    renderer: {
+      format: "tailwind",
+      ...rendererConfig
+    }
+  });
+  return engine.toHtml(markdown3);
+}
+var defaultTailwindClasses = {
+  // Typography
+  "heading-1": "text-3xl font-bold mt-8 mb-4",
+  "heading-2": "text-2xl font-semibold mt-6 mb-3",
+  "heading-3": "text-xl font-medium mt-5 mb-3",
+  "heading-4": "text-lg font-medium mt-4 mb-2",
+  "heading-5": "text-base font-medium mt-3 mb-2",
+  "heading-6": "text-sm font-medium mt-3 mb-2",
+  "paragraph": "leading-7 mb-4",
+  "blockquote": "pl-4 py-2 border-l-2 border-border italic text-muted-foreground my-4",
+  // Code
+  "code-inline": "bg-muted px-1.5 py-0.5 rounded text-sm font-mono",
+  "code-block": "bg-muted p-4 rounded-md overflow-x-auto my-4",
+  // Links and buttons
+  "link": "text-primary hover:underline inline-flex items-center gap-1",
+  "button": "inline-flex items-center justify-center font-medium rounded-lg transition-all duration-200",
+  // Lists
+  "list": "list-disc list-inside space-y-1",
+  "list-item": "ml-4",
+  // Images and media
+  "image": "max-w-full h-auto rounded-lg my-4",
+  "embed": "rounded-lg border bg-card text-card-foreground shadow-sm mb-6 overflow-hidden",
+  // Alerts
+  "alert": "border-l-4 p-4 mb-4 rounded-md transition-colors duration-200",
+  "alert-info": "bg-blue-500/10 border-blue-500/30 text-blue-600 border-l-blue-500",
+  "alert-warning": "bg-amber-500/10 border-amber-500/30 text-amber-600 border-l-amber-500",
+  "alert-error": "bg-red-500/10 border-red-500/30 text-red-600 border-l-red-500",
+  "alert-success": "bg-green-500/10 border-green-500/30 text-green-600 border-l-green-500"
+};
+var proseClasses = {
+  "heading-1": "text-4xl font-bold tracking-tight mt-10 mb-6",
+  "heading-2": "text-3xl font-semibold tracking-tight mt-8 mb-4",
+  "heading-3": "text-2xl font-medium tracking-tight mt-6 mb-3",
+  "paragraph": "text-lg leading-8 mb-6",
+  "blockquote": "border-l-4 border-gray-300 pl-6 py-2 italic text-gray-700 my-6",
+  "code-inline": "bg-gray-100 text-gray-800 px-2 py-1 rounded text-sm font-mono",
+  "code-block": "bg-gray-900 text-gray-100 p-6 rounded-lg overflow-x-auto my-6 text-sm",
+  "link": "text-blue-600 hover:text-blue-800 underline decoration-2 underline-offset-2"
+};
+var minimalClasses = {
+  "heading-1": "text-2xl font-semibold mb-4",
+  "heading-2": "text-xl font-medium mb-3",
+  "heading-3": "text-lg font-medium mb-2",
+  "paragraph": "mb-4",
+  "blockquote": "border-l-2 border-gray-300 pl-4 italic mb-4",
+  "code-inline": "bg-gray-100 px-1 rounded font-mono text-sm",
+  "code-block": "bg-gray-100 p-3 rounded font-mono text-sm mb-4",
+  "link": "text-blue-600 hover:underline"
+};
+
+// src/standalone.ts
+function renderCum(markdown3, config) {
+  const engine = new ChangerawrMarkdown(config);
+  return engine.toHtml(markdown3);
+}
+function parseCum(markdown3, config) {
+  const engine = new ChangerawrMarkdown(config);
+  return engine.parse(markdown3);
+}
+function createCumEngine(config) {
+  return new ChangerawrMarkdown(config);
+}
+function renderCumToHtml(markdown3) {
+  return renderCum(markdown3, {
+    renderer: { format: "html" }
+  });
+}
+function renderCumToTailwind(markdown3) {
+  return renderCum(markdown3, {
+    renderer: { format: "tailwind" }
+  });
+}
+function renderCumToJson(markdown3) {
+  return parseCum(markdown3);
+}
+if (typeof window !== "undefined") {
+  window.ChangerawrMarkdown = {
+    renderCum,
+    parseCum,
+    createCumEngine,
+    renderCumToHtml,
+    renderCumToTailwind,
+    renderCumToJson,
+    // Legacy aliases
+    render: renderCum,
+    parse: parseCum
+  };
+}
+
+// src/index.ts
+function createEngine(config) {
+  return new ChangerawrMarkdown(config);
+}
+function createHTMLEngine(config) {
+  return new ChangerawrMarkdown({
+    ...config,
+    renderer: {
+      format: "html",
+      sanitize: true,
+      allowUnsafeHtml: false,
+      ...config?.parser
+    }
+  });
+}
+function createTailwindEngine(config) {
+  return new ChangerawrMarkdown({
+    ...config,
+    renderer: {
+      format: "tailwind",
+      sanitize: true,
+      allowUnsafeHtml: false,
+      ...config?.parser
+    }
+  });
+}
+function createDebugEngine(config) {
+  return new ChangerawrMarkdown({
+    ...config,
+    parser: {
+      debugMode: true,
+      validateMarkdown: true,
+      ...config?.parser
+    },
+    renderer: {
+      format: "tailwind",
+      debugMode: true,
+      ...config?.renderer
+    }
+  });
+}
+function createMinimalEngine(config) {
+  const engine = new ChangerawrMarkdown({
+    ...config,
+    extensions: []
+    // Override to prevent built-in extensions
+  });
+  if (engine.hasExtension("alert")) {
+    engine.unregisterExtension("alert");
+  }
+  if (engine.hasExtension("button")) {
+    engine.unregisterExtension("button");
+  }
+  if (engine.hasExtension("embed")) {
+    engine.unregisterExtension("embed");
+  }
+  return engine;
+}
+function createCustomEngine(extensions, config) {
+  return new ChangerawrMarkdown({
+    ...config,
+    extensions
+  });
+}
+var markdown2 = {
+  // Core rendering functions
+  render: renderMarkdown,
+  parse: parseMarkdown,
+  // Output format functions
+  toHtml: renderToHTML,
+  toTailwind: renderToTailwind,
+  toJson: renderToJSON,
+  toAst: renderToAST,
+  // Engine creation
+  createEngine,
+  createHTMLEngine,
+  createTailwindEngine,
+  createDebugEngine,
+  createMinimalEngine,
+  createCustomEngine,
+  // Standalone functions
+  renderCum,
+  parseCum,
+  // Main class
+  ChangerawrMarkdown,
+  // Extensions
+  extensions: {
+    Alert: AlertExtension,
+    Button: ButtonExtension,
+    Embed: EmbedExtension
+  },
+  // Utilities
+  utils: {
+    escapeHtml,
+    generateId,
+    sanitizeHtml,
+    extractDomain,
+    parseOptions,
+    PerformanceTimer,
+    Logger
+  }
+};
+var index_default = markdown2;
+var presets = {
+  /**
+   * Blog/article preset with prose-friendly styling
+   */
+  blog: {
+    renderer: {
+      format: "tailwind",
+      customClasses: {
+        "heading-1": "text-4xl font-bold tracking-tight mt-10 mb-6",
+        "heading-2": "text-3xl font-semibold tracking-tight mt-8 mb-4",
+        "heading-3": "text-2xl font-medium tracking-tight mt-6 mb-3",
+        "paragraph": "text-lg leading-8 mb-6",
+        "blockquote": "border-l-4 border-gray-300 pl-6 py-2 italic text-gray-700 my-6",
+        "code-inline": "bg-gray-100 text-gray-800 px-2 py-1 rounded text-sm font-mono",
+        "code-block": "bg-gray-900 text-gray-100 p-6 rounded-lg overflow-x-auto my-6 text-sm"
+      }
+    }
+  },
+  /**
+   * Documentation preset with clean, technical styling
+   */
+  docs: {
+    renderer: {
+      format: "tailwind",
+      customClasses: {
+        "heading-1": "text-3xl font-bold border-b border-gray-200 pb-2 mb-6",
+        "heading-2": "text-2xl font-semibold mt-8 mb-4",
+        "heading-3": "text-xl font-medium mt-6 mb-3",
+        "paragraph": "leading-7 mb-4",
+        "code-inline": "bg-blue-50 text-blue-800 px-2 py-1 rounded text-sm font-mono",
+        "code-block": "bg-gray-50 border border-gray-200 p-4 rounded-lg overflow-x-auto my-4 text-sm",
+        "alert": "border border-blue-200 bg-blue-50 text-blue-800 p-4 rounded-lg mb-4"
+      }
+    }
+  },
+  /**
+   * Minimal preset with basic styling
+   */
+  minimal: {
+    renderer: {
+      format: "html",
+      sanitize: true
+    }
+  },
+  /**
+   * Performance preset with minimal processing
+   */
+  fast: {
+    parser: {
+      validateMarkdown: false,
+      maxIterations: 1e3
+    },
+    renderer: {
+      format: "html",
+      sanitize: false
+    }
+  }
+};
+function createEngineWithPreset(presetName, additionalConfig) {
+  const preset = presets[presetName];
+  return new ChangerawrMarkdown({
+    ...preset,
+    ...additionalConfig
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlertExtension,
+  ButtonExtension,
+  ChangerawrMarkdown,
+  EmbedExtension,
+  Logger,
+  MarkdownParser,
+  MarkdownRenderer,
+  PerformanceTimer,
+  astToJSONString,
+  astToTokens,
+  basicSanitize,
+  compareTokens,
+  createCumEngine,
+  createCustomEngine,
+  createDebugEngine,
+  createEngine,
+  createEngineWithPreset,
+  createHTMLEngine,
+  createMinimalEngine,
+  createTailwindEngine,
+  debounce,
+  deepMerge,
+  defaultTailwindClasses,
+  escapeHtml,
+  extractDomain,
+  generateId,
+  getASTStats,
+  getTokenStats,
+  isBrowser,
+  isNode,
+  isValidUrl,
+  markdown,
+  minimalClasses,
+  parseASTFromJSON,
+  parseCum,
+  parseMarkdown,
+  parseOptions,
+  parseTokensFromJSON,
+  presets,
+  proseClasses,
+  renderCum,
+  renderCumToHtml,
+  renderCumToJson,
+  renderCumToTailwind,
+  renderMarkdown,
+  renderToAST,
+  renderToHTML,
+  renderToHTMLUnsafe,
+  renderToHTMLWithConfig,
+  renderToJSON,
+  renderToTailwind,
+  renderToTailwindWithClasses,
+  renderToTailwindWithConfig,
+  sanitizeHtml,
+  tokensToAST,
+  tokensToJSONString
+});
+//# sourceMappingURL=index.js.map