@changerawr/markdown 1.0.4 → 1.1.0

package/dist/standalone.browser.js

@@ -0,0 +1,2722 @@
+"use strict";
+var ChangerawrMarkdown = (() => {
+  var __defProp = Object.defineProperty;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // node_modules/dompurify/dist/purify.es.mjs
+  var purify_es_exports = {};
+  __export(purify_es_exports, {
+    default: () => purify
+  });
+  function unapply(func) {
+    return function(thisArg) {
+      if (thisArg instanceof RegExp) {
+        thisArg.lastIndex = 0;
+      }
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      return apply(func, thisArg, args);
+    };
+  }
+  function unconstruct(func) {
+    return function() {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return construct(func, args);
+    };
+  }
+  function addToSet(set, array) {
+    let transformCaseFunc = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : stringToLowerCase;
+    if (setPrototypeOf) {
+      setPrototypeOf(set, null);
+    }
+    let l = array.length;
+    while (l--) {
+      let element = array[l];
+      if (typeof element === "string") {
+        const lcElement = transformCaseFunc(element);
+        if (lcElement !== element) {
+          if (!isFrozen(array)) {
+            array[l] = lcElement;
+          }
+          element = lcElement;
+        }
+      }
+      set[element] = true;
+    }
+    return set;
+  }
+  function cleanArray(array) {
+    for (let index = 0; index < array.length; index++) {
+      const isPropertyExist = objectHasOwnProperty(array, index);
+      if (!isPropertyExist) {
+        array[index] = null;
+      }
+    }
+    return array;
+  }
+  function clone(object) {
+    const newObject = create(null);
+    for (const [property, value] of entries(object)) {
+      const isPropertyExist = objectHasOwnProperty(object, property);
+      if (isPropertyExist) {
+        if (Array.isArray(value)) {
+          newObject[property] = cleanArray(value);
+        } else if (value && typeof value === "object" && value.constructor === Object) {
+          newObject[property] = clone(value);
+        } else {
+          newObject[property] = value;
+        }
+      }
+    }
+    return newObject;
+  }
+  function lookupGetter(object, prop) {
+    while (object !== null) {
+      const desc = getOwnPropertyDescriptor(object, prop);
+      if (desc) {
+        if (desc.get) {
+          return unapply(desc.get);
+        }
+        if (typeof desc.value === "function") {
+          return unapply(desc.value);
+        }
+      }
+      object = getPrototypeOf(object);
+    }
+    function fallbackValue() {
+      return null;
+    }
+    return fallbackValue;
+  }
+  function createDOMPurify() {
+    let window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
+    const DOMPurify2 = (root) => createDOMPurify(root);
+    DOMPurify2.version = "3.2.6";
+    DOMPurify2.removed = [];
+    if (!window2 || !window2.document || window2.document.nodeType !== NODE_TYPE.document || !window2.Element) {
+      DOMPurify2.isSupported = false;
+      return DOMPurify2;
+    }
+    let {
+      document: document2
+    } = window2;
+    const originalDocument = document2;
+    const currentScript = originalDocument.currentScript;
+    const {
+      DocumentFragment,
+      HTMLTemplateElement,
+      Node,
+      Element,
+      NodeFilter,
+      NamedNodeMap = window2.NamedNodeMap || window2.MozNamedAttrMap,
+      HTMLFormElement,
+      DOMParser,
+      trustedTypes
+    } = window2;
+    const ElementPrototype = Element.prototype;
+    const cloneNode = lookupGetter(ElementPrototype, "cloneNode");
+    const remove = lookupGetter(ElementPrototype, "remove");
+    const getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
+    const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
+    const getParentNode = lookupGetter(ElementPrototype, "parentNode");
+    if (typeof HTMLTemplateElement === "function") {
+      const template = document2.createElement("template");
+      if (template.content && template.content.ownerDocument) {
+        document2 = template.content.ownerDocument;
+      }
+    }
+    let trustedTypesPolicy;
+    let emptyHTML = "";
+    const {
+      implementation,
+      createNodeIterator,
+      createDocumentFragment,
+      getElementsByTagName
+    } = document2;
+    const {
+      importNode
+    } = originalDocument;
+    let hooks = _createHooksMap();
+    DOMPurify2.isSupported = typeof entries === "function" && typeof getParentNode === "function" && implementation && implementation.createHTMLDocument !== void 0;
+    const {
+      MUSTACHE_EXPR: MUSTACHE_EXPR2,
+      ERB_EXPR: ERB_EXPR2,
+      TMPLIT_EXPR: TMPLIT_EXPR2,
+      DATA_ATTR: DATA_ATTR2,
+      ARIA_ATTR: ARIA_ATTR2,
+      IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA2,
+      ATTR_WHITESPACE: ATTR_WHITESPACE2,
+      CUSTOM_ELEMENT: CUSTOM_ELEMENT2
+    } = EXPRESSIONS;
+    let {
+      IS_ALLOWED_URI: IS_ALLOWED_URI$1
+    } = EXPRESSIONS;
+    let ALLOWED_TAGS2 = null;
+    const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
+    let ALLOWED_ATTR2 = null;
+    const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
+    let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {
+      tagNameCheck: {
+        writable: true,
+        configurable: false,
+        enumerable: true,
+        value: null
+      },
+      attributeNameCheck: {
+        writable: true,
+        configurable: false,
+        enumerable: true,
+        value: null
+      },
+      allowCustomizedBuiltInElements: {
+        writable: true,
+        configurable: false,
+        enumerable: true,
+        value: false
+      }
+    }));
+    let FORBID_TAGS = null;
+    let FORBID_ATTR = null;
+    let ALLOW_ARIA_ATTR = true;
+    let ALLOW_DATA_ATTR = true;
+    let ALLOW_UNKNOWN_PROTOCOLS = false;
+    let ALLOW_SELF_CLOSE_IN_ATTR = true;
+    let SAFE_FOR_TEMPLATES = false;
+    let SAFE_FOR_XML = true;
+    let WHOLE_DOCUMENT = false;
+    let SET_CONFIG = false;
+    let FORCE_BODY = false;
+    let RETURN_DOM = false;
+    let RETURN_DOM_FRAGMENT = false;
+    let RETURN_TRUSTED_TYPE = false;
+    let SANITIZE_DOM = true;
+    let SANITIZE_NAMED_PROPS = false;
+    const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
+    let KEEP_CONTENT = true;
+    let IN_PLACE = false;
+    let USE_PROFILES = {};
+    let FORBID_CONTENTS = null;
+    const DEFAULT_FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
+    let DATA_URI_TAGS = null;
+    const DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]);
+    let URI_SAFE_ATTRIBUTES = null;
+    const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]);
+    const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+    const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+    const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+    let NAMESPACE = HTML_NAMESPACE;
+    let IS_EMPTY_INPUT = false;
+    let ALLOWED_NAMESPACES = null;
+    const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
+    let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
+    let HTML_INTEGRATION_POINTS = addToSet({}, ["annotation-xml"]);
+    const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ["title", "style", "font", "a", "script"]);
+    let PARSER_MEDIA_TYPE = null;
+    const SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
+    const DEFAULT_PARSER_MEDIA_TYPE = "text/html";
+    let transformCaseFunc = null;
+    let CONFIG = null;
+    const formElement = document2.createElement("form");
+    const isRegexOrFunction = function isRegexOrFunction2(testValue) {
+      return testValue instanceof RegExp || testValue instanceof Function;
+    };
+    const _parseConfig = function _parseConfig2() {
+      let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      if (CONFIG && CONFIG === cfg) {
+        return;
+      }
+      if (!cfg || typeof cfg !== "object") {
+        cfg = {};
+      }
+      cfg = clone(cfg);
+      PARSER_MEDIA_TYPE = // eslint-disable-next-line unicorn/prefer-includes
+      SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
+      transformCaseFunc = PARSER_MEDIA_TYPE === "application/xhtml+xml" ? stringToString : stringToLowerCase;
+      ALLOWED_TAGS2 = objectHasOwnProperty(cfg, "ALLOWED_TAGS") ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
+      ALLOWED_ATTR2 = objectHasOwnProperty(cfg, "ALLOWED_ATTR") ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
+      ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, "ALLOWED_NAMESPACES") ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
+      URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+      DATA_URI_TAGS = objectHasOwnProperty(cfg, "ADD_DATA_URI_TAGS") ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
+      FORBID_CONTENTS = objectHasOwnProperty(cfg, "FORBID_CONTENTS") ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
+      FORBID_TAGS = objectHasOwnProperty(cfg, "FORBID_TAGS") ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone({});
+      FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone({});
+      USE_PROFILES = objectHasOwnProperty(cfg, "USE_PROFILES") ? cfg.USE_PROFILES : false;
+      ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
+      ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
+      ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false;
+      ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false;
+      SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false;
+      SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false;
+      WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false;
+      RETURN_DOM = cfg.RETURN_DOM || false;
+      RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false;
+      RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false;
+      FORCE_BODY = cfg.FORCE_BODY || false;
+      SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
+      SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false;
+      KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
+      IN_PLACE = cfg.IN_PLACE || false;
+      IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
+      NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+      MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
+      HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
+      CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
+      if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
+        CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+      }
+      if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
+        CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
+      }
+      if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === "boolean") {
+        CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
+      }
+      if (SAFE_FOR_TEMPLATES) {
+        ALLOW_DATA_ATTR = false;
+      }
+      if (RETURN_DOM_FRAGMENT) {
+        RETURN_DOM = true;
+      }
+      if (USE_PROFILES) {
+        ALLOWED_TAGS2 = addToSet({}, text);
+        ALLOWED_ATTR2 = [];
+        if (USE_PROFILES.html === true) {
+          addToSet(ALLOWED_TAGS2, html$1);
+          addToSet(ALLOWED_ATTR2, html);
+        }
+        if (USE_PROFILES.svg === true) {
+          addToSet(ALLOWED_TAGS2, svg$1);
+          addToSet(ALLOWED_ATTR2, svg);
+          addToSet(ALLOWED_ATTR2, xml);
+        }
+        if (USE_PROFILES.svgFilters === true) {
+          addToSet(ALLOWED_TAGS2, svgFilters);
+          addToSet(ALLOWED_ATTR2, svg);
+          addToSet(ALLOWED_ATTR2, xml);
+        }
+        if (USE_PROFILES.mathMl === true) {
+          addToSet(ALLOWED_TAGS2, mathMl$1);
+          addToSet(ALLOWED_ATTR2, mathMl);
+          addToSet(ALLOWED_ATTR2, xml);
+        }
+      }
+      if (cfg.ADD_TAGS) {
+        if (ALLOWED_TAGS2 === DEFAULT_ALLOWED_TAGS) {
+          ALLOWED_TAGS2 = clone(ALLOWED_TAGS2);
+        }
+        addToSet(ALLOWED_TAGS2, cfg.ADD_TAGS, transformCaseFunc);
+      }
+      if (cfg.ADD_ATTR) {
+        if (ALLOWED_ATTR2 === DEFAULT_ALLOWED_ATTR) {
+          ALLOWED_ATTR2 = clone(ALLOWED_ATTR2);
+        }
+        addToSet(ALLOWED_ATTR2, cfg.ADD_ATTR, transformCaseFunc);
+      }
+      if (cfg.ADD_URI_SAFE_ATTR) {
+        addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
+      }
+      if (cfg.FORBID_CONTENTS) {
+        if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+          FORBID_CONTENTS = clone(FORBID_CONTENTS);
+        }
+        addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
+      }
+      if (KEEP_CONTENT) {
+        ALLOWED_TAGS2["#text"] = true;
+      }
+      if (WHOLE_DOCUMENT) {
+        addToSet(ALLOWED_TAGS2, ["html", "head", "body"]);
+      }
+      if (ALLOWED_TAGS2.table) {
+        addToSet(ALLOWED_TAGS2, ["tbody"]);
+        delete FORBID_TAGS.tbody;
+      }
+      if (cfg.TRUSTED_TYPES_POLICY) {
+        if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== "function") {
+          throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+        }
+        if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== "function") {
+          throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+        }
+        trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
+        emptyHTML = trustedTypesPolicy.createHTML("");
+      } else {
+        if (trustedTypesPolicy === void 0) {
+          trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+        }
+        if (trustedTypesPolicy !== null && typeof emptyHTML === "string") {
+          emptyHTML = trustedTypesPolicy.createHTML("");
+        }
+      }
+      if (freeze) {
+        freeze(cfg);
+      }
+      CONFIG = cfg;
+    };
+    const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
+    const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
+    const _checkValidNamespace = function _checkValidNamespace2(element) {
+      let parent = getParentNode(element);
+      if (!parent || !parent.tagName) {
+        parent = {
+          namespaceURI: NAMESPACE,
+          tagName: "template"
+        };
+      }
+      const tagName = stringToLowerCase(element.tagName);
+      const parentTagName = stringToLowerCase(parent.tagName);
+      if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
+        return false;
+      }
+      if (element.namespaceURI === SVG_NAMESPACE) {
+        if (parent.namespaceURI === HTML_NAMESPACE) {
+          return tagName === "svg";
+        }
+        if (parent.namespaceURI === MATHML_NAMESPACE) {
+          return tagName === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+        }
+        return Boolean(ALL_SVG_TAGS[tagName]);
+      }
+      if (element.namespaceURI === MATHML_NAMESPACE) {
+        if (parent.namespaceURI === HTML_NAMESPACE) {
+          return tagName === "math";
+        }
+        if (parent.namespaceURI === SVG_NAMESPACE) {
+          return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
+        }
+        return Boolean(ALL_MATHML_TAGS[tagName]);
+      }
+      if (element.namespaceURI === HTML_NAMESPACE) {
+        if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+          return false;
+        }
+        if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+          return false;
+        }
+        return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+      }
+      if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) {
+        return true;
+      }
+      return false;
+    };
+    const _forceRemove = function _forceRemove2(node) {
+      arrayPush(DOMPurify2.removed, {
+        element: node
+      });
+      try {
+        getParentNode(node).removeChild(node);
+      } catch (_) {
+        remove(node);
+      }
+    };
+    const _removeAttribute = function _removeAttribute2(name, element) {
+      try {
+        arrayPush(DOMPurify2.removed, {
+          attribute: element.getAttributeNode(name),
+          from: element
+        });
+      } catch (_) {
+        arrayPush(DOMPurify2.removed, {
+          attribute: null,
+          from: element
+        });
+      }
+      element.removeAttribute(name);
+      if (name === "is") {
+        if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+          try {
+            _forceRemove(element);
+          } catch (_) {
+          }
+        } else {
+          try {
+            element.setAttribute(name, "");
+          } catch (_) {
+          }
+        }
+      }
+    };
+    const _initDocument = function _initDocument2(dirty) {
+      let doc = null;
+      let leadingWhitespace = null;
+      if (FORCE_BODY) {
+        dirty = "<remove></remove>" + dirty;
+      } else {
+        const matches = stringMatch(dirty, /^[\r\n\t ]+/);
+        leadingWhitespace = matches && matches[0];
+      }
+      if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && NAMESPACE === HTML_NAMESPACE) {
+        dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + "</body></html>";
+      }
+      const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+      if (NAMESPACE === HTML_NAMESPACE) {
+        try {
+          doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+        } catch (_) {
+        }
+      }
+      if (!doc || !doc.documentElement) {
+        doc = implementation.createDocument(NAMESPACE, "template", null);
+        try {
+          doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
+        } catch (_) {
+        }
+      }
+      const body = doc.body || doc.documentElement;
+      if (dirty && leadingWhitespace) {
+        body.insertBefore(document2.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+      }
+      if (NAMESPACE === HTML_NAMESPACE) {
+        return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0];
+      }
+      return WHOLE_DOCUMENT ? doc.documentElement : body;
+    };
+    const _createNodeIterator = function _createNodeIterator2(root) {
+      return createNodeIterator.call(
+        root.ownerDocument || root,
+        root,
+        // eslint-disable-next-line no-bitwise
+        NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION,
+        null
+      );
+    };
+    const _isClobbered = function _isClobbered2(element) {
+      return element instanceof HTMLFormElement && (typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function");
+    };
+    const _isNode = function _isNode2(value) {
+      return typeof Node === "function" && value instanceof Node;
+    };
+    function _executeHooks(hooks2, currentNode, data) {
+      arrayForEach(hooks2, (hook) => {
+        hook.call(DOMPurify2, currentNode, data, CONFIG);
+      });
+    }
+    const _sanitizeElements = function _sanitizeElements2(currentNode) {
+      let content = null;
+      _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+      if (_isClobbered(currentNode)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+      const tagName = transformCaseFunc(currentNode.nodeName);
+      _executeHooks(hooks.uponSanitizeElement, currentNode, {
+        tagName,
+        allowedTags: ALLOWED_TAGS2
+      });
+      if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+      if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
+        _forceRemove(currentNode);
+        return true;
+      }
+      if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+      if (!ALLOWED_TAGS2[tagName] || FORBID_TAGS[tagName]) {
+        if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
+          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
+            return false;
+          }
+          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
+            return false;
+          }
+        }
+        if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+          const parentNode = getParentNode(currentNode) || currentNode.parentNode;
+          const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+          if (childNodes && parentNode) {
+            const childCount = childNodes.length;
+            for (let i = childCount - 1; i >= 0; --i) {
+              const childClone = cloneNode(childNodes[i], true);
+              childClone.__removalCount = (currentNode.__removalCount || 0) + 1;
+              parentNode.insertBefore(childClone, getNextSibling(currentNode));
+            }
+          }
+        }
+        _forceRemove(currentNode);
+        return true;
+      }
+      if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+      if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+      if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
+        content = currentNode.textContent;
+        arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+          content = stringReplace(content, expr, " ");
+        });
+        if (currentNode.textContent !== content) {
+          arrayPush(DOMPurify2.removed, {
+            element: currentNode.cloneNode()
+          });
+          currentNode.textContent = content;
+        }
+      }
+      _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+      return false;
+    };
+    const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
+      if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) {
+        return false;
+      }
+      if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR2, lcName)) ;
+      else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR2, lcName)) ;
+      else if (!ALLOWED_ATTR2[lcName] || FORBID_ATTR[lcName]) {
+        if (
+          // First condition does a very basic check if a) it's basically a valid custom element tagname AND
+          // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+          // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
+          _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) || // Alternative, second condition checks if it's an `is`-attribute, AND
+          // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+          lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))
+        ) ;
+        else {
+          return false;
+        }
+      } else if (URI_SAFE_ATTRIBUTES[lcName]) ;
+      else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE2, ""))) ;
+      else if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]) ;
+      else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA2, stringReplace(value, ATTR_WHITESPACE2, ""))) ;
+      else if (value) {
+        return false;
+      } else ;
+      return true;
+    };
+    const _isBasicCustomElement = function _isBasicCustomElement2(tagName) {
+      return tagName !== "annotation-xml" && stringMatch(tagName, CUSTOM_ELEMENT2);
+    };
+    const _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
+      _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
+      const {
+        attributes
+      } = currentNode;
+      if (!attributes || _isClobbered(currentNode)) {
+        return;
+      }
+      const hookEvent = {
+        attrName: "",
+        attrValue: "",
+        keepAttr: true,
+        allowedAttributes: ALLOWED_ATTR2,
+        forceKeepAttr: void 0
+      };
+      let l = attributes.length;
+      while (l--) {
+        const attr = attributes[l];
+        const {
+          name,
+          namespaceURI,
+          value: attrValue
+        } = attr;
+        const lcName = transformCaseFunc(name);
+        const initValue = attrValue;
+        let value = name === "value" ? initValue : stringTrim(initValue);
+        hookEvent.attrName = lcName;
+        hookEvent.attrValue = value;
+        hookEvent.keepAttr = true;
+        hookEvent.forceKeepAttr = void 0;
+        _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
+        value = hookEvent.attrValue;
+        if (SANITIZE_NAMED_PROPS && (lcName === "id" || lcName === "name")) {
+          _removeAttribute(name, currentNode);
+          value = SANITIZE_NAMED_PROPS_PREFIX + value;
+        }
+        if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title)/i, value)) {
+          _removeAttribute(name, currentNode);
+          continue;
+        }
+        if (hookEvent.forceKeepAttr) {
+          continue;
+        }
+        if (!hookEvent.keepAttr) {
+          _removeAttribute(name, currentNode);
+          continue;
+        }
+        if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
+          _removeAttribute(name, currentNode);
+          continue;
+        }
+        if (SAFE_FOR_TEMPLATES) {
+          arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+            value = stringReplace(value, expr, " ");
+          });
+        }
+        const lcTag = transformCaseFunc(currentNode.nodeName);
+        if (!_isValidAttribute(lcTag, lcName, value)) {
+          _removeAttribute(name, currentNode);
+          continue;
+        }
+        if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") {
+          if (namespaceURI) ;
+          else {
+            switch (trustedTypes.getAttributeType(lcTag, lcName)) {
+              case "TrustedHTML": {
+                value = trustedTypesPolicy.createHTML(value);
+                break;
+              }
+              case "TrustedScriptURL": {
+                value = trustedTypesPolicy.createScriptURL(value);
+                break;
+              }
+            }
+          }
+        }
+        if (value !== initValue) {
+          try {
+            if (namespaceURI) {
+              currentNode.setAttributeNS(namespaceURI, name, value);
+            } else {
+              currentNode.setAttribute(name, value);
+            }
+            if (_isClobbered(currentNode)) {
+              _forceRemove(currentNode);
+            } else {
+              arrayPop(DOMPurify2.removed);
+            }
+          } catch (_) {
+            _removeAttribute(name, currentNode);
+          }
+        }
+      }
+      _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
+    };
+    const _sanitizeShadowDOM = function _sanitizeShadowDOM2(fragment) {
+      let shadowNode = null;
+      const shadowIterator = _createNodeIterator(fragment);
+      _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
+      while (shadowNode = shadowIterator.nextNode()) {
+        _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
+        _sanitizeElements(shadowNode);
+        _sanitizeAttributes(shadowNode);
+        if (shadowNode.content instanceof DocumentFragment) {
+          _sanitizeShadowDOM2(shadowNode.content);
+        }
+      }
+      _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
+    };
+    DOMPurify2.sanitize = function(dirty) {
+      let cfg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      let body = null;
+      let importedNode = null;
+      let currentNode = null;
+      let returnNode = null;
+      IS_EMPTY_INPUT = !dirty;
+      if (IS_EMPTY_INPUT) {
+        dirty = "<!-->";
+      }
+      if (typeof dirty !== "string" && !_isNode(dirty)) {
+        if (typeof dirty.toString === "function") {
+          dirty = dirty.toString();
+          if (typeof dirty !== "string") {
+            throw typeErrorCreate("dirty is not a string, aborting");
+          }
+        } else {
+          throw typeErrorCreate("toString is not a function");
+        }
+      }
+      if (!DOMPurify2.isSupported) {
+        return dirty;
+      }
+      if (!SET_CONFIG) {
+        _parseConfig(cfg);
+      }
+      DOMPurify2.removed = [];
+      if (typeof dirty === "string") {
+        IN_PLACE = false;
+      }
+      if (IN_PLACE) {
+        if (dirty.nodeName) {
+          const tagName = transformCaseFunc(dirty.nodeName);
+          if (!ALLOWED_TAGS2[tagName] || FORBID_TAGS[tagName]) {
+            throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
+          }
+        }
+      } else if (dirty instanceof Node) {
+        body = _initDocument("<!---->");
+        importedNode = body.ownerDocument.importNode(dirty, true);
+        if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === "BODY") {
+          body = importedNode;
+        } else if (importedNode.nodeName === "HTML") {
+          body = importedNode;
+        } else {
+          body.appendChild(importedNode);
+        }
+      } else {
+        if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && // eslint-disable-next-line unicorn/prefer-includes
+        dirty.indexOf("<") === -1) {
+          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+        }
+        body = _initDocument(dirty);
+        if (!body) {
+          return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
+        }
+      }
+      if (body && FORCE_BODY) {
+        _forceRemove(body.firstChild);
+      }
+      const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
+      while (currentNode = nodeIterator.nextNode()) {
+        _sanitizeElements(currentNode);
+        _sanitizeAttributes(currentNode);
+        if (currentNode.content instanceof DocumentFragment) {
+          _sanitizeShadowDOM(currentNode.content);
+        }
+      }
+      if (IN_PLACE) {
+        return dirty;
+      }
+      if (RETURN_DOM) {
+        if (RETURN_DOM_FRAGMENT) {
+          returnNode = createDocumentFragment.call(body.ownerDocument);
+          while (body.firstChild) {
+            returnNode.appendChild(body.firstChild);
+          }
+        } else {
+          returnNode = body;
+        }
+        if (ALLOWED_ATTR2.shadowroot || ALLOWED_ATTR2.shadowrootmode) {
+          returnNode = importNode.call(originalDocument, returnNode, true);
+        }
+        return returnNode;
+      }
+      let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+      if (WHOLE_DOCUMENT && ALLOWED_TAGS2["!doctype"] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
+        serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
+      }
+      if (SAFE_FOR_TEMPLATES) {
+        arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+          serializedHTML = stringReplace(serializedHTML, expr, " ");
+        });
+      }
+      return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+    };
+    DOMPurify2.setConfig = function() {
+      let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      _parseConfig(cfg);
+      SET_CONFIG = true;
+    };
+    DOMPurify2.clearConfig = function() {
+      CONFIG = null;
+      SET_CONFIG = false;
+    };
+    DOMPurify2.isValidAttribute = function(tag, attr, value) {
+      if (!CONFIG) {
+        _parseConfig({});
+      }
+      const lcTag = transformCaseFunc(tag);
+      const lcName = transformCaseFunc(attr);
+      return _isValidAttribute(lcTag, lcName, value);
+    };
+    DOMPurify2.addHook = function(entryPoint, hookFunction) {
+      if (typeof hookFunction !== "function") {
+        return;
+      }
+      arrayPush(hooks[entryPoint], hookFunction);
+    };
+    DOMPurify2.removeHook = function(entryPoint, hookFunction) {
+      if (hookFunction !== void 0) {
+        const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+        return index === -1 ? void 0 : arraySplice(hooks[entryPoint], index, 1)[0];
+      }
+      return arrayPop(hooks[entryPoint]);
+    };
+    DOMPurify2.removeHooks = function(entryPoint) {
+      hooks[entryPoint] = [];
+    };
+    DOMPurify2.removeAllHooks = function() {
+      hooks = _createHooksMap();
+    };
+    return DOMPurify2;
+  }
+  var entries, setPrototypeOf, isFrozen, getPrototypeOf, getOwnPropertyDescriptor, freeze, seal, create, apply, construct, arrayForEach, arrayLastIndexOf, arrayPop, arrayPush, arraySplice, stringToLowerCase, stringToString, stringMatch, stringReplace, stringIndexOf, stringTrim, objectHasOwnProperty, regExpTest, typeErrorCreate, html$1, svg$1, svgFilters, svgDisallowed, mathMl$1, mathMlDisallowed, text, html, svg, mathMl, xml, MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR, DATA_ATTR, ARIA_ATTR, IS_ALLOWED_URI, IS_SCRIPT_OR_DATA, ATTR_WHITESPACE, DOCTYPE_NAME, CUSTOM_ELEMENT, EXPRESSIONS, NODE_TYPE, getGlobal, _createTrustedTypesPolicy, _createHooksMap, purify;
+  var init_purify_es = __esm({
+    "node_modules/dompurify/dist/purify.es.mjs"() {
+      "use strict";
+      ({
+        entries,
+        setPrototypeOf,
+        isFrozen,
+        getPrototypeOf,
+        getOwnPropertyDescriptor
+      } = Object);
+      ({
+        freeze,
+        seal,
+        create
+      } = Object);
+      ({
+        apply,
+        construct
+      } = typeof Reflect !== "undefined" && Reflect);
+      if (!freeze) {
+        freeze = function freeze2(x) {
+          return x;
+        };
+      }
+      if (!seal) {
+        seal = function seal2(x) {
+          return x;
+        };
+      }
+      if (!apply) {
+        apply = function apply2(fun, thisValue, args) {
+          return fun.apply(thisValue, args);
+        };
+      }
+      if (!construct) {
+        construct = function construct2(Func, args) {
+          return new Func(...args);
+        };
+      }
+      arrayForEach = unapply(Array.prototype.forEach);
+      arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
+      arrayPop = unapply(Array.prototype.pop);
+      arrayPush = unapply(Array.prototype.push);
+      arraySplice = unapply(Array.prototype.splice);
+      stringToLowerCase = unapply(String.prototype.toLowerCase);
+      stringToString = unapply(String.prototype.toString);
+      stringMatch = unapply(String.prototype.match);
+      stringReplace = unapply(String.prototype.replace);
+      stringIndexOf = unapply(String.prototype.indexOf);
+      stringTrim = unapply(String.prototype.trim);
+      objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
+      regExpTest = unapply(RegExp.prototype.test);
+      typeErrorCreate = unconstruct(TypeError);
+      html$1 = freeze(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "section", "select", "shadow", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]);
+      svg$1 = freeze(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]);
+      svgFilters = freeze(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]);
+      svgDisallowed = freeze(["animate", "color-profile", "cursor", "discard", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]);
+      mathMl$1 = freeze(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "mprescripts"]);
+      mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]);
+      text = freeze(["#text"]);
+      html = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "wrap", "xmlns", "slot"]);
+      svg = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "exponent", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "intercept", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "slope", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "tablevalues", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]);
+      mathMl = freeze(["accent", "accentunder", "align", "bevelled", "close", "columnsalign", "columnlines", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lspace", "lquote", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]);
+      xml = freeze(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]);
+      MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
+      ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
+      TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm);
+      DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/);
+      ARIA_ATTR = seal(/^aria-[\-\w]+$/);
+      IS_ALLOWED_URI = seal(
+        /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
+        // eslint-disable-line no-useless-escape
+      );
+      IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+      ATTR_WHITESPACE = seal(
+        /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
+        // eslint-disable-line no-control-regex
+      );
+      DOCTYPE_NAME = seal(/^html$/i);
+      CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
+      EXPRESSIONS = /* @__PURE__ */ Object.freeze({
+        __proto__: null,
+        ARIA_ATTR,
+        ATTR_WHITESPACE,
+        CUSTOM_ELEMENT,
+        DATA_ATTR,
+        DOCTYPE_NAME,
+        ERB_EXPR,
+        IS_ALLOWED_URI,
+        IS_SCRIPT_OR_DATA,
+        MUSTACHE_EXPR,
+        TMPLIT_EXPR
+      });
+      NODE_TYPE = {
+        element: 1,
+        attribute: 2,
+        text: 3,
+        cdataSection: 4,
+        entityReference: 5,
+        // Deprecated
+        entityNode: 6,
+        // Deprecated
+        progressingInstruction: 7,
+        comment: 8,
+        document: 9,
+        documentType: 10,
+        documentFragment: 11,
+        notation: 12
+        // Deprecated
+      };
+      getGlobal = function getGlobal2() {
+        return typeof window === "undefined" ? null : window;
+      };
+      _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes, purifyHostElement) {
+        if (typeof trustedTypes !== "object" || typeof trustedTypes.createPolicy !== "function") {
+          return null;
+        }
+        let suffix = null;
+        const ATTR_NAME = "data-tt-policy-suffix";
+        if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
+          suffix = purifyHostElement.getAttribute(ATTR_NAME);
+        }
+        const policyName = "dompurify" + (suffix ? "#" + suffix : "");
+        try {
+          return trustedTypes.createPolicy(policyName, {
+            createHTML(html2) {
+              return html2;
+            },
+            createScriptURL(scriptUrl) {
+              return scriptUrl;
+            }
+          });
+        } catch (_) {
+          console.warn("TrustedTypes policy " + policyName + " could not be created.");
+          return null;
+        }
+      };
+      _createHooksMap = function _createHooksMap2() {
+        return {
+          afterSanitizeAttributes: [],
+          afterSanitizeElements: [],
+          afterSanitizeShadowDOM: [],
+          beforeSanitizeAttributes: [],
+          beforeSanitizeElements: [],
+          beforeSanitizeShadowDOM: [],
+          uponSanitizeAttribute: [],
+          uponSanitizeElement: [],
+          uponSanitizeShadowNode: []
+        };
+      };
+      purify = createDOMPurify();
+    }
+  });
+
+  // src/standalone.ts
+  var standalone_exports = {};
+  __export(standalone_exports, {
+    ChangerawrMarkdown: () => ChangerawrMarkdown,
+    createCumEngine: () => createCumEngine,
+    default: () => standalone_default,
+    parseCum: () => parseCum,
+    renderCum: () => renderCum,
+    renderCumToHtml: () => renderCumToHtml,
+    renderCumToJson: () => renderCumToJson,
+    renderCumToTailwind: () => renderCumToTailwind
+  });
+
+  // src/parser.ts
+  var MarkdownParser = class {
+    constructor(config) {
+      this.rules = [];
+      this.warnings = [];
+      this.config = __spreadValues({
+        debugMode: false,
+        maxIterations: 1e4,
+        validateMarkdown: false
+      }, config);
+    }
+    addRule(rule) {
+      this.rules.push(rule);
+      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) {
+      var _a;
+      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;
+        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(__spreadProps(__spreadValues({}, token), {
+              raw: match[0] || ""
+            }));
+            remaining = remaining.slice(((_a = match[0]) == null ? void 0 : _a.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 __spreadValues({}, this.config);
+    }
+    updateConfig(config) {
+      this.config = __spreadValues(__spreadValues({}, 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(new RegExp("(?<!\\*)\\*(?!\\*)", "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) {
+          processed.push(token);
+          i++;
+        } else {
+          i++;
+        }
+      }
+      return processed;
+    }
+  };
+
+  // src/utils.ts
+  var DOMPurify = {
+    sanitize: (html2) => html2
+  };
+  if (typeof window !== "undefined") {
+    Promise.resolve().then(() => (init_purify_es(), purify_es_exports)).then((module) => {
+      DOMPurify = module.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(text2) {
+    const map = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    };
+    return text2.replace(/[&<>"']/g, (char) => map[char] || char);
+  }
+  function generateId(text2) {
+    return text2.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").trim();
+  }
+  function sanitizeHtml(html2) {
+    try {
+      if (html2.includes("codepen.io/") || html2.includes("youtube.com/embed/")) {
+        return html2;
+      }
+      if (typeof (DOMPurify == null ? void 0 : DOMPurify.sanitize) === "function") {
+        const sanitized = DOMPurify.sanitize(html2, {
+          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 < html2.length * 0.7) {
+          return basicSanitize(html2);
+        }
+        return sanitized;
+      }
+      return basicSanitize(html2);
+    } catch (error) {
+      console.error("Sanitization failed:", error);
+      return basicSanitize(html2);
+    }
+  }
+  function basicSanitize(html2) {
+    return html2.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 (e) {
+      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 = __spreadValues({
+        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) => __spreadProps(__spreadValues({}, token), {
+        attributes: __spreadProps(__spreadValues({}, token.attributes), {
+          format: this.config.format
+        })
+      }));
+      const htmlParts = tokensWithFormat.map((token) => this.renderToken(token));
+      const combinedHtml = htmlParts.join("");
+      if (this.config.sanitize && !this.config.allowUnsafeHtml) {
+        return sanitizeHtml(combinedHtml);
+      }
+      return combinedHtml;
+    }
+    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 (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 __spreadValues({}, this.config);
+    }
+    updateConfig(config) {
+      this.config = __spreadValues(__spreadValues({}, this.config), config);
+    }
+    setDebugMode(enabled) {
+      this.config.debugMode = enabled;
+    }
+    clearWarnings() {
+      this.warnings = [];
+    }
+  };
+
+  // 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) => {
+          var _a;
+          const content = escapeHtml(token.content);
+          const format = ((_a = token.attributes) == null ? void 0 : _a.format) || "html";
+          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) => {
+          var _a;
+          const content = escapeHtml(token.content);
+          const format = (_a = token.attributes) == null ? void 0 : _a.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) => {
+          var _a, _b;
+          const language = ((_a = token.attributes) == null ? void 0 : _a.language) || "text";
+          const escapedCode = escapeHtml(token.content);
+          const format = ((_b = token.attributes) == null ? void 0 : _b.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) => {
+          var _a;
+          const content = escapeHtml(token.content);
+          const format = (_a = token.attributes) == null ? void 0 : _a.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) => {
+          var _a;
+          const content = escapeHtml(token.content);
+          const format = (_a = token.attributes) == null ? void 0 : _a.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) => {
+          var _a, _b;
+          return {
+            type: "heading",
+            content: ((_a = match[2]) == null ? void 0 : _a.trim()) || "",
+            raw: match[0] || "",
+            attributes: {
+              level: String(((_b = match[1]) == null ? void 0 : _b.length) || 1)
+            }
+          };
+        }
+      }
+    ],
+    renderRules: [
+      {
+        type: "heading",
+        render: (token) => {
+          var _a, _b;
+          const level = parseInt(((_a = token.attributes) == null ? void 0 : _a.level) || "1");
+          const text2 = token.content;
+          const id = generateId(text2);
+          const escapedContent = escapeHtml(text2);
+          const format = ((_b = token.attributes) == null ? void 0 : _b.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) => {
+          var _a;
+          const format = (_a = token.attributes) == null ? void 0 : _a.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] || "",
+            title: match[3] || ""
+          }
+        })
+      }
+    ],
+    renderRules: [
+      {
+        type: "image",
+        render: (token) => {
+          var _a, _b, _c, _d;
+          const src = ((_a = token.attributes) == null ? void 0 : _a.src) || "";
+          const alt = ((_b = token.attributes) == null ? void 0 : _b.alt) || "";
+          const title = ((_c = token.attributes) == null ? void 0 : _c.title) || "";
+          const titleAttr = title ? ` title="${escapeHtml(title)}"` : "";
+          const format = ((_d = token.attributes) == null ? void 0 : _d.format) || "html";
+          if (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" />`;
+        }
+      }
+    ]
+  };
+
+  // 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) => {
+          var _a, _b;
+          const href = ((_a = token.attributes) == null ? void 0 : _a.href) || "#";
+          const escapedHref = escapeHtml(href);
+          const escapedText = escapeHtml(token.content);
+          const format = ((_b = token.attributes) == null ? void 0 : _b.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: "list-item",
+        pattern: /^(\s*)[-*+]\s+(.+)$/m,
+        render: (match) => ({
+          type: "list-item",
+          content: match[2] || "",
+          raw: match[0] || ""
+        })
+      }
+    ],
+    renderRules: [
+      {
+        type: "list-item",
+        render: (token) => `<li>${escapeHtml(token.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: {
+            checked: String((match[2] || "").toLowerCase() === "x")
+          }
+        })
+      }
+    ],
+    renderRules: [
+      {
+        type: "task-item",
+        render: (token) => {
+          var _a, _b;
+          const isChecked = ((_a = token.attributes) == null ? void 0 : _a.checked) === "true";
+          const escapedContent = escapeHtml(token.content);
+          const format = ((_b = token.attributes) == null ? void 0 : _b.format) || "html";
+          if (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>`;
+        }
+      }
+    ]
+  };
+
+  // src/extensions/core/paragraph.ts
+  var ParagraphExtension = {
+    name: "paragraph",
+    parseRules: [],
+    renderRules: [
+      {
+        type: "paragraph",
+        render: (token) => {
+          var _a;
+          if (!token.content) return "";
+          const content = token.content.trim();
+          if (!content) return "";
+          const processedContent = content.includes("<br>") ? content : escapeHtml(content);
+          const format = ((_a = token.attributes) == null ? void 0 : _a.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/index.ts
+  var CoreExtensions = [
+    TextExtension,
+    HeadingExtension,
+    BoldExtension,
+    ItalicExtension,
+    InlineCodeExtension,
+    CodeBlockExtension,
+    LinkExtension,
+    ImageExtension,
+    ListExtension,
+    TaskListExtension,
+    BlockquoteExtension,
+    HorizontalRuleExtension,
+    ParagraphExtension,
+    LineBreakExtension
+  ];
+
+  // src/extensions/alert.ts
+  var AlertExtension = {
+    name: "alert",
+    parseRules: [
+      {
+        name: "alert",
+        pattern: /:::(\w+)(?:\s+(.*?))?\s*\n([\s\S]*?)\n:::/,
+        render: (match) => {
+          var _a;
+          return {
+            type: "alert",
+            content: ((_a = match[3]) == null ? void 0 : _a.trim()) || "",
+            raw: match[0] || "",
+            attributes: {
+              type: match[1] || "info",
+              title: match[2] || ""
+            }
+          };
+        }
+      }
+    ],
+    renderRules: [
+      {
+        type: "alert",
+        render: (token) => {
+          var _a, _b;
+          const type = ((_a = token.attributes) == null ? void 0 : _a.type) || "info";
+          const title = ((_b = token.attributes) == null ? void 0 : _b.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 == null ? void 0 : 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 == null ? void 0 : 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 == null ? void 0 : 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 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) => {
+          var _a, _b, _c, _d, _e;
+          const href = ((_a = token.attributes) == null ? void 0 : _a.href) || "#";
+          const style = ((_b = token.attributes) == null ? void 0 : _b.style) || "primary";
+          const size = ((_c = token.attributes) == null ? void 0 : _c.size) || "md";
+          const disabled = ((_d = token.attributes) == null ? void 0 : _d.disabled) === "true";
+          const target = ((_e = token.attributes) == null ? void 0 : _e.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) => {
+          var _a, _b, _c;
+          const provider = ((_a = token.attributes) == null ? void 0 : _a.provider) || "generic";
+          const url = ((_b = token.attributes) == null ? void 0 : _b.url) || "";
+          const options = ((_c = token.attributes) == null ? void 0 : _c.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) {
+    var _a;
+    const match = url.match(/vimeo\.com\/(?:.*\/)?(\d+)/);
+    return (_a = match == null ? void 0 : match[1]) != null ? _a : null;
+  }
+
+  // src/engine.ts
+  var ChangerawrMarkdown = class {
+    constructor(config) {
+      this.extensions = /* @__PURE__ */ new Map();
+      this.parser = new MarkdownParser(config == null ? void 0 : config.parser);
+      this.renderer = new MarkdownRenderer(config == null ? void 0 : config.renderer);
+      this.registerCoreExtensions();
+      this.registerFeatureExtensions();
+      if (config == null ? void 0 : 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 (e) {
+        return false;
+      }
+    }
+    parse(markdown2) {
+      return this.parser.parse(markdown2);
+    }
+    render(tokens) {
+      return this.renderer.render(tokens);
+    }
+    toHtml(markdown2) {
+      const tokens = this.parse(markdown2);
+      return this.render(tokens);
+    }
+    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: 0,
+        renderTime: 0,
+        tokenCount: 0,
+        iterationCount: 0
+      };
+    }
+    getPerformanceMetrics() {
+      return {
+        parseTime: 0,
+        renderTime: 0,
+        totalTime: 0,
+        tokenCount: 0
+      };
+    }
+    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());
+      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/standalone.ts
+  function renderCum(markdown2, config) {
+    const engine = new ChangerawrMarkdown(config);
+    return engine.toHtml(markdown2);
+  }
+  function parseCum(markdown2, config) {
+    const engine = new ChangerawrMarkdown(config);
+    return engine.parse(markdown2);
+  }
+  function createCumEngine(config) {
+    return new ChangerawrMarkdown(config);
+  }
+  function renderCumToHtml(markdown2) {
+    return renderCum(markdown2, {
+      renderer: { format: "html" }
+    });
+  }
+  function renderCumToTailwind(markdown2) {
+    return renderCum(markdown2, {
+      renderer: { format: "tailwind" }
+    });
+  }
+  function renderCumToJson(markdown2) {
+    return parseCum(markdown2);
+  }
+  var standalone_default = {
+    renderCum,
+    parseCum,
+    createCumEngine,
+    renderCumToHtml,
+    renderCumToTailwind,
+    renderCumToJson,
+    // Legacy aliases
+    render: renderCum,
+    parse: parseCum,
+    // Include the main class
+    ChangerawrMarkdown
+  };
+  return __toCommonJS(standalone_exports);
+})();
+/*! Bundled license information:
+
+dompurify/dist/purify.es.mjs:
+  (*! @license DOMPurify 3.2.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.6/LICENSE *)
+*/