@changerawr/markdown 1.1.10 → 1.2.0

package/dist/astro/index.js

@@ -0,0 +1,2177 @@
+"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/astro/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChangerawrMarkdown: () => ChangerawrMarkdown,
+  renderMarkdownForAstro: () => renderMarkdownForAstro,
+  renderToHTML: () => renderToHTML,
+  renderToHTMLWithConfig: () => renderToHTMLWithConfig,
+  renderToTailwind: () => renderToTailwind,
+  renderToTailwindWithConfig: () => renderToTailwindWithConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parser.ts
+var MarkdownParser = class _MarkdownParser {
+  // Cache compiled regexes
+  constructor(config) {
+    this.rules = [];
+    this.warnings = [];
+    this.compiledPatterns = /* @__PURE__ */ new Map();
+    this.config = {
+      debugMode: false,
+      maxIterations: 1e4,
+      validateMarkdown: false,
+      ...config
+    };
+  }
+  addRule(rule) {
+    this.rules.push(rule);
+    this.compiledPatterns.set(
+      rule,
+      new RegExp(rule.pattern.source, rule.pattern.flags.replace("g", ""))
+    );
+    this.rules.sort((a, b) => {
+      const aFeatureExtension = ["alert", "button", "embed"].includes(a.name);
+      const bFeatureExtension = ["alert", "button", "embed"].includes(b.name);
+      if (aFeatureExtension && !bFeatureExtension) return -1;
+      if (!aFeatureExtension && bFeatureExtension) return 1;
+      const aCoreExtension = ["text", "heading", "bold", "italic", "code", "codeblock", "link", "image", "list", "task-list", "blockquote", "hr", "paragraph", "line-break"].includes(a.name);
+      const bCoreExtension = ["text", "heading", "bold", "italic", "code", "codeblock", "link", "image", "list", "task-list", "blockquote", "hr", "paragraph", "line-break"].includes(b.name);
+      if (aCoreExtension && !bCoreExtension) return -1;
+      if (!aCoreExtension && bCoreExtension) return 1;
+      if (a.name === "image" && b.name === "link") return -1;
+      if (a.name === "link" && b.name === "image") return 1;
+      if (a.name === "task-item" && b.name === "list-item") return -1;
+      if (a.name === "list-item" && b.name === "task-item") return 1;
+      if (a.name === "codeblock" && b.name === "code") return -1;
+      if (a.name === "code" && b.name === "codeblock") return 1;
+      if (a.name === "bold" && b.name === "italic") return -1;
+      if (a.name === "italic" && b.name === "bold") return 1;
+      return a.name.localeCompare(b.name);
+    });
+  }
+  hasRule(name) {
+    return this.rules.some((rule) => rule.name === name);
+  }
+  parse(markdown2) {
+    this.warnings = [];
+    if (!markdown2.trim()) {
+      return [];
+    }
+    if (this.rules.length === 0) {
+      this.warnings.push("No parse rules registered - consider using CoreExtensions");
+      return [{
+        type: "text",
+        content: markdown2,
+        raw: markdown2
+      }];
+    }
+    const processedMarkdown = this.preprocessMarkdown(markdown2);
+    const tokens = [];
+    let remaining = processedMarkdown;
+    let iterationCount = 0;
+    const maxIterations = this.config.maxIterations || 1e4;
+    while (remaining.length > 0 && iterationCount < maxIterations) {
+      iterationCount++;
+      let matched = false;
+      let bestMatch = null;
+      let nextBestMatchIndex = null;
+      for (const rule of this.rules) {
+        try {
+          const pattern = this.compiledPatterns.get(rule);
+          const match = remaining.match(pattern);
+          if (match && match.index !== void 0) {
+            if (match.index === 0) {
+              bestMatch = { rule, match, priority: 1e3 };
+              break;
+            }
+            if (nextBestMatchIndex === null || match.index < nextBestMatchIndex) {
+              nextBestMatchIndex = match.index;
+            }
+            const priority = 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 chunkSize = nextBestMatchIndex !== null ? nextBestMatchIndex : Math.min(remaining.length, 1e3);
+        const textChunk = remaining.slice(0, chunkSize);
+        tokens.push({
+          type: "text",
+          content: textChunk,
+          raw: textChunk
+        });
+        remaining = remaining.slice(chunkSize);
+      }
+    }
+    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 = [];
+  }
+  preprocessMarkdown(markdown2) {
+    if (this.config.validateMarkdown) {
+      this.validateMarkdown(markdown2);
+    }
+    return markdown2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  }
+  validateMarkdown(markdown2) {
+    const boldMatches = markdown2.match(/\*\*/g);
+    if (boldMatches && boldMatches.length % 2 !== 0) {
+      this.warnings.push("Unclosed bold markers (**) detected - some bold formatting may not work");
+    }
+    const italicMatches = markdown2.match(/(?<!\*)\*(?!\*)/g);
+    if (italicMatches && italicMatches.length % 2 !== 0) {
+      this.warnings.push("Unclosed italic markers (*) detected - some italic formatting may not work");
+    }
+    const codeBlockMatches = markdown2.match(/```/g);
+    if (codeBlockMatches && codeBlockMatches.length % 2 !== 0) {
+      this.warnings.push("Unclosed code blocks (```) detected - some code formatting may not work");
+    }
+    const inlineCodeMatches = markdown2.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) {
+        const processedToken = this.recursivelyParseBlockContent(token);
+        processed.push(processedToken);
+        i++;
+      } else {
+        i++;
+      }
+    }
+    return processed;
+  }
+  recursivelyParseBlockContent(token) {
+    const blockTypes = ["alert", "blockquote", "list-item", "ordered-list-item", "task-item"];
+    if (blockTypes.includes(token.type) && token.content && token.content.trim()) {
+      let children;
+      if ((token.type === "list-item" || token.type === "ordered-list-item" || token.type === "task-item") && this.rules.some((r) => r.name === "unordered-list-item" || r.name === "ordered-list-item" || r.name === "task-item")) {
+        const parserWithoutListRule = new _MarkdownParser(this.config);
+        this.rules.forEach((rule) => {
+          if (rule.name !== "unordered-list-item" && rule.name !== "ordered-list-item" && rule.name !== "task-item") {
+            parserWithoutListRule.addRule(rule);
+          }
+        });
+        children = parserWithoutListRule.parse(token.content);
+      } else {
+        children = this.parse(token.content);
+      }
+      return {
+        ...token,
+        children
+      };
+    }
+    return token;
+  }
+};
+
+// 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 extractDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+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;
+}
+
+// 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
+    };
+  }
+  addRule(rule) {
+    this.rules.set(rule.type, rule);
+  }
+  hasRule(type) {
+    return this.rules.has(type);
+  }
+  render(tokens) {
+    this.warnings = [];
+    const tokensWithFormat = tokens.map((token) => ({
+      ...token,
+      attributes: {
+        ...token.attributes,
+        format: this.config.format
+      }
+    }));
+    const groupedTokens = this.groupListItems(tokensWithFormat);
+    const htmlParts = groupedTokens.map((token) => this.renderToken(token));
+    const combinedHtml = htmlParts.join("");
+    if (this.config.sanitize && !this.config.allowUnsafeHtml) {
+      return sanitizeHtml(combinedHtml);
+    }
+    return combinedHtml;
+  }
+  groupListItems(tokens) {
+    const result = [];
+    let i = 0;
+    while (i < tokens.length) {
+      const token = tokens[i];
+      const isListItem = token?.type === "list-item" || token?.type === "ordered-list-item" || token?.type === "task-item";
+      if (isListItem) {
+        const listItems = [];
+        const firstItemType = token.type;
+        const isOrdered = firstItemType === "ordered-list-item";
+        while (i < tokens.length) {
+          const item = tokens[i];
+          if (!item) break;
+          const itemType = item.type;
+          const isSameListType = isOrdered && itemType === "ordered-list-item" || !isOrdered && (itemType === "list-item" || itemType === "task-item");
+          if (isSameListType) {
+            listItems.push(item);
+            i++;
+          } else {
+            break;
+          }
+        }
+        const wrappedList = {
+          type: isOrdered ? "ol" : "ul",
+          content: "",
+          raw: "",
+          children: listItems,
+          attributes: { format: this.config.format }
+        };
+        wrappedList._isWrapped = true;
+        result.push(wrappedList);
+      } else {
+        result.push(token);
+        i++;
+      }
+    }
+    return result;
+  }
+  renderToken(token) {
+    const rule = this.rules.get(token.type);
+    if (rule) {
+      try {
+        let tokenToRender = token;
+        if (token.children && token.children.length > 0) {
+          const renderedChildren = token.type === "ul" || token.type === "ol" ? token.children.map((child) => this.renderToken(child)).join("") : this.render(token.children);
+          tokenToRender = {
+            ...token,
+            attributes: {
+              ...token.attributes,
+              renderedChildren
+              // Extensions can use this instead of re-parsing
+            }
+          };
+        }
+        return rule.render(tokenToRender);
+      } 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 (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>`;
+  }
+  getWarnings() {
+    return [...this.warnings];
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  setDebugMode(enabled) {
+    this.config.debugMode = enabled;
+  }
+  clearWarnings() {
+    this.warnings = [];
+  }
+};
+
+// src/cache.ts
+var LRUCache = class {
+  constructor(capacity = 100) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.hits = 0;
+    this.misses = 0;
+    this.evictions = 0;
+    if (capacity <= 0) {
+      throw new Error("Cache capacity must be greater than 0");
+    }
+    this.capacity = capacity;
+  }
+  /**
+   * Get a value from the cache
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (entry) {
+      entry.timestamp = Date.now();
+      entry.accessCount++;
+      this.hits++;
+      this.cache.delete(key);
+      this.cache.set(key, entry);
+      return entry.value;
+    }
+    this.misses++;
+    return void 0;
+  }
+  /**
+   * Set a value in the cache
+   */
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.capacity) {
+      this.evictLRU();
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      accessCount: 0
+    });
+  }
+  /**
+   * Check if a key exists in the cache
+   */
+  has(key) {
+    return this.cache.has(key);
+  }
+  /**
+   * Delete a specific key from the cache
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * Clear all entries from the cache
+   */
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+    this.evictions = 0;
+  }
+  /**
+   * Get the current size of the cache
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const totalRequests = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      capacity: this.capacity,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: totalRequests > 0 ? this.hits / totalRequests : 0,
+      evictions: this.evictions
+    };
+  }
+  /**
+   * Reset cache statistics
+   */
+  resetStats() {
+    this.hits = 0;
+    this.misses = 0;
+    this.evictions = 0;
+  }
+  /**
+   * Get all keys in the cache
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  /**
+   * Get all values in the cache
+   */
+  values() {
+    return Array.from(this.cache.values()).map((entry) => entry.value);
+  }
+  /**
+   * Update cache capacity and evict if necessary
+   */
+  setCapacity(newCapacity) {
+    if (newCapacity <= 0) {
+      throw new Error("Cache capacity must be greater than 0");
+    }
+    this.capacity = newCapacity;
+    while (this.cache.size > this.capacity) {
+      this.evictLRU();
+    }
+  }
+  /**
+   * Evict the least recently used entry
+   */
+  evictLRU() {
+    const firstKey = this.cache.keys().next().value;
+    if (firstKey !== void 0) {
+      this.cache.delete(firstKey);
+      this.evictions++;
+    }
+  }
+};
+function hashContent(content) {
+  if (content.length > 1e4) {
+    const start = content.slice(0, 1e3);
+    const middle = content.slice(Math.floor(content.length / 2) - 500, Math.floor(content.length / 2) + 500);
+    const end = content.slice(-1e3);
+    const sample = content.length + "|" + start + middle + end;
+    let hash2 = 2166136261;
+    for (let i = 0; i < sample.length; i++) {
+      hash2 ^= sample.charCodeAt(i);
+      hash2 += (hash2 << 1) + (hash2 << 4) + (hash2 << 7) + (hash2 << 8) + (hash2 << 24);
+    }
+    return (hash2 >>> 0).toString(36);
+  }
+  let hash = 2166136261;
+  for (let i = 0; i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+  return (hash >>> 0).toString(36);
+}
+
+// src/extensions/core/blockquote.ts
+var BlockquoteExtension = {
+  name: "blockquote",
+  parseRules: [
+    {
+      name: "blockquote",
+      pattern: /^>\s+(.+)$/m,
+      render: (match) => ({
+        type: "blockquote",
+        content: match[1] || "",
+        raw: match[0] || ""
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "blockquote",
+      render: (token) => {
+        const format = token.attributes?.format || "html";
+        const renderedChildren = token.attributes?.renderedChildren;
+        const renderMarkdown = token.attributes?.renderMarkdown;
+        const content = renderedChildren || (renderMarkdown ? renderMarkdown(token.content) : escapeHtml(token.content));
+        if (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>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/core/breaks.ts
+var LineBreakExtension = {
+  name: "line-break",
+  parseRules: [
+    {
+      name: "hard-break-backslash",
+      pattern: /\\\s*\n/,
+      render: (match) => ({
+        type: "line-break",
+        content: "",
+        raw: match[0] || ""
+      })
+    },
+    {
+      name: "hard-break-spaces",
+      pattern: /  +\n/,
+      render: (match) => ({
+        type: "line-break",
+        content: "",
+        raw: match[0] || ""
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "line-break",
+      render: () => "<br>"
+    },
+    {
+      type: "paragraph-break",
+      render: () => "</p><p>"
+    },
+    {
+      type: "soft-break",
+      render: (token) => token.content || " "
+    }
+  ]
+};
+
+// src/extensions/core/code.ts
+var InlineCodeExtension = {
+  name: "inline-code",
+  parseRules: [
+    {
+      name: "code",
+      pattern: /`([^`]+)`/,
+      render: (match) => ({
+        type: "code",
+        content: match[1] || "",
+        raw: match[0] || ""
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "code",
+      render: (token) => {
+        const content = escapeHtml(token.content);
+        const format = token.attributes?.format;
+        if (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>`;
+      }
+    }
+  ]
+};
+var CodeBlockExtension = {
+  name: "codeblock",
+  parseRules: [
+    {
+      name: "codeblock",
+      pattern: /```(\w+)?\s*\n([\s\S]*?)\n```/,
+      render: (match) => ({
+        type: "codeblock",
+        content: match[2] || "",
+        raw: match[0] || "",
+        attributes: {
+          language: match[1] || "text"
+        }
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "codeblock",
+      render: (token) => {
+        const language = token.attributes?.language || "text";
+        const escapedCode = escapeHtml(token.content);
+        const format = token.attributes?.format || "html";
+        if (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>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/core/emphasis.ts
+var BoldExtension = {
+  name: "bold",
+  parseRules: [
+    {
+      name: "bold",
+      pattern: /\*\*((?:(?!\*\*).)+)\*\*/,
+      render: (match) => ({
+        type: "bold",
+        content: match[1] || "",
+        raw: match[0] || ""
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "bold",
+      render: (token) => {
+        const content = escapeHtml(token.content);
+        const format = token.attributes?.format;
+        if (format === "html") {
+          return `<strong>${content}</strong>`;
+        }
+        return `<strong class="font-bold">${content}</strong>`;
+      }
+    }
+  ]
+};
+var ItalicExtension = {
+  name: "italic",
+  parseRules: [
+    {
+      name: "italic",
+      pattern: /\*((?:(?!\*).)+)\*/,
+      render: (match) => ({
+        type: "italic",
+        content: match[1] || "",
+        raw: match[0] || ""
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "italic",
+      render: (token) => {
+        const content = escapeHtml(token.content);
+        const format = token.attributes?.format;
+        if (format === "html") {
+          return `<em>${content}</em>`;
+        }
+        return `<em class="italic">${content}</em>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/core/heading.ts
+var HeadingExtension = {
+  name: "heading",
+  parseRules: [
+    {
+      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)
+        }
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "heading",
+      render: (token) => {
+        const level = parseInt(token.attributes?.level || "1");
+        const text = token.content;
+        const id = generateId(text);
+        const escapedContent = escapeHtml(text);
+        const format = token.attributes?.format || "html";
+        if (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 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"/>
+  <path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"/>
+</svg>
+          </a>
+        </h${level}>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/core/hr.ts
+var HorizontalRuleExtension = {
+  name: "hr",
+  parseRules: [
+    {
+      name: "hr",
+      pattern: /^---$/m,
+      render: (match) => ({
+        type: "hr",
+        content: "",
+        raw: match[0] || ""
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "hr",
+      render: (token) => {
+        const format = token.attributes?.format;
+        if (format === "html") {
+          return '<hr style="margin: 24px 0; border: none; border-top: 1px solid #d1d5db;">';
+        }
+        return '<hr class="my-6 border-t border-border">';
+      }
+    }
+  ]
+};
+
+// src/extensions/core/image.ts
+var ImageExtension = {
+  name: "image",
+  parseRules: [
+    {
+      name: "image",
+      pattern: /!\[([^\]]*)\]\(([^)]+?)(?:\s+"([^"]+)")?\)/,
+      render: (match) => ({
+        type: "image",
+        content: match[1] || "",
+        raw: match[0] || "",
+        attributes: {
+          alt: match[1] || "",
+          src: match[2] || "",
+          caption: match[3] || ""
+          // Renamed from 'title' to 'caption' for clarity
+        }
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "image",
+      render: (token) => {
+        const src = token.attributes?.src || "";
+        const alt = token.attributes?.alt || "";
+        const caption = token.attributes?.caption || "";
+        const format = token.attributes?.format || "html";
+        if (caption) {
+          if (format === "html") {
+            return `<figure style="margin: 16px 0; text-align: center;">
+            <img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}" style="max-width: 100%; height: auto; border-radius: 8px;" loading="lazy" />
+            <figcaption style="margin-top: 8px; font-size: 14px; color: #6b7280; font-style: italic;">${escapeHtml(caption)}</figcaption>
+          </figure>`;
+          }
+          return `<figure class="my-4 text-center">
+            <img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}" class="max-w-full h-auto rounded-lg" loading="lazy" />
+            <figcaption class="mt-2 text-sm text-gray-500 italic">${escapeHtml(caption)}</figcaption>
+          </figure>`;
+        }
+        if (format === "html") {
+          return `<img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}" style="max-width: 100%; height: auto; border-radius: 8px; margin: 16px 0;" loading="lazy" />`;
+        }
+        return `<img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}" class="max-w-full h-auto rounded-lg my-4" loading="lazy" />`;
+      }
+    }
+  ]
+};
+
+// src/extensions/core/links.ts
+var LinkExtension = {
+  name: "link",
+  parseRules: [
+    {
+      name: "link",
+      pattern: /\[(?!(?:button|embed):)([^\]]+)\]\(([^)]+)\)/,
+      render: (match) => ({
+        type: "link",
+        content: match[1] || "",
+        raw: match[0] || "",
+        attributes: {
+          href: match[2] || ""
+        }
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "link",
+      render: (token) => {
+        const href = token.attributes?.href || "#";
+        const escapedHref = escapeHtml(href);
+        const escapedText = escapeHtml(token.content);
+        const format = token.attributes?.format || "html";
+        if (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>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/core/lists.ts
+var ListExtension = {
+  name: "list",
+  parseRules: [
+    {
+      name: "unordered-list-item",
+      pattern: /^(\s*)[-*+]\s+(.+)$/m,
+      render: (match) => ({
+        type: "list-item",
+        content: match[2] || "",
+        raw: match[0] || "",
+        attributes: {
+          indent: match[1]?.length || 0,
+          ordered: false,
+          marker: match[1] ? match[0].match(/[-*+]/)?.[0] : "-"
+        }
+      })
+    },
+    {
+      name: "ordered-list-item",
+      pattern: /^(\s*)(\d+)\.\s+(.+)$/m,
+      render: (match) => ({
+        type: "ordered-list-item",
+        content: match[3] || "",
+        raw: match[0] || "",
+        attributes: {
+          indent: match[1]?.length || 0,
+          ordered: true,
+          number: parseInt(match[2] || "1")
+        }
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "ul",
+      render: (token) => {
+        const format = token.attributes?.format || "tailwind";
+        const content = token.attributes?.renderedChildren || "";
+        if (format === "html") {
+          return `<ul style="margin: 8px 0; padding-left: 24px; list-style: disc;">${content}</ul>`;
+        }
+        return `<ul class="my-2 pl-6 list-disc">${content}</ul>`;
+      }
+    },
+    {
+      type: "ol",
+      render: (token) => {
+        const format = token.attributes?.format || "tailwind";
+        const content = token.attributes?.renderedChildren || "";
+        if (format === "html") {
+          return `<ol style="margin: 8px 0; padding-left: 24px; list-style: decimal;">${content}</ol>`;
+        }
+        return `<ol class="my-2 pl-6 list-decimal">${content}</ol>`;
+      }
+    },
+    {
+      type: "list-item",
+      render: (token) => {
+        const format = token.attributes?.format || "tailwind";
+        const content = token.attributes?.renderedChildren || escapeHtml(token.content);
+        if (format === "html") {
+          return `<li>${content}</li>`;
+        }
+        return `<li>${content}</li>`;
+      }
+    },
+    {
+      type: "ordered-list-item",
+      render: (token) => {
+        const format = token.attributes?.format || "tailwind";
+        const content = token.attributes?.renderedChildren || escapeHtml(token.content);
+        if (format === "html") {
+          return `<li>${content}</li>`;
+        }
+        return `<li>${content}</li>`;
+      }
+    }
+  ]
+};
+var TaskListExtension = {
+  name: "task-list",
+  parseRules: [
+    {
+      name: "task-item",
+      pattern: /^(\s*)-\s*\[([ xX])\]\s*(.+)$/m,
+      render: (match) => ({
+        type: "task-item",
+        content: match[3] || "",
+        raw: match[0] || "",
+        attributes: {
+          indent: match[1]?.length || 0,
+          checked: String((match[2] || "").toLowerCase() === "x")
+        }
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "task-item",
+      render: (token) => {
+        const isChecked = token.attributes?.checked === "true";
+        const content = token.attributes?.renderedChildren || escapeHtml(token.content);
+        const format = token.attributes?.format || "html";
+        const checkmark = `<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="flex-shrink: 0; margin-top: 2px;"><polyline points="20 6 9 17 4 12"></polyline></svg>`;
+        const checkbox = `<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="flex-shrink: 0; margin-top: 2px;"><rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect></svg>`;
+        if (format === "html") {
+          return `<div style="display: flex; align-items: flex-start; gap: 8px; margin: 8px 0;">
+            <div style="color: ${isChecked ? "#10b981" : "#9ca3af"}; margin-top: 2px;">
+              ${isChecked ? checkmark : checkbox}
+            </div>
+            <span${isChecked ? ' style="text-decoration: line-through; color: #6b7280;"' : ""}>${content}</span>
+          </div>`;
+        }
+        return `<div class="flex items-start gap-2 my-2 task-list-item">
+          <div class="${isChecked ? "text-green-600" : "text-gray-400"} flex-shrink-0 mt-0.5">
+            ${isChecked ? checkmark : checkbox}
+          </div>
+          <span${isChecked ? ' class="line-through text-muted-foreground"' : ""}>${content}</span>
+        </div>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/core/paragraph.ts
+var ParagraphExtension = {
+  name: "paragraph",
+  parseRules: [],
+  renderRules: [
+    {
+      type: "paragraph",
+      render: (token) => {
+        if (!token.content) return "";
+        const content = token.content.trim();
+        if (!content) return "";
+        const processedContent = content.includes("<br>") ? content : escapeHtml(content);
+        const format = token.attributes?.format || "html";
+        if (format === "html") {
+          return `<p style="line-height: 1.75; margin-bottom: 16px;">${processedContent}</p>`;
+        }
+        return `<p class="leading-7 mb-4">${processedContent}</p>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/core/text.ts
+var TextExtension = {
+  name: "text",
+  parseRules: [],
+  renderRules: [
+    {
+      type: "text",
+      render: (token) => {
+        if (!token.content) return "";
+        return escapeHtml(token.content);
+      }
+    }
+  ]
+};
+
+// src/extensions/core/strikethrough.ts
+var StrikethroughExtension = {
+  name: "strikethrough",
+  parseRules: [
+    {
+      name: "strikethrough",
+      pattern: /~~((?:(?!~~).)+)~~/,
+      render: (match) => ({
+        type: "strikethrough",
+        content: match[1] || "",
+        raw: match[0] || ""
+      })
+    }
+  ],
+  renderRules: [
+    {
+      type: "strikethrough",
+      render: (token) => {
+        const content = escapeHtml(token.content);
+        const format = token.attributes?.format;
+        if (format === "html") {
+          return `<del style="text-decoration: line-through; color: #6b7280;">${content}</del>`;
+        }
+        return `<del class="line-through text-gray-500">${content}</del>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/core/index.ts
+var CoreExtensions = [
+  TextExtension,
+  HeadingExtension,
+  BoldExtension,
+  ItalicExtension,
+  InlineCodeExtension,
+  CodeBlockExtension,
+  LinkExtension,
+  ImageExtension,
+  ListExtension,
+  TaskListExtension,
+  BlockquoteExtension,
+  HorizontalRuleExtension,
+  StrikethroughExtension,
+  ParagraphExtension,
+  LineBreakExtension
+];
+
+// src/extensions/alert.ts
+var AlertExtension = {
+  name: "alert",
+  parseRules: [
+    {
+      name: "alert",
+      pattern: /:::(\w+)(?: ([^\n]+))?\n([\s\S]*?)\n:::/,
+      render: (match) => {
+        return {
+          type: "alert",
+          content: match[3]?.trim() || "",
+          raw: match[0] || "",
+          attributes: {
+            type: match[1] || "info",
+            title: match[2]?.trim() || ""
+          }
+        };
+      }
+    }
+  ],
+  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 renderedChildren = token.attributes?.renderedChildren;
+        const renderMarkdown = token.attributes?.renderMarkdown;
+        const renderedContent = renderedChildren || (renderMarkdown ? renderMarkdown(token.content) : token.content);
+        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">${renderedContent}</div>
+                </div>`;
+      }
+    }
+  ]
+};
+
+// src/extensions/button.ts
+var ButtonExtension = {
+  name: "button",
+  parseRules: [
+    {
+      name: "button",
+      pattern: /\[button:([^\]]+)\]\(([^)]+)\)(?:\{([^}]+)\})?/,
+      render: (match) => {
+        const options = match[3] ? match[3].split(",").map((opt) => opt.trim()) : [];
+        return {
+          type: "button",
+          content: match[1] || "",
+          raw: match[0] || "",
+          attributes: {
+            href: match[2] || "",
+            style: options.find(
+              (opt) => ["default", "primary", "secondary", "success", "danger", "outline", "ghost"].includes(opt)
+            ) || "primary",
+            size: options.find((opt) => ["sm", "md", "lg"].includes(opt)) || "md",
+            disabled: String(options.includes("disabled")),
+            target: options.includes("self") ? "_self" : "_blank"
+          }
+        };
+      }
+    }
+  ],
+  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 baseClasses = `
+                    inline-flex items-center justify-center font-medium rounded-lg 
+                    transition-all duration-200 ease-out
+                    focus:outline-none focus:ring-2 focus:ring-offset-2
+                    disabled:opacity-50 disabled:cursor-not-allowed disabled:pointer-events-none
+                    transform hover:scale-[1.02] active:scale-[0.98]
+                    shadow-sm hover:shadow-md active:shadow-sm
+                    border border-transparent
+                    relative overflow-hidden
+                    before:absolute before:inset-0 before:rounded-lg
+                    before:bg-gradient-to-br before:from-white/20 before:to-transparent
+                    before:opacity-0 hover:before:opacity-100 before:transition-opacity before:duration-200
+                `.replace(/\s+/g, " ").trim();
+        const sizeClasses = {
+          sm: "px-3 py-1.5 text-sm gap-1.5",
+          md: "px-4 py-2 text-base gap-2",
+          lg: "px-6 py-3 text-lg gap-2.5"
+        };
+        const styleClasses = {
+          default: `
+                        bg-slate-600 text-white border-slate-500
+                        hover:bg-slate-700 hover:border-slate-400
+                        focus:ring-slate-500
+                        shadow-[0_1px_0_0_rgba(255,255,255,0.1)_inset,0_1px_2px_0_rgba(0,0,0,0.1)]
+                        hover:shadow-[0_1px_0_0_rgba(255,255,255,0.15)_inset,0_2px_4px_0_rgba(0,0,0,0.15)]
+                    `,
+          primary: `
+                        bg-blue-600 text-white border-blue-500
+                        hover:bg-blue-700 hover:border-blue-400
+                        focus:ring-blue-500
+                        shadow-[0_1px_0_0_rgba(255,255,255,0.1)_inset,0_1px_2px_0_rgba(0,0,0,0.1)]
+                        hover:shadow-[0_1px_0_0_rgba(255,255,255,0.15)_inset,0_2px_4px_0_rgba(0,0,0,0.15)]
+                    `,
+          secondary: `
+                        bg-gray-600 text-white border-gray-500
+                        hover:bg-gray-700 hover:border-gray-400
+                        focus:ring-gray-500
+                        shadow-[0_1px_0_0_rgba(255,255,255,0.1)_inset,0_1px_2px_0_rgba(0,0,0,0.1)]
+                        hover:shadow-[0_1px_0_0_rgba(255,255,255,0.15)_inset,0_2px_4px_0_rgba(0,0,0,0.15)]
+                    `,
+          success: `
+                        bg-green-600 text-white border-green-500
+                        hover:bg-green-700 hover:border-green-400
+                        focus:ring-green-500
+                        shadow-[0_1px_0_0_rgba(255,255,255,0.1)_inset,0_1px_2px_0_rgba(0,0,0,0.1)]
+                        hover:shadow-[0_1px_0_0_rgba(255,255,255,0.15)_inset,0_2px_4px_0_rgba(0,0,0,0.15)]
+                    `,
+          danger: `
+                        bg-red-600 text-white border-red-500
+                        hover:bg-red-700 hover:border-red-400
+                        focus:ring-red-500
+                        shadow-[0_1px_0_0_rgba(255,255,255,0.1)_inset,0_1px_2px_0_rgba(0,0,0,0.1)]
+                        hover:shadow-[0_1px_0_0_rgba(255,255,255,0.15)_inset,0_2px_4px_0_rgba(0,0,0,0.15)]
+                    `,
+          outline: `
+                        bg-transparent text-blue-600 border-blue-600
+                        hover:bg-blue-50 hover:border-blue-700 hover:text-blue-700
+                        focus:ring-blue-500
+                        shadow-[0_0_0_1px_rgba(59,130,246,0.5)_inset]
+                        hover:shadow-[0_0_0_1px_rgba(29,78,216,0.6)_inset,0_1px_2px_0_rgba(0,0,0,0.05)]
+                    `,
+          ghost: `
+                        bg-transparent text-gray-700 border-transparent
+                        hover:bg-gray-100 hover:text-gray-900
+                        focus:ring-gray-500
+                        shadow-none
+                        hover:shadow-[0_1px_2px_0_rgba(0,0,0,0.05)]
+                    `
+        };
+        const classes = `
+                    ${baseClasses}
+                    ${sizeClasses[size] || sizeClasses.md}
+                    ${styleClasses[style] || styleClasses.primary}
+                `.replace(/\s+/g, " ").trim();
+        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 opacity-75" 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}>
+                    <span class="relative z-10">${token.content}</span>${externalIcon}
+                </a>`;
+      }
+    }
+  ]
+};
+
+// 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.parseTime = 0;
+    this.renderTime = 0;
+    this.lastTokenCount = 0;
+    this.parser = new MarkdownParser(config?.parser);
+    this.renderer = new MarkdownRenderer(config?.renderer);
+    this.parseCache = new LRUCache(100);
+    this.renderCache = new LRUCache(100);
+    this.registerCoreExtensions();
+    this.registerFeatureExtensions();
+    if (config?.extensions) {
+      config.extensions.forEach((extension) => {
+        this.registerExtension(extension);
+      });
+    }
+  }
+  registerFeatureExtensions() {
+    this.registerExtension(AlertExtension);
+    this.registerExtension(ButtonExtension);
+    this.registerExtension(EmbedExtension);
+  }
+  registerCoreExtensions() {
+    CoreExtensions.forEach((extension) => {
+      this.registerExtension(extension);
+    });
+  }
+  registerExtension(extension) {
+    try {
+      if (!extension.name || typeof extension.name !== "string") {
+        throw new Error("Extension must have a valid name");
+      }
+      if (!Array.isArray(extension.parseRules)) {
+        throw new Error("Extension must have parseRules array");
+      }
+      if (!Array.isArray(extension.renderRules)) {
+        throw new Error("Extension must have renderRules array");
+      }
+      extension.parseRules.forEach((rule, index) => {
+        if (!rule.name || typeof rule.name !== "string") {
+          throw new Error(`Parse rule ${index} must have a valid name`);
+        }
+        if (!rule.pattern || !(rule.pattern instanceof RegExp)) {
+          throw new Error(`Parse rule ${index} must have a valid RegExp pattern`);
+        }
+        if (!rule.render || typeof rule.render !== "function") {
+          throw new Error(`Parse rule ${index} must have a valid render function`);
+        }
+      });
+      extension.renderRules.forEach((rule, index) => {
+        if (!rule.type || typeof rule.type !== "string") {
+          throw new Error(`Render rule ${index} must have a valid type`);
+        }
+        if (!rule.render || typeof rule.render !== "function") {
+          throw new Error(`Render rule ${index} must have a valid render function`);
+        }
+      });
+      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
+      };
+    }
+  }
+  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(markdown2) {
+    const cacheKey = hashContent(markdown2);
+    const cached = this.parseCache.get(cacheKey);
+    if (cached) {
+      this.lastTokenCount = cached.length;
+      return cached;
+    }
+    const startTime = performance.now();
+    const tokens = this.parser.parse(markdown2);
+    this.parseTime = performance.now() - startTime;
+    this.lastTokenCount = tokens.length;
+    this.parseCache.set(cacheKey, tokens);
+    return tokens;
+  }
+  render(tokens, cacheKey) {
+    if (cacheKey) {
+      const cached = this.renderCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    const startTime = performance.now();
+    const html = this.renderer.render(tokens);
+    this.renderTime = performance.now() - startTime;
+    if (cacheKey) {
+      this.renderCache.set(cacheKey, html);
+    }
+    return html;
+  }
+  toHtml(markdown2) {
+    const cacheKey = hashContent(markdown2);
+    const cachedHtml = this.renderCache.get(cacheKey);
+    if (cachedHtml) {
+      return cachedHtml;
+    }
+    const tokens = this.parse(markdown2);
+    return this.render(tokens, cacheKey);
+  }
+  /**
+   * Render markdown with performance metrics
+   */
+  toHtmlWithMetrics(markdown2) {
+    const startTotal = performance.now();
+    const parseCacheKey = hashContent(markdown2);
+    const parseCacheHit = this.parseCache.has(parseCacheKey);
+    const html = this.toHtml(markdown2);
+    const totalTime = performance.now() - startTotal;
+    const metrics = {
+      inputSize: markdown2.length,
+      parseTime: this.parseTime,
+      renderTime: this.renderTime,
+      totalTime,
+      tokenCount: this.lastTokenCount,
+      cacheHit: parseCacheHit
+    };
+    return { html, metrics };
+  }
+  /**
+   * Stream-render large documents in chunks for better performance
+   */
+  async toHtmlStreamed(markdown2, options = {}) {
+    const chunkSize = options.chunkSize || 50;
+    const tokens = this.parse(markdown2);
+    const totalTokens = tokens.length;
+    const chunks = [];
+    for (let i = 0; i < tokens.length; i += chunkSize) {
+      const chunkTokens = tokens.slice(i, Math.min(i + chunkSize, tokens.length));
+      const chunkHtml = this.render(chunkTokens);
+      chunks.push(chunkHtml);
+      if (options.onChunk) {
+        options.onChunk({
+          html: chunkHtml,
+          progress: Math.min(i + chunkSize, tokens.length) / totalTokens
+        });
+      }
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    return chunks.join("");
+  }
+  getExtensions() {
+    return Array.from(this.extensions.keys());
+  }
+  hasExtension(name) {
+    return this.extensions.has(name);
+  }
+  getWarnings() {
+    return [...this.parser.getWarnings(), ...this.renderer.getWarnings()];
+  }
+  getDebugInfo() {
+    return {
+      warnings: this.getWarnings(),
+      parseTime: this.parseTime,
+      renderTime: this.renderTime,
+      tokenCount: this.lastTokenCount,
+      iterationCount: 0
+    };
+  }
+  getPerformanceMetrics() {
+    return {
+      parseTime: this.parseTime,
+      renderTime: this.renderTime,
+      totalTime: this.parseTime + this.renderTime,
+      tokenCount: this.lastTokenCount
+    };
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      parse: this.parseCache.getStats(),
+      render: this.renderCache.getStats()
+    };
+  }
+  /**
+   * Clear all caches
+   */
+  clearCaches() {
+    this.parseCache.clear();
+    this.renderCache.clear();
+  }
+  /**
+   * Update cache capacity
+   */
+  setCacheSize(size) {
+    this.parseCache.setCapacity(size);
+    this.renderCache.setCapacity(size);
+  }
+  rebuildParserAndRenderer() {
+    const parserConfig = this.parser.getConfig();
+    const rendererConfig = this.renderer.getConfig();
+    this.parser = new MarkdownParser(parserConfig);
+    this.renderer = new MarkdownRenderer(rendererConfig);
+    this.parseCache.clear();
+    this.renderCache.clear();
+    const extensionsToRegister = Array.from(this.extensions.values());
+    const featureExtensions = extensionsToRegister.filter(
+      (ext) => ["alert", "button", "embed"].includes(ext.name)
+    );
+    const coreExtensions = extensionsToRegister.filter(
+      (ext) => ["text", "heading", "bold", "italic", "code", "codeblock", "link", "image", "list", "task-list", "blockquote", "hr", "paragraph", "line-break"].includes(ext.name)
+    );
+    const customExtensions = extensionsToRegister.filter(
+      (ext) => !["alert", "button", "embed", "text", "heading", "bold", "italic", "code", "codeblock", "link", "image", "list", "task-list", "blockquote", "hr", "paragraph", "line-break"].includes(ext.name)
+    );
+    [...featureExtensions, ...coreExtensions, ...customExtensions].forEach((extension) => {
+      extension.parseRules.forEach((rule) => {
+        this.parser.addRule(rule);
+      });
+      extension.renderRules.forEach((rule) => {
+        this.renderer.addRule(rule);
+      });
+    });
+  }
+};
+var markdown = new ChangerawrMarkdown();
+
+// src/outputs/html.ts
+function renderToHTML(markdown2, config) {
+  const engine = new ChangerawrMarkdown({
+    ...config,
+    renderer: {
+      format: "html",
+      sanitize: true,
+      allowUnsafeHtml: false
+    }
+  });
+  return engine.toHtml(markdown2);
+}
+function renderToHTMLWithConfig(markdown2, rendererConfig) {
+  const engine = new ChangerawrMarkdown({
+    renderer: {
+      format: "html",
+      ...rendererConfig
+    }
+  });
+  return engine.toHtml(markdown2);
+}
+
+// src/outputs/tailwind.ts
+function renderToTailwind(markdown2, config) {
+  const engine = new ChangerawrMarkdown({
+    ...config,
+    renderer: {
+      format: "tailwind",
+      sanitize: true,
+      allowUnsafeHtml: false
+    }
+  });
+  return engine.toHtml(markdown2);
+}
+function renderToTailwindWithConfig(markdown2, rendererConfig) {
+  const engine = new ChangerawrMarkdown({
+    renderer: {
+      format: "tailwind",
+      ...rendererConfig
+    }
+  });
+  return engine.toHtml(markdown2);
+}
+
+// src/astro/index.ts
+function renderMarkdownForAstro(content, options = {}) {
+  const { format = "html", config, extensions } = options;
+  const engineConfig = {
+    renderer: {
+      sanitize: true,
+      ...config?.renderer ?? {},
+      format
+    }
+  };
+  if (config?.parser) engineConfig.parser = config.parser;
+  const engine = new ChangerawrMarkdown(engineConfig);
+  if (extensions) {
+    extensions.forEach((ext) => engine.registerExtension(ext));
+  }
+  return engine.toHtml(content);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChangerawrMarkdown,
+  renderMarkdownForAstro,
+  renderToHTML,
+  renderToHTMLWithConfig,
+  renderToTailwind,
+  renderToTailwindWithConfig
+});
+//# sourceMappingURL=index.js.map