artalk 2.5.4 → 2.6.0

package/dist/Artalk.es.js

@@ -21,6 +21,19 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -41,6 +54,7 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
+var _parseMarkdown, parseMarkdown_fn, _onError, onError_fn;
 const main = "";
 function createElement(htmlStr = "") {
   const div = document.createElement("div");
@@ -136,7 +150,8 @@ function onImagesLoaded($container, event) {
   }
 }
 function getGravatarURL(ctx, emailMD5) {
-  return `${ctx.conf.gravatar.mirror.replace(/\/$/, "")}/${emailMD5}?d=${encodeURIComponent(ctx.conf.gravatar.default)}&s=80`;
+  const { mirror, params } = ctx.conf.gravatar;
+  return `${mirror.replace(/\/$/, "")}/${emailMD5}?${params.replace(/^\?/, "")}`;
 }
 function versionCompare(a, b) {
   const pa = a.split(".");
@@ -367,7 +382,7 @@ function getScrollBarWidth() {
   document.body.removeChild(outer);
   return w1 - w2;
 }
-const _Layer = class extends Component {
+const _Layer = class _Layer extends Component {
   constructor(ctx, name, el) {
     super(ctx);
     __publicField(this, "name");
@@ -474,11 +489,11 @@ const _Layer = class extends Component {
     }
   }
 };
-let Layer = _Layer;
-__publicField(Layer, "BodyOrgOverflow");
-__publicField(Layer, "BodyOrgPaddingRight");
+__publicField(_Layer, "BodyOrgOverflow");
+__publicField(_Layer, "BodyOrgPaddingRight");
 // Timers
-__publicField(Layer, "actionTimers", []);
+__publicField(_Layer, "actionTimers", []);
+let Layer = _Layer;
 function getLayerWrap() {
   let $wrap = document.querySelector(`.atk-layer-wrap`);
   if (!$wrap) {
@@ -530,19 +545,19 @@ function updateClassName(ctx, darkMode) {
       $layerWrap.classList.remove(DarkModeClassName);
   }
 }
-function getDefaults() {
+function _getDefaults() {
   return {
     async: false,
     baseUrl: null,
     breaks: false,
     extensions: null,
     gfm: true,
-    headerIds: true,
+    headerIds: false,
     headerPrefix: "",
     highlight: null,
     hooks: null,
     langPrefix: "language-",
-    mangle: true,
+    mangle: false,
     pedantic: false,
     renderer: null,
     sanitize: false,
@@ -554,9 +569,9 @@ function getDefaults() {
     xhtml: false
   };
 }
-let defaults$3 = getDefaults();
+let _defaults = _getDefaults();
 function changeDefaults(newDefaults) {
-  defaults$3 = newDefaults;
+  _defaults = newDefaults;
 }
 const escapeTest = /[&<>"']/;
 const escapeReplace = new RegExp(escapeTest.source, "g");
@@ -600,7 +615,7 @@ function edit$1(regex, opt) {
   opt = opt || "";
   const obj = {
     replace: (name, val) => {
-      val = val.source || val;
+      val = typeof val === "object" && "source" in val ? val.source : val;
       val = val.replace(caret, "$1");
       regex = regex.replace(name, val);
       return obj;
@@ -663,11 +678,11 @@ function resolveUrl(base, href) {
     return base + href;
   }
 }
-const noopTest = { exec: function noopTest2() {
-} };
+const noopTest = { exec: () => null };
 function splitCells(tableRow, count) {
   const row = tableRow.replace(/\|/g, (match, offset, str) => {
-    let escaped = false, curr = offset;
+    let escaped = false;
+    let curr = offset;
     while (--curr >= 0 && str[curr] === "\\")
       escaped = !escaped;
     if (escaped) {
@@ -683,11 +698,13 @@ function splitCells(tableRow, count) {
   if (cells.length > 0 && !cells[cells.length - 1].trim()) {
     cells.pop();
   }
-  if (cells.length > count) {
-    cells.splice(count);
-  } else {
-    while (cells.length < count)
-      cells.push("");
+  if (count) {
+    if (cells.length > count) {
+      cells.splice(count);
+    } else {
+      while (cells.length < count)
+        cells.push("");
+    }
   }
   for (; i < cells.length; i++) {
     cells[i] = cells[i].trim().replace(/\\\|/g, "|");
@@ -716,9 +733,8 @@ function findClosingBracket(str, b) {
   if (str.indexOf(b[1]) === -1) {
     return -1;
   }
-  const l = str.length;
-  let level = 0, i = 0;
-  for (; i < l; i++) {
+  let level = 0;
+  for (let i = 0; i < str.length; i++) {
     if (str[i] === "\\") {
       i++;
     } else if (str[i] === b[0]) {
@@ -732,24 +748,34 @@ function findClosingBracket(str, b) {
   }
   return -1;
 }
-function checkSanitizeDeprecation(opt) {
-  if (opt && opt.sanitize && !opt.silent) {
+function checkDeprecations(opt, callback) {
+  if (!opt || opt.silent) {
+    return;
+  }
+  if (callback) {
+    console.warn("marked(): callback is deprecated since version 5.0.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/using_pro#async");
+  }
+  if (opt.sanitize || opt.sanitizer) {
     console.warn("marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options");
   }
-}
-function repeatString(pattern, count) {
-  if (count < 1) {
-    return "";
+  if (opt.highlight || opt.langPrefix !== "language-") {
+    console.warn("marked(): highlight and langPrefix parameters are deprecated since version 5.0.0, should not be used and will be removed in the future. Instead use https://www.npmjs.com/package/marked-highlight.");
   }
-  let result = "";
-  while (count > 1) {
-    if (count & 1) {
-      result += pattern;
-    }
-    count >>= 1;
-    pattern += pattern;
+  if (opt.mangle) {
+    console.warn("marked(): mangle parameter is enabled by default, but is deprecated since version 5.0.0, and will be removed in the future. To clear this warning, install https://www.npmjs.com/package/marked-mangle, or disable by setting `{mangle: false}`.");
+  }
+  if (opt.baseUrl) {
+    console.warn("marked(): baseUrl parameter is deprecated since version 5.0.0, should not be used and will be removed in the future. Instead use https://www.npmjs.com/package/marked-base-url.");
+  }
+  if (opt.smartypants) {
+    console.warn("marked(): smartypants parameter is deprecated since version 5.0.0, should not be used and will be removed in the future. Instead use https://www.npmjs.com/package/marked-smartypants.");
+  }
+  if (opt.xhtml) {
+    console.warn("marked(): xhtml parameter is deprecated since version 5.0.0, should not be used and will be removed in the future. Instead use https://www.npmjs.com/package/marked-xhtml.");
+  }
+  if (opt.headerIds || opt.headerPrefix) {
+    console.warn("marked(): headerIds and headerPrefix parameters enabled by default, but are deprecated since version 5.0.0, and will be removed in the future. To clear this warning, install  https://www.npmjs.com/package/marked-gfm-heading-id, or disable by setting `{headerIds: false}`.");
   }
-  return result + pattern;
 }
 function outputLink(cap, link, raw, lexer) {
   const href = link.href;
@@ -794,9 +820,13 @@ function indentCodeCompensation(raw, text) {
     return node;
   }).join("\n");
 }
-class Tokenizer {
+class _Tokenizer {
   constructor(options) {
-    this.options = options || defaults$3;
+    __publicField(this, "options");
+    // TODO: Fix this rules type
+    __publicField(this, "rules");
+    __publicField(this, "lexer");
+    this.options = options || _defaults;
   }
   space(src) {
     const cap = this.rules.block.newline.exec(src);
@@ -881,7 +911,6 @@ class Tokenizer {
   list(src) {
     let cap = this.rules.block.list.exec(src);
     if (cap) {
-      let raw, istask, ischecked, indent, i, blankLine, endsWithBlankLine, line, nextLine, rawLine, itemContents, endEarly;
       let bull = cap[1].trim();
       const isordered = bull.length > 1;
       const list = {
@@ -897,8 +926,11 @@ class Tokenizer {
         bull = isordered ? bull : "[*+-]";
       }
       const itemRegex = new RegExp(`^( {0,3}${bull})((?:[	 ][^\\n]*)?(?:\\n|$))`);
+      let raw = "";
+      let itemContents = "";
+      let endsWithBlankLine = false;
       while (src) {
-        endEarly = false;
+        let endEarly = false;
         if (!(cap = itemRegex.exec(src))) {
           break;
         }
@@ -907,8 +939,9 @@ class Tokenizer {
         }
         raw = cap[0];
         src = src.substring(raw.length);
-        line = cap[2].split("\n", 1)[0].replace(/^\t+/, (t2) => " ".repeat(3 * t2.length));
-        nextLine = src.split("\n", 1)[0];
+        let line = cap[2].split("\n", 1)[0].replace(/^\t+/, (t2) => " ".repeat(3 * t2.length));
+        let nextLine = src.split("\n", 1)[0];
+        let indent = 0;
         if (this.options.pedantic) {
           indent = 2;
           itemContents = line.trimLeft();
@@ -918,7 +951,7 @@ class Tokenizer {
           itemContents = line.slice(indent);
           indent += cap[1].length;
         }
-        blankLine = false;
+        let blankLine = false;
         if (!line && /^ *$/.test(nextLine)) {
           raw += nextLine + "\n";
           src = src.substring(nextLine.length + 1);
@@ -930,7 +963,7 @@ class Tokenizer {
           const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`);
           const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);
           while (src) {
-            rawLine = src.split("\n", 1)[0];
+            const rawLine = src.split("\n", 1)[0];
             nextLine = rawLine;
             if (this.options.pedantic) {
               nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, "  ");
@@ -982,6 +1015,8 @@ class Tokenizer {
             endsWithBlankLine = true;
           }
         }
+        let istask = null;
+        let ischecked;
         if (this.options.gfm) {
           istask = /^\[[ xX]\] /.exec(itemContents);
           if (istask) {
@@ -995,15 +1030,15 @@ class Tokenizer {
           task: !!istask,
           checked: ischecked,
           loose: false,
-          text: itemContents
+          text: itemContents,
+          tokens: []
         });
         list.raw += raw;
       }
       list.items[list.items.length - 1].raw = raw.trimRight();
       list.items[list.items.length - 1].text = itemContents.trimRight();
       list.raw = list.raw.trimRight();
-      const l = list.items.length;
-      for (i = 0; i < l; i++) {
+      for (let i = 0; i < list.items.length; i++) {
         this.lexer.state.top = false;
         list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);
         if (!list.loose) {
@@ -1013,7 +1048,7 @@ class Tokenizer {
         }
       }
       if (list.loose) {
-        for (i = 0; i < l; i++) {
+        for (let i = 0; i < list.items.length; i++) {
           list.items[i].loose = true;
         }
       }
@@ -1025,15 +1060,17 @@ class Tokenizer {
     if (cap) {
       const token = {
         type: "html",
+        block: true,
         raw: cap[0],
         pre: !this.options.sanitizer && (cap[1] === "pre" || cap[1] === "script" || cap[1] === "style"),
         text: cap[0]
       };
       if (this.options.sanitize) {
         const text = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]);
-        token.type = "paragraph";
-        token.text = text;
-        token.tokens = this.lexer.inline(text);
+        const paragraph = token;
+        paragraph.type = "paragraph";
+        paragraph.text = text;
+        paragraph.tokens = this.lexer.inline(text);
       }
       return token;
     }
@@ -1058,31 +1095,34 @@ class Tokenizer {
     if (cap) {
       const item = {
         type: "table",
+        raw: cap[0],
         header: splitCells(cap[1]).map((c) => {
-          return { text: c };
+          return { text: c, tokens: [] };
         }),
         align: cap[2].replace(/^ *|\| *$/g, "").split(/ *\| */),
         rows: cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, "").split("\n") : []
       };
       if (item.header.length === item.align.length) {
-        item.raw = cap[0];
         let l = item.align.length;
         let i, j, k, row;
         for (i = 0; i < l; i++) {
-          if (/^ *-+: *$/.test(item.align[i])) {
-            item.align[i] = "right";
-          } else if (/^ *:-+: *$/.test(item.align[i])) {
-            item.align[i] = "center";
-          } else if (/^ *:-+ *$/.test(item.align[i])) {
-            item.align[i] = "left";
-          } else {
-            item.align[i] = null;
+          const align = item.align[i];
+          if (align) {
+            if (/^ *-+: *$/.test(align)) {
+              item.align[i] = "right";
+            } else if (/^ *:-+: *$/.test(align)) {
+              item.align[i] = "center";
+            } else if (/^ *:-+ *$/.test(align)) {
+              item.align[i] = "left";
+            } else {
+              item.align[i] = null;
+            }
           }
         }
         l = item.rows.length;
         for (i = 0; i < l; i++) {
           item.rows[i] = splitCells(item.rows[i], item.header.length).map((c) => {
-            return { text: c };
+            return { text: c, tokens: [] };
           });
         }
         l = item.header.length;
@@ -1163,6 +1203,7 @@ class Tokenizer {
         raw: cap[0],
         inLink: this.lexer.state.inLink,
         inRawBlock: this.lexer.state.inRawBlock,
+        block: false,
         text: this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0]
       };
     }
@@ -1237,8 +1278,8 @@ class Tokenizer {
     if (match[3] && prevChar.match(/[\p{L}\p{N}]/u))
       return;
     const nextChar = match[1] || match[2] || "";
-    if (!nextChar || nextChar && (prevChar === "" || this.rules.inline.punctuation.exec(prevChar))) {
-      const lLength = match[0].length - 1;
+    if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
+      const lLength = [...match[0]].length - 1;
       let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
       const endReg = match[0][0] === "*" ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
       endReg.lastIndex = 0;
@@ -1247,7 +1288,7 @@ class Tokenizer {
         rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
         if (!rDelim)
           continue;
-        rLength = rDelim.length;
+        rLength = [...rDelim].length;
         if (match[3] || match[4]) {
           delimTotal += rLength;
           continue;
@@ -1261,7 +1302,7 @@ class Tokenizer {
         if (delimTotal > 0)
           continue;
         rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
-        const raw = src.slice(0, lLength + match.index + (match[0].length - rDelim.length) + rLength);
+        const raw = [...src].slice(0, lLength + match.index + rLength + 1).join("");
         if (Math.min(lLength, rLength) % 2) {
           const text2 = raw.slice(1, -1);
           return {
@@ -1407,7 +1448,7 @@ const block = {
   html: "^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))",
   def: /^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/,
   table: noopTest,
-  lheading: /^((?:.|\n(?!\n))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+  lheading: /^((?:(?!^bull ).|\n(?!\n|bull ))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
   // regex template, placeholders will be replaced according to different paragraph
   // interruption rules of commonmark and the original markdown spec:
   _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,
@@ -1422,6 +1463,7 @@ block.list = edit$1(block.list).replace(/bull/g, block.bullet).replace("hr", "\\
 block._tag = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
 block._comment = /<!--(?!-?>)[\s\S]*?(?:-->|$)/;
 block.html = edit$1(block.html, "i").replace("comment", block._comment).replace("tag", block._tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+block.lheading = edit$1(block.lheading).replace(/bull/g, block.bullet).getRegex();
 block.paragraph = edit$1(block._paragraph).replace("hr", block.hr).replace("heading", " {0,3}#{1,6} ").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", block._tag).getRegex();
 block.blockquote = edit$1(block.blockquote).replace("paragraph", block.paragraph).getRegex();
 block.normal = __spreadValues({}, block);
@@ -1432,13 +1474,10 @@ block.gfm = __spreadProps(__spreadValues({}, block.normal), {
 block.gfm.table = edit$1(block.gfm.table).replace("hr", block.hr).replace("heading", " {0,3}#{1,6} ").replace("blockquote", " {0,3}>").replace("code", " {4}[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", block._tag).getRegex();
 block.gfm.paragraph = edit$1(block._paragraph).replace("hr", block.hr).replace("heading", " {0,3}#{1,6} ").replace("|lheading", "").replace("table", block.gfm.table).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", block._tag).getRegex();
 block.pedantic = __spreadProps(__spreadValues({}, block.normal), {
-  html: edit$1(
-    `^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`
-  ).replace("comment", block._comment).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
+  html: edit$1(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", block._comment).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
   def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
   heading: /^(#{1,6})(.*)(?:\n+|$)/,
   fences: noopTest,
-  // fences not supported
   lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
   paragraph: edit$1(block.normal._paragraph).replace("hr", block.hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", block.lheading).replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").getRegex()
 });
@@ -1447,34 +1486,35 @@ const inline = {
   autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/,
   url: noopTest,
   tag: "^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>",
-  // CDATA section
   link: /^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,
   reflink: /^!?\[(label)\]\[(ref)\]/,
   nolink: /^!?\[(ref)\](?:\[\])?/,
   reflinkSearch: "reflink|nolink(?!\\()",
   emStrong: {
-    lDelim: /^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,
-    //        (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
-    //          () Skip orphan inside strong                                      () Consume to delim     (1) #***                (2) a***#, a***                             (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a
-    rDelimAst: /^(?:[^_*\\]|\\.)*?\_\_(?:[^_*\\]|\\.)*?\*(?:[^_*\\]|\\.)*?(?=\_\_)|(?:[^*\\]|\\.)+(?=[^*])|[punct_](\*+)(?=[\s]|$)|(?:[^punct*_\s\\]|\\.)(\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|(?:[^punct*_\s\\]|\\.)(\*+)(?=[^punct*_\s])/,
-    rDelimUnd: /^(?:[^_*\\]|\\.)*?\*\*(?:[^_*\\]|\\.)*?\_(?:[^_*\\]|\\.)*?(?=\*\*)|(?:[^_\\]|\\.)+(?=[^_])|[punct*](\_+)(?=[\s]|$)|(?:[^punct*_\s\\]|\\.)(\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/
+    lDelim: /^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/,
+    //         (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
+    //         | Skip orphan inside strong      | Consume to delim | (1) #***              | (2) a***#, a***                    | (3) #***a, ***a                  | (4) ***#                 | (5) #***#                         | (6) a***a
+    rDelimAst: /^[^_*]*?__[^_*]*?\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\*)[punct](\*+)(?=[\s]|$)|[^punct\s](\*+)(?!\*)(?=[punct\s]|$)|(?!\*)[punct\s](\*+)(?=[^punct\s])|[\s](\*+)(?!\*)(?=[punct])|(?!\*)[punct](\*+)(?!\*)(?=[punct])|[^punct\s](\*+)(?=[^punct\s])/,
+    rDelimUnd: /^[^_*]*?\*\*[^_*]*?_[^_*]*?(?=\*\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\s]|$)|[^punct\s](_+)(?!_)(?=[punct\s]|$)|(?!_)[punct\s](_+)(?=[^punct\s])|[\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])/
     // ^- Not allowed for _
   },
   code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
   br: /^( {2,}|\\)\n(?!\s*$)/,
   del: noopTest,
   text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
-  punctuation: /^([\spunctuation])/
+  punctuation: /^((?![*_])[\spunctuation])/
 };
-inline._punctuation = "!\"#$%&'()+\\-.,/:;<=>?@\\[\\]`^{|}~";
-inline.punctuation = edit$1(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex();
-inline.blockSkip = /\[[^\]]*?\]\([^\)]*?\)|`[^`]*?`|<[^>]*?>/g;
-inline.escapedEmSt = /(?:^|[^\\])(?:\\\\)*\\[*_]/g;
+inline._punctuation = "\\p{P}$+<=>`^|~";
+inline.punctuation = edit$1(inline.punctuation, "u").replace(/punctuation/g, inline._punctuation).getRegex();
+inline.blockSkip = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g;
+inline.anyPunctuation = /\\[punct]/g;
+inline._escapes = /\\([punct])/g;
 inline._comment = edit$1(block._comment).replace("(?:-->|$)", "-->").getRegex();
-inline.emStrong.lDelim = edit$1(inline.emStrong.lDelim).replace(/punct/g, inline._punctuation).getRegex();
-inline.emStrong.rDelimAst = edit$1(inline.emStrong.rDelimAst, "g").replace(/punct/g, inline._punctuation).getRegex();
-inline.emStrong.rDelimUnd = edit$1(inline.emStrong.rDelimUnd, "g").replace(/punct/g, inline._punctuation).getRegex();
-inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
+inline.emStrong.lDelim = edit$1(inline.emStrong.lDelim, "u").replace(/punct/g, inline._punctuation).getRegex();
+inline.emStrong.rDelimAst = edit$1(inline.emStrong.rDelimAst, "gu").replace(/punct/g, inline._punctuation).getRegex();
+inline.emStrong.rDelimUnd = edit$1(inline.emStrong.rDelimUnd, "gu").replace(/punct/g, inline._punctuation).getRegex();
+inline.anyPunctuation = edit$1(inline.anyPunctuation, "gu").replace(/punct/g, inline._punctuation).getRegex();
+inline._escapes = edit$1(inline._escapes, "gu").replace(/punct/g, inline._punctuation).getRegex();
 inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
 inline._email = /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/;
 inline.autolink = edit$1(inline.autolink).replace("scheme", inline._scheme).replace("email", inline._email).getRegex();
@@ -1521,23 +1561,24 @@ function smartypants(text) {
   return text.replace(/---/g, "—").replace(/--/g, "–").replace(/(^|[-\u2014/(\[{"\s])'/g, "$1‘").replace(/'/g, "’").replace(/(^|[-\u2014/(\[{\u2018\s])"/g, "$1“").replace(/"/g, "”").replace(/\.{3}/g, "…");
 }
 function mangle(text) {
-  let out = "", i, ch;
-  const l = text.length;
-  for (i = 0; i < l; i++) {
-    ch = text.charCodeAt(i);
-    if (Math.random() > 0.5) {
-      ch = "x" + ch.toString(16);
-    }
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = Math.random() > 0.5 ? "x" + text.charCodeAt(i).toString(16) : text.charCodeAt(i).toString();
     out += "&#" + ch + ";";
   }
   return out;
 }
-class Lexer {
+class _Lexer {
   constructor(options) {
+    __publicField(this, "tokens");
+    __publicField(this, "options");
+    __publicField(this, "state");
+    __publicField(this, "tokenizer");
+    __publicField(this, "inlineQueue");
     this.tokens = [];
     this.tokens.links = /* @__PURE__ */ Object.create(null);
-    this.options = options || defaults$3;
-    this.options.tokenizer = this.options.tokenizer || new Tokenizer();
+    this.options = options || _defaults;
+    this.options.tokenizer = this.options.tokenizer || new _Tokenizer();
     this.tokenizer = this.options.tokenizer;
     this.tokenizer.options = this.options;
     this.tokenizer.lexer = this;
@@ -1577,14 +1618,14 @@ class Lexer {
    * Static Lex Method
    */
   static lex(src, options) {
-    const lexer = new Lexer(options);
+    const lexer = new _Lexer(options);
     return lexer.lex(src);
   }
   /**
    * Static Lex Inline Method
    */
   static lexInline(src, options) {
-    const lexer = new Lexer(options);
+    const lexer = new _Lexer(options);
     return lexer.inlineTokens(src);
   }
   /**
@@ -1599,9 +1640,6 @@ class Lexer {
     }
     return this.tokens;
   }
-  /**
-   * Lexing
-   */
   blockTokens(src, tokens = []) {
     if (this.options.pedantic) {
       src = src.replace(/\t/g, "    ").replace(/^ +$/gm, "");
@@ -1610,7 +1648,10 @@ class Lexer {
         return leading + "    ".repeat(tabs.length);
       });
     }
-    let token, lastToken, cutSrc, lastParagraphClipped;
+    let token;
+    let lastToken;
+    let cutSrc;
+    let lastParagraphClipped;
     while (src) {
       if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((extTokenizer) => {
         if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
@@ -1703,7 +1744,7 @@ class Lexer {
         let startIndex = Infinity;
         const tempSrc = src.slice(1);
         let tempStart;
-        this.options.extensions.startBlock.forEach(function(getStartIndex) {
+        this.options.extensions.startBlock.forEach((getStartIndex) => {
           tempStart = getStartIndex.call({ lexer: this }, tempSrc);
           if (typeof tempStart === "number" && tempStart >= 0) {
             startIndex = Math.min(startIndex, tempStart);
@@ -1770,17 +1811,16 @@ class Lexer {
       if (links.length > 0) {
         while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
           if (links.includes(match[0].slice(match[0].lastIndexOf("[") + 1, -1))) {
-            maskedSrc = maskedSrc.slice(0, match.index) + "[" + repeatString("a", match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
+            maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
           }
         }
       }
     }
     while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
-      maskedSrc = maskedSrc.slice(0, match.index) + "[" + repeatString("a", match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+      maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
     }
-    while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) {
-      maskedSrc = maskedSrc.slice(0, match.index + match[0].length - 2) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);
-      this.tokenizer.rules.inline.escapedEmSt.lastIndex--;
+    while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
     }
     while (src) {
       if (!keepPrevChar) {
@@ -1864,7 +1904,7 @@ class Lexer {
         let startIndex = Infinity;
         const tempSrc = src.slice(1);
         let tempStart;
-        this.options.extensions.startInline.forEach(function(getStartIndex) {
+        this.options.extensions.startInline.forEach((getStartIndex) => {
           tempStart = getStartIndex.call({ lexer: this }, tempSrc);
           if (typeof tempStart === "number" && tempStart >= 0) {
             startIndex = Math.min(startIndex, tempStart);
@@ -1902,12 +1942,14 @@ class Lexer {
     return tokens;
   }
 }
-class Renderer {
+class _Renderer {
   constructor(options) {
-    this.options = options || defaults$3;
+    __publicField(this, "options");
+    this.options = options || _defaults;
   }
   code(code, infostring, escaped) {
-    const lang = (infostring || "").match(/\S*/)[0];
+    var _a;
+    const lang = (_a = (infostring || "").match(/^\S*/)) == null ? void 0 : _a[0];
     if (this.options.highlight) {
       const out = this.options.highlight(code, lang);
       if (out != null && out !== code) {
@@ -1921,23 +1963,14 @@ class Renderer {
     }
     return '<pre><code class="' + this.options.langPrefix + escape(lang) + '">' + (escaped ? code : escape(code, true)) + "</code></pre>\n";
   }
-  /**
-   * @param {string} quote
-   */
   blockquote(quote) {
     return `<blockquote>
 ${quote}</blockquote>
 `;
   }
-  html(html) {
+  html(html, block2) {
     return html;
   }
-  /**
-   * @param {string} text
-   * @param {string} level
-   * @param {string} raw
-   * @param {any} slugger
-   */
   heading(text, level, raw, slugger) {
     if (this.options.headerIds) {
       const id = this.options.headerPrefix + slugger.slug(raw);
@@ -1951,38 +1984,26 @@ ${quote}</blockquote>
     return this.options.xhtml ? "<hr/>\n" : "<hr>\n";
   }
   list(body, ordered, start) {
-    const type = ordered ? "ol" : "ul", startatt = ordered && start !== 1 ? ' start="' + start + '"' : "";
+    const type = ordered ? "ol" : "ul";
+    const startatt = ordered && start !== 1 ? ' start="' + start + '"' : "";
     return "<" + type + startatt + ">\n" + body + "</" + type + ">\n";
   }
-  /**
-   * @param {string} text
-   */
-  listitem(text) {
+  listitem(text, task, checked) {
     return `<li>${text}</li>
 `;
   }
   checkbox(checked) {
     return "<input " + (checked ? 'checked="" ' : "") + 'disabled="" type="checkbox"' + (this.options.xhtml ? " /" : "") + "> ";
   }
-  /**
-   * @param {string} text
-   */
   paragraph(text) {
     return `<p>${text}</p>
 `;
   }
-  /**
-   * @param {string} header
-   * @param {string} body
-   */
   table(header2, body) {
     if (body)
       body = `<tbody>${body}</tbody>`;
     return "<table>\n<thead>\n" + header2 + "</thead>\n" + body + "</table>\n";
   }
-  /**
-   * @param {string} content
-   */
   tablerow(content) {
     return `<tr>
 ${content}</tr>
@@ -1996,42 +2017,28 @@ ${content}</tr>
   }
   /**
    * span level renderer
-   * @param {string} text
    */
   strong(text) {
     return `<strong>${text}</strong>`;
   }
-  /**
-   * @param {string} text
-   */
   em(text) {
     return `<em>${text}</em>`;
   }
-  /**
-   * @param {string} text
-   */
   codespan(text) {
     return `<code>${text}</code>`;
   }
   br() {
     return this.options.xhtml ? "<br/>" : "<br>";
   }
-  /**
-   * @param {string} text
-   */
   del(text) {
     return `<del>${text}</del>`;
   }
-  /**
-   * @param {string} href
-   * @param {string} title
-   * @param {string} text
-   */
   link(href, title, text) {
-    href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
-    if (href === null) {
+    const cleanHref = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+    if (cleanHref === null) {
       return text;
     }
+    href = cleanHref;
     let out = '<a href="' + href + '"';
     if (title) {
       out += ' title="' + title + '"';
@@ -2039,16 +2046,12 @@ ${content}</tr>
     out += ">" + text + "</a>";
     return out;
   }
-  /**
-   * @param {string} href
-   * @param {string} title
-   * @param {string} text
-   */
   image(href, title, text) {
-    href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
-    if (href === null) {
+    const cleanHref = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+    if (cleanHref === null) {
       return text;
     }
+    href = cleanHref;
     let out = `<img src="${href}" alt="${text}"`;
     if (title) {
       out += ` title="${title}"`;
@@ -2060,7 +2063,7 @@ ${content}</tr>
     return text;
   }
 }
-class TextRenderer {
+class _TextRenderer {
   // no need for block level renderers
   strong(text) {
     return text;
@@ -2090,20 +2093,16 @@ class TextRenderer {
     return "";
   }
 }
-class Slugger {
+class _Slugger {
   constructor() {
+    __publicField(this, "seen");
     this.seen = {};
   }
-  /**
-   * @param {string} value
-   */
   serialize(value) {
     return value.toLowerCase().trim().replace(/<[!\/a-z].*?>/ig, "").replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, "").replace(/\s/g, "-");
   }
   /**
    * Finds the next safe (unique) slug to use
-   * @param {string} originalSlug
-   * @param {boolean} isDryRun
    */
   getNextSafeSlug(originalSlug, isDryRun) {
     let slug = originalSlug;
@@ -2123,49 +2122,50 @@ class Slugger {
   }
   /**
    * Convert string to unique id
-   * @param {object} [options]
-   * @param {boolean} [options.dryrun] Generates the next unique slug without
-   * updating the internal accumulator.
    */
   slug(value, options = {}) {
     const slug = this.serialize(value);
     return this.getNextSafeSlug(slug, options.dryrun);
   }
 }
-class Parser {
+class _Parser {
   constructor(options) {
-    this.options = options || defaults$3;
-    this.options.renderer = this.options.renderer || new Renderer();
+    __publicField(this, "options");
+    __publicField(this, "renderer");
+    __publicField(this, "textRenderer");
+    __publicField(this, "slugger");
+    this.options = options || _defaults;
+    this.options.renderer = this.options.renderer || new _Renderer();
     this.renderer = this.options.renderer;
     this.renderer.options = this.options;
-    this.textRenderer = new TextRenderer();
-    this.slugger = new Slugger();
+    this.textRenderer = new _TextRenderer();
+    this.slugger = new _Slugger();
   }
   /**
    * Static Parse Method
    */
   static parse(tokens, options) {
-    const parser2 = new Parser(options);
+    const parser2 = new _Parser(options);
     return parser2.parse(tokens);
   }
   /**
    * Static Parse Inline Method
    */
   static parseInline(tokens, options) {
-    const parser2 = new Parser(options);
+    const parser2 = new _Parser(options);
     return parser2.parseInline(tokens);
   }
   /**
    * Parse Loop
    */
   parse(tokens, top = true) {
-    let out = "", i, j, k, l2, l3, row, cell, header2, body, token, ordered, start, loose, itemBody, item, checked, task, checkbox, ret;
-    const l = tokens.length;
-    for (i = 0; i < l; i++) {
-      token = tokens[i];
+    let out = "";
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
       if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
-        ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
-        if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(token.type)) {
+        const genericToken = token;
+        const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);
+        if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(genericToken.type)) {
           out += ret || "";
           continue;
         }
@@ -2179,44 +2179,29 @@ class Parser {
           continue;
         }
         case "heading": {
-          out += this.renderer.heading(
-            this.parseInline(token.tokens),
-            token.depth,
-            unescape(this.parseInline(token.tokens, this.textRenderer)),
-            this.slugger
-          );
+          const headingToken = token;
+          out += this.renderer.heading(this.parseInline(headingToken.tokens), headingToken.depth, unescape(this.parseInline(headingToken.tokens, this.textRenderer)), this.slugger);
           continue;
         }
         case "code": {
-          out += this.renderer.code(
-            token.text,
-            token.lang,
-            token.escaped
-          );
+          const codeToken = token;
+          out += this.renderer.code(codeToken.text, codeToken.lang, !!codeToken.escaped);
           continue;
         }
         case "table": {
-          header2 = "";
-          cell = "";
-          l2 = token.header.length;
-          for (j = 0; j < l2; j++) {
-            cell += this.renderer.tablecell(
-              this.parseInline(token.header[j].tokens),
-              { header: true, align: token.align[j] }
-            );
+          const tableToken = token;
+          let header2 = "";
+          let cell = "";
+          for (let j = 0; j < tableToken.header.length; j++) {
+            cell += this.renderer.tablecell(this.parseInline(tableToken.header[j].tokens), { header: true, align: tableToken.align[j] });
           }
           header2 += this.renderer.tablerow(cell);
-          body = "";
-          l2 = token.rows.length;
-          for (j = 0; j < l2; j++) {
-            row = token.rows[j];
+          let body = "";
+          for (let j = 0; j < tableToken.rows.length; j++) {
+            const row = tableToken.rows[j];
             cell = "";
-            l3 = row.length;
-            for (k = 0; k < l3; k++) {
-              cell += this.renderer.tablecell(
-                this.parseInline(row[k].tokens),
-                { header: false, align: token.align[k] }
-              );
+            for (let k = 0; k < row.length; k++) {
+              cell += this.renderer.tablecell(this.parseInline(row[k].tokens), { header: false, align: tableToken.align[k] });
             }
             body += this.renderer.tablerow(cell);
           }
@@ -2224,23 +2209,24 @@ class Parser {
           continue;
         }
         case "blockquote": {
-          body = this.parse(token.tokens);
+          const blockquoteToken = token;
+          const body = this.parse(blockquoteToken.tokens);
           out += this.renderer.blockquote(body);
           continue;
         }
         case "list": {
-          ordered = token.ordered;
-          start = token.start;
-          loose = token.loose;
-          l2 = token.items.length;
-          body = "";
-          for (j = 0; j < l2; j++) {
-            item = token.items[j];
-            checked = item.checked;
-            task = item.task;
-            itemBody = "";
+          const listToken = token;
+          const ordered = listToken.ordered;
+          const start = listToken.start;
+          const loose = listToken.loose;
+          let body = "";
+          for (let j = 0; j < listToken.items.length; j++) {
+            const item = listToken.items[j];
+            const checked = item.checked;
+            const task = item.task;
+            let itemBody = "";
             if (item.task) {
-              checkbox = this.renderer.checkbox(checked);
+              const checkbox = this.renderer.checkbox(!!checked);
               if (loose) {
                 if (item.tokens.length > 0 && item.tokens[0].type === "paragraph") {
                   item.tokens[0].text = checkbox + " " + item.tokens[0].text;
@@ -2258,24 +2244,27 @@ class Parser {
               }
             }
             itemBody += this.parse(item.tokens, loose);
-            body += this.renderer.listitem(itemBody, task, checked);
+            body += this.renderer.listitem(itemBody, task, !!checked);
           }
           out += this.renderer.list(body, ordered, start);
           continue;
         }
         case "html": {
-          out += this.renderer.html(token.text);
+          const htmlToken = token;
+          out += this.renderer.html(htmlToken.text, htmlToken.block);
           continue;
         }
         case "paragraph": {
-          out += this.renderer.paragraph(this.parseInline(token.tokens));
+          const paragraphToken = token;
+          out += this.renderer.paragraph(this.parseInline(paragraphToken.tokens));
           continue;
         }
         case "text": {
-          body = token.tokens ? this.parseInline(token.tokens) : token.text;
-          while (i + 1 < l && tokens[i + 1].type === "text") {
-            token = tokens[++i];
-            body += "\n" + (token.tokens ? this.parseInline(token.tokens) : token.text);
+          let textToken = token;
+          let body = textToken.tokens ? this.parseInline(textToken.tokens) : textToken.text;
+          while (i + 1 < tokens.length && tokens[i + 1].type === "text") {
+            textToken = tokens[++i];
+            body += "\n" + (textToken.tokens ? this.parseInline(textToken.tokens) : textToken.text);
           }
           out += top ? this.renderer.paragraph(body) : body;
           continue;
@@ -2284,7 +2273,7 @@ class Parser {
           const errMsg = 'Token with "' + token.type + '" type was not found.';
           if (this.options.silent) {
             console.error(errMsg);
-            return;
+            return "";
           } else {
             throw new Error(errMsg);
           }
@@ -2298,12 +2287,11 @@ class Parser {
    */
   parseInline(tokens, renderer) {
     renderer = renderer || this.renderer;
-    let out = "", i, token, ret;
-    const l = tokens.length;
-    for (i = 0; i < l; i++) {
-      token = tokens[i];
+    let out = "";
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
       if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
-        ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
+        const ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
         if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(token.type)) {
           out += ret || "";
           continue;
@@ -2311,31 +2299,38 @@ class Parser {
       }
       switch (token.type) {
         case "escape": {
-          out += renderer.text(token.text);
+          const escapeToken = token;
+          out += renderer.text(escapeToken.text);
           break;
         }
         case "html": {
-          out += renderer.html(token.text);
+          const tagToken = token;
+          out += renderer.html(tagToken.text);
           break;
         }
         case "link": {
-          out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
+          const linkToken = token;
+          out += renderer.link(linkToken.href, linkToken.title, this.parseInline(linkToken.tokens, renderer));
           break;
         }
         case "image": {
-          out += renderer.image(token.href, token.title, token.text);
+          const imageToken = token;
+          out += renderer.image(imageToken.href, imageToken.title, imageToken.text);
           break;
         }
         case "strong": {
-          out += renderer.strong(this.parseInline(token.tokens, renderer));
+          const strongToken = token;
+          out += renderer.strong(this.parseInline(strongToken.tokens, renderer));
           break;
         }
         case "em": {
-          out += renderer.em(this.parseInline(token.tokens, renderer));
+          const emToken = token;
+          out += renderer.em(this.parseInline(emToken.tokens, renderer));
           break;
         }
         case "codespan": {
-          out += renderer.codespan(token.text);
+          const codespanToken = token;
+          out += renderer.codespan(codespanToken.text);
           break;
         }
         case "br": {
@@ -2343,18 +2338,20 @@ class Parser {
           break;
         }
         case "del": {
-          out += renderer.del(this.parseInline(token.tokens, renderer));
+          const delToken = token;
+          out += renderer.del(this.parseInline(delToken.tokens, renderer));
           break;
         }
         case "text": {
-          out += renderer.text(token.text);
+          const textToken = token;
+          out += renderer.text(textToken.text);
           break;
         }
         default: {
           const errMsg = 'Token with "' + token.type + '" type was not found.';
           if (this.options.silent) {
             console.error(errMsg);
-            return;
+            return "";
           } else {
             throw new Error(errMsg);
           }
@@ -2364,9 +2361,10 @@ class Parser {
     return out;
   }
 }
-class Hooks {
+class _Hooks {
   constructor(options) {
-    this.options = options || defaults$3;
+    __publicField(this, "options");
+    this.options = options || _defaults;
   }
   /**
    * Process markdown before marked
@@ -2381,54 +2379,234 @@ class Hooks {
     return html;
   }
 }
-__publicField(Hooks, "passThroughHooks", /* @__PURE__ */ new Set([
+__publicField(_Hooks, "passThroughHooks", /* @__PURE__ */ new Set([
   "preprocess",
   "postprocess"
 ]));
-function onError(silent, async, callback) {
-  return (e) => {
-    e.message += "\nPlease report this to https://github.com/markedjs/marked.";
-    if (silent) {
-      const msg = "<p>An error occurred:</p><pre>" + escape(e.message + "", true) + "</pre>";
-      if (async) {
-        return Promise.resolve(msg);
-      }
-      if (callback) {
-        callback(null, msg);
-        return;
+class Marked {
+  constructor(...args) {
+    __privateAdd(this, _parseMarkdown);
+    __privateAdd(this, _onError);
+    __publicField(this, "defaults", _getDefaults());
+    __publicField(this, "options", this.setOptions);
+    __publicField(this, "parse", __privateMethod(this, _parseMarkdown, parseMarkdown_fn).call(this, _Lexer.lex, _Parser.parse));
+    __publicField(this, "parseInline", __privateMethod(this, _parseMarkdown, parseMarkdown_fn).call(this, _Lexer.lexInline, _Parser.parseInline));
+    __publicField(this, "Parser", _Parser);
+    __publicField(this, "parser", _Parser.parse);
+    __publicField(this, "Renderer", _Renderer);
+    __publicField(this, "TextRenderer", _TextRenderer);
+    __publicField(this, "Lexer", _Lexer);
+    __publicField(this, "lexer", _Lexer.lex);
+    __publicField(this, "Tokenizer", _Tokenizer);
+    __publicField(this, "Slugger", _Slugger);
+    __publicField(this, "Hooks", _Hooks);
+    this.use(...args);
+  }
+  /**
+   * Run callback for every token
+   */
+  walkTokens(tokens, callback) {
+    var _a, _b;
+    let values = [];
+    for (const token of tokens) {
+      values = values.concat(callback.call(this, token));
+      switch (token.type) {
+        case "table": {
+          const tableToken = token;
+          for (const cell of tableToken.header) {
+            values = values.concat(this.walkTokens(cell.tokens, callback));
+          }
+          for (const row of tableToken.rows) {
+            for (const cell of row) {
+              values = values.concat(this.walkTokens(cell.tokens, callback));
+            }
+          }
+          break;
+        }
+        case "list": {
+          const listToken = token;
+          values = values.concat(this.walkTokens(listToken.items, callback));
+          break;
+        }
+        default: {
+          const genericToken = token;
+          if ((_b = (_a = this.defaults.extensions) == null ? void 0 : _a.childTokens) == null ? void 0 : _b[genericToken.type]) {
+            this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {
+              values = values.concat(this.walkTokens(genericToken[childTokens], callback));
+            });
+          } else if (genericToken.tokens) {
+            values = values.concat(this.walkTokens(genericToken.tokens, callback));
+          }
+        }
       }
-      return msg;
-    }
-    if (async) {
-      return Promise.reject(e);
     }
-    if (callback) {
-      callback(e);
-      return;
-    }
-    throw e;
-  };
+    return values;
+  }
+  use(...args) {
+    const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    args.forEach((pack) => {
+      const opts = __spreadValues({}, pack);
+      opts.async = this.defaults.async || opts.async || false;
+      if (pack.extensions) {
+        pack.extensions.forEach((ext) => {
+          if (!ext.name) {
+            throw new Error("extension name required");
+          }
+          if ("renderer" in ext) {
+            const prevRenderer = extensions.renderers[ext.name];
+            if (prevRenderer) {
+              extensions.renderers[ext.name] = function(...args2) {
+                let ret = ext.renderer.apply(this, args2);
+                if (ret === false) {
+                  ret = prevRenderer.apply(this, args2);
+                }
+                return ret;
+              };
+            } else {
+              extensions.renderers[ext.name] = ext.renderer;
+            }
+          }
+          if ("tokenizer" in ext) {
+            if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
+              throw new Error("extension level must be 'block' or 'inline'");
+            }
+            const extLevel = extensions[ext.level];
+            if (extLevel) {
+              extLevel.unshift(ext.tokenizer);
+            } else {
+              extensions[ext.level] = [ext.tokenizer];
+            }
+            if (ext.start) {
+              if (ext.level === "block") {
+                if (extensions.startBlock) {
+                  extensions.startBlock.push(ext.start);
+                } else {
+                  extensions.startBlock = [ext.start];
+                }
+              } else if (ext.level === "inline") {
+                if (extensions.startInline) {
+                  extensions.startInline.push(ext.start);
+                } else {
+                  extensions.startInline = [ext.start];
+                }
+              }
+            }
+          }
+          if ("childTokens" in ext && ext.childTokens) {
+            extensions.childTokens[ext.name] = ext.childTokens;
+          }
+        });
+        opts.extensions = extensions;
+      }
+      if (pack.renderer) {
+        const renderer = this.defaults.renderer || new _Renderer(this.defaults);
+        for (const prop in pack.renderer) {
+          const rendererFunc = pack.renderer[prop];
+          const rendererKey = prop;
+          const prevRenderer = renderer[rendererKey];
+          renderer[rendererKey] = (...args2) => {
+            let ret = rendererFunc.apply(renderer, args2);
+            if (ret === false) {
+              ret = prevRenderer.apply(renderer, args2);
+            }
+            return ret || "";
+          };
+        }
+        opts.renderer = renderer;
+      }
+      if (pack.tokenizer) {
+        const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
+        for (const prop in pack.tokenizer) {
+          const tokenizerFunc = pack.tokenizer[prop];
+          const tokenizerKey = prop;
+          const prevTokenizer = tokenizer[tokenizerKey];
+          tokenizer[tokenizerKey] = (...args2) => {
+            let ret = tokenizerFunc.apply(tokenizer, args2);
+            if (ret === false) {
+              ret = prevTokenizer.apply(tokenizer, args2);
+            }
+            return ret;
+          };
+        }
+        opts.tokenizer = tokenizer;
+      }
+      if (pack.hooks) {
+        const hooks = this.defaults.hooks || new _Hooks();
+        for (const prop in pack.hooks) {
+          const hooksFunc = pack.hooks[prop];
+          const hooksKey = prop;
+          const prevHook = hooks[hooksKey];
+          if (_Hooks.passThroughHooks.has(prop)) {
+            hooks[hooksKey] = (arg) => {
+              if (this.defaults.async) {
+                return Promise.resolve(hooksFunc.call(hooks, arg)).then((ret2) => {
+                  return prevHook.call(hooks, ret2);
+                });
+              }
+              const ret = hooksFunc.call(hooks, arg);
+              return prevHook.call(hooks, ret);
+            };
+          } else {
+            hooks[hooksKey] = (...args2) => {
+              let ret = hooksFunc.apply(hooks, args2);
+              if (ret === false) {
+                ret = prevHook.apply(hooks, args2);
+              }
+              return ret;
+            };
+          }
+        }
+        opts.hooks = hooks;
+      }
+      if (pack.walkTokens) {
+        const walkTokens = this.defaults.walkTokens;
+        const packWalktokens = pack.walkTokens;
+        opts.walkTokens = function(token) {
+          let values = [];
+          values.push(packWalktokens.call(this, token));
+          if (walkTokens) {
+            values = values.concat(walkTokens.call(this, token));
+          }
+          return values;
+        };
+      }
+      this.defaults = __spreadValues(__spreadValues({}, this.defaults), opts);
+    });
+    return this;
+  }
+  setOptions(opt) {
+    this.defaults = __spreadValues(__spreadValues({}, this.defaults), opt);
+    return this;
+  }
 }
-function parseMarkdown(lexer, parser2) {
-  return (src, opt, callback) => {
-    if (typeof opt === "function") {
-      callback = opt;
-      opt = null;
+_parseMarkdown = new WeakSet();
+parseMarkdown_fn = function(lexer, parser2) {
+  return (src, optOrCallback, callback) => {
+    if (typeof optOrCallback === "function") {
+      callback = optOrCallback;
+      optOrCallback = null;
+    }
+    const origOpt = __spreadValues({}, optOrCallback);
+    const opt = __spreadValues(__spreadValues({}, this.defaults), origOpt);
+    if (this.defaults.async === true && origOpt.async === false) {
+      if (!opt.silent) {
+        console.warn("marked(): The async option was set to true by an extension. The async: false option sent to parse will be ignored.");
+      }
+      opt.async = true;
     }
-    const origOpt = __spreadValues({}, opt);
-    opt = __spreadValues(__spreadValues({}, marked$1.defaults), origOpt);
-    const throwError = onError(opt.silent, opt.async, callback);
+    const throwError = __privateMethod(this, _onError, onError_fn).call(this, !!opt.silent, !!opt.async, callback);
     if (typeof src === "undefined" || src === null) {
       return throwError(new Error("marked(): input parameter is undefined or null"));
     }
     if (typeof src !== "string") {
       return throwError(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"));
     }
-    checkSanitizeDeprecation(opt);
+    checkDeprecations(opt, callback);
     if (opt.hooks) {
       opt.hooks.options = opt;
     }
     if (callback) {
+      const resultCallback = callback;
       const highlight = opt.highlight;
       let tokens;
       try {
@@ -2439,12 +2617,12 @@ function parseMarkdown(lexer, parser2) {
       } catch (e) {
         return throwError(e);
       }
-      const done = function(err) {
+      const done = (err) => {
         let out;
         if (!err) {
           try {
             if (opt.walkTokens) {
-              marked$1.walkTokens(tokens, opt.walkTokens);
+              this.walkTokens(tokens, opt.walkTokens);
             }
             out = parser2(tokens, opt);
             if (opt.hooks) {
@@ -2455,7 +2633,7 @@ function parseMarkdown(lexer, parser2) {
           }
         }
         opt.highlight = highlight;
-        return err ? throwError(err) : callback(null, out);
+        return err ? throwError(err) : resultCallback(null, out);
       };
       if (!highlight || highlight.length < 3) {
         return done();
@@ -2464,11 +2642,11 @@ function parseMarkdown(lexer, parser2) {
       if (!tokens.length)
         return done();
       let pending = 0;
-      marked$1.walkTokens(tokens, function(token) {
+      this.walkTokens(tokens, (token) => {
         if (token.type === "code") {
           pending++;
           setTimeout(() => {
-            highlight(token.text, token.lang, function(err, code) {
+            highlight(token.text, token.lang, (err, code) => {
               if (err) {
                 return done(err);
               }
@@ -2490,7 +2668,7 @@ function parseMarkdown(lexer, parser2) {
       return;
     }
     if (opt.async) {
-      return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src2) => lexer(src2, opt)).then((tokens) => opt.walkTokens ? Promise.all(marked$1.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser2(tokens, opt)).then((html) => opt.hooks ? opt.hooks.postprocess(html) : html).catch(throwError);
+      return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src2) => lexer(src2, opt)).then((tokens) => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser2(tokens, opt)).then((html) => opt.hooks ? opt.hooks.postprocess(html) : html).catch(throwError);
     }
     try {
       if (opt.hooks) {
@@ -2498,7 +2676,7 @@ function parseMarkdown(lexer, parser2) {
       }
       const tokens = lexer(src, opt);
       if (opt.walkTokens) {
-        marked$1.walkTokens(tokens, opt.walkTokens);
+        this.walkTokens(tokens, opt.walkTokens);
       }
       let html = parser2(tokens, opt);
       if (opt.hooks) {
@@ -2509,192 +2687,75 @@ function parseMarkdown(lexer, parser2) {
       return throwError(e);
     }
   };
-}
+};
+_onError = new WeakSet();
+onError_fn = function(silent, async, callback) {
+  return (e) => {
+    e.message += "\nPlease report this to https://github.com/markedjs/marked.";
+    if (silent) {
+      const msg = "<p>An error occurred:</p><pre>" + escape(e.message + "", true) + "</pre>";
+      if (async) {
+        return Promise.resolve(msg);
+      }
+      if (callback) {
+        callback(null, msg);
+        return;
+      }
+      return msg;
+    }
+    if (async) {
+      return Promise.reject(e);
+    }
+    if (callback) {
+      callback(e);
+      return;
+    }
+    throw e;
+  };
+};
+const markedInstance = new Marked();
 function marked$1(src, opt, callback) {
-  return parseMarkdown(Lexer.lex, Parser.parse)(src, opt, callback);
+  return markedInstance.parse(src, opt, callback);
 }
-marked$1.options = marked$1.setOptions = function(opt) {
-  marked$1.defaults = __spreadValues(__spreadValues({}, marked$1.defaults), opt);
+marked$1.options = marked$1.setOptions = function(options) {
+  markedInstance.setOptions(options);
+  marked$1.defaults = markedInstance.defaults;
   changeDefaults(marked$1.defaults);
   return marked$1;
 };
-marked$1.getDefaults = getDefaults;
-marked$1.defaults = defaults$3;
+marked$1.getDefaults = _getDefaults;
+marked$1.defaults = _defaults;
 marked$1.use = function(...args) {
-  const extensions = marked$1.defaults.extensions || { renderers: {}, childTokens: {} };
-  args.forEach((pack) => {
-    const opts = __spreadValues({}, pack);
-    opts.async = marked$1.defaults.async || opts.async || false;
-    if (pack.extensions) {
-      pack.extensions.forEach((ext) => {
-        if (!ext.name) {
-          throw new Error("extension name required");
-        }
-        if (ext.renderer) {
-          const prevRenderer = extensions.renderers[ext.name];
-          if (prevRenderer) {
-            extensions.renderers[ext.name] = function(...args2) {
-              let ret = ext.renderer.apply(this, args2);
-              if (ret === false) {
-                ret = prevRenderer.apply(this, args2);
-              }
-              return ret;
-            };
-          } else {
-            extensions.renderers[ext.name] = ext.renderer;
-          }
-        }
-        if (ext.tokenizer) {
-          if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
-            throw new Error("extension level must be 'block' or 'inline'");
-          }
-          if (extensions[ext.level]) {
-            extensions[ext.level].unshift(ext.tokenizer);
-          } else {
-            extensions[ext.level] = [ext.tokenizer];
-          }
-          if (ext.start) {
-            if (ext.level === "block") {
-              if (extensions.startBlock) {
-                extensions.startBlock.push(ext.start);
-              } else {
-                extensions.startBlock = [ext.start];
-              }
-            } else if (ext.level === "inline") {
-              if (extensions.startInline) {
-                extensions.startInline.push(ext.start);
-              } else {
-                extensions.startInline = [ext.start];
-              }
-            }
-          }
-        }
-        if (ext.childTokens) {
-          extensions.childTokens[ext.name] = ext.childTokens;
-        }
-      });
-      opts.extensions = extensions;
-    }
-    if (pack.renderer) {
-      const renderer = marked$1.defaults.renderer || new Renderer();
-      for (const prop in pack.renderer) {
-        const prevRenderer = renderer[prop];
-        renderer[prop] = (...args2) => {
-          let ret = pack.renderer[prop].apply(renderer, args2);
-          if (ret === false) {
-            ret = prevRenderer.apply(renderer, args2);
-          }
-          return ret;
-        };
-      }
-      opts.renderer = renderer;
-    }
-    if (pack.tokenizer) {
-      const tokenizer = marked$1.defaults.tokenizer || new Tokenizer();
-      for (const prop in pack.tokenizer) {
-        const prevTokenizer = tokenizer[prop];
-        tokenizer[prop] = (...args2) => {
-          let ret = pack.tokenizer[prop].apply(tokenizer, args2);
-          if (ret === false) {
-            ret = prevTokenizer.apply(tokenizer, args2);
-          }
-          return ret;
-        };
-      }
-      opts.tokenizer = tokenizer;
-    }
-    if (pack.hooks) {
-      const hooks = marked$1.defaults.hooks || new Hooks();
-      for (const prop in pack.hooks) {
-        const prevHook = hooks[prop];
-        if (Hooks.passThroughHooks.has(prop)) {
-          hooks[prop] = (arg) => {
-            if (marked$1.defaults.async) {
-              return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then((ret2) => {
-                return prevHook.call(hooks, ret2);
-              });
-            }
-            const ret = pack.hooks[prop].call(hooks, arg);
-            return prevHook.call(hooks, ret);
-          };
-        } else {
-          hooks[prop] = (...args2) => {
-            let ret = pack.hooks[prop].apply(hooks, args2);
-            if (ret === false) {
-              ret = prevHook.apply(hooks, args2);
-            }
-            return ret;
-          };
-        }
-      }
-      opts.hooks = hooks;
-    }
-    if (pack.walkTokens) {
-      const walkTokens = marked$1.defaults.walkTokens;
-      opts.walkTokens = function(token) {
-        let values = [];
-        values.push(pack.walkTokens.call(this, token));
-        if (walkTokens) {
-          values = values.concat(walkTokens.call(this, token));
-        }
-        return values;
-      };
-    }
-    marked$1.setOptions(opts);
-  });
+  markedInstance.use(...args);
+  marked$1.defaults = markedInstance.defaults;
+  changeDefaults(marked$1.defaults);
+  return marked$1;
 };
 marked$1.walkTokens = function(tokens, callback) {
-  let values = [];
-  for (const token of tokens) {
-    values = values.concat(callback.call(marked$1, token));
-    switch (token.type) {
-      case "table": {
-        for (const cell of token.header) {
-          values = values.concat(marked$1.walkTokens(cell.tokens, callback));
-        }
-        for (const row of token.rows) {
-          for (const cell of row) {
-            values = values.concat(marked$1.walkTokens(cell.tokens, callback));
-          }
-        }
-        break;
-      }
-      case "list": {
-        values = values.concat(marked$1.walkTokens(token.items, callback));
-        break;
-      }
-      default: {
-        if (marked$1.defaults.extensions && marked$1.defaults.extensions.childTokens && marked$1.defaults.extensions.childTokens[token.type]) {
-          marked$1.defaults.extensions.childTokens[token.type].forEach(function(childTokens) {
-            values = values.concat(marked$1.walkTokens(token[childTokens], callback));
-          });
-        } else if (token.tokens) {
-          values = values.concat(marked$1.walkTokens(token.tokens, callback));
-        }
-      }
-    }
-  }
-  return values;
+  return markedInstance.walkTokens(tokens, callback);
 };
-marked$1.parseInline = parseMarkdown(Lexer.lexInline, Parser.parseInline);
-marked$1.Parser = Parser;
-marked$1.parser = Parser.parse;
-marked$1.Renderer = Renderer;
-marked$1.TextRenderer = TextRenderer;
-marked$1.Lexer = Lexer;
-marked$1.lexer = Lexer.lex;
-marked$1.Tokenizer = Tokenizer;
-marked$1.Slugger = Slugger;
-marked$1.Hooks = Hooks;
+marked$1.parseInline = markedInstance.parseInline;
+marked$1.Parser = _Parser;
+marked$1.parser = _Parser.parse;
+marked$1.Renderer = _Renderer;
+marked$1.TextRenderer = _TextRenderer;
+marked$1.Lexer = _Lexer;
+marked$1.lexer = _Lexer.lex;
+marked$1.Tokenizer = _Tokenizer;
+marked$1.Slugger = _Slugger;
+marked$1.Hooks = _Hooks;
 marked$1.parse = marked$1;
 marked$1.options;
 marked$1.setOptions;
 marked$1.use;
 marked$1.walkTokens;
 marked$1.parseInline;
-Parser.parse;
-Lexer.lex;
+_Parser.parse;
+_Lexer.lex;
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
 var escapes = {
   "&": "&amp;",
   "<": "&lt;",
@@ -3084,15 +3145,8 @@ function insane(html, options, strict) {
 }
 insane.defaults = defaults$1;
 var insane_1 = insane;
-var hanabiExports = {};
-var hanabi$1 = {
-  get exports() {
-    return hanabiExports;
-  },
-  set exports(v) {
-    hanabiExports = v;
-  }
-};
+const insane$1 = /* @__PURE__ */ getDefaultExportFromCjs(insane_1);
+var hanabi$1 = { exports: {} };
 (function(module, exports) {
   (function(global2, factory) {
     module.exports = factory();
@@ -3148,7 +3202,8 @@ var hanabi$1 = {
     return index;
   });
 })(hanabi$1);
-const hanabi = hanabiExports;
+var hanabiExports = hanabi$1.exports;
+const hanabi = /* @__PURE__ */ getDefaultExportFromCjs(hanabiExports);
 let instance;
 function getInstance() {
   return instance;
@@ -3201,7 +3256,7 @@ function marked(ctx, src) {
   if (!markedContent) {
     markedContent = src.replace(/```\s*([^]+?.*?[^]+?[^]+?)```/g, (_, code) => `<pre><code>${hanabi(code)}</code></pre>`).replace(/!\[(.*?)\]\((.*?)\)/g, (_, alt, imgSrc) => `<img src="${imgSrc}" alt="${alt}" />`).replace(/\[(.*?)\]\((.*?)\)/g, (_, text, link) => `<a href="${link}" target="_blank">${text}</a>`).replace(/\n/g, "<br>");
   }
-  let dest = insane_1(markedContent, {
+  let dest = insane$1(markedContent, {
     allowedClasses: {},
     // @refer CVE-2018-8495
     // @link https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-8495
@@ -3472,7 +3527,7 @@ function t(key, args = {}) {
   str = str.replace(/\{\s*(\w+?)\s*\}/g, (_, token) => args[token] || "");
   return str;
 }
-const version = "2.5.4";
+const version = "2.6.0";
 class User {
   constructor() {
     __publicField(this, "ctx");
@@ -5000,8 +5055,8 @@ const defaults = {
   countEl: "#ArtalkCount",
   pvEl: "#ArtalkPV",
   gravatar: {
-    default: "mp",
-    mirror: "https://cravatar.cn/avatar/"
+    mirror: "https://cravatar.cn/avatar/",
+    params: "d=mp&s=240"
   },
   pagination: {
     pageSize: 20,
@@ -7458,7 +7513,7 @@ function createPlugManager(editor) {
   editor.getUI().$plugPanelWrap.style.display = "none";
   editor.getUI().$plugBtnWrap.innerHTML = "";
   const DISABLED = getDisabledPlugNames(editor.conf);
-  ENABLED_PLUGS.filter((p) => !DISABLED.includes(p.name)).forEach((Plug) => {
+  ENABLED_PLUGS.filter((p) => !DISABLED.includes(p.Name)).forEach((Plug) => {
     initPlugItem(ctx, Plug);
   });
   return ctx;
@@ -7695,10 +7750,12 @@ function Do(m) {
     } catch (err) {
       console.error(err);
       m.editor.showNotify(`${m.editor.$t("commentFail")}，${err.msg || String(err)}`, "e");
+      return;
+    } finally {
+      m.editor.hideLoading();
     }
     m.editor.reset();
     m.editor.ctx.trigger("editor-submitted");
-    m.editor.hideLoading();
   });
 }
 function getSubmitAddParams(m) {
@@ -8244,7 +8301,7 @@ function handleStatCount(p, args) {
     });
   });
 }
-const _Artalk = class {
+const _Artalk = class _Artalk {
   constructor(conf) {
     __publicField(this, "conf");
     __publicField(this, "ctx");
@@ -8370,13 +8427,13 @@ const _Artalk = class {
     this.loadCountWidget(conf);
   }
 };
-let Artalk = _Artalk;
-__publicField(Artalk, "instance");
-__publicField(Artalk, "ListLite", ListLite);
-__publicField(Artalk, "defaults", defaults);
+__publicField(_Artalk, "instance");
+__publicField(_Artalk, "ListLite", ListLite);
+__publicField(_Artalk, "defaults", defaults);
 /** Plugins */
-__publicField(Artalk, "plugins", [PvCountWidget]);
-__publicField(Artalk, "DisabledComponents", []);
+__publicField(_Artalk, "plugins", [PvCountWidget]);
+__publicField(_Artalk, "DisabledComponents", []);
+let Artalk = _Artalk;
 export {
   Artalk as default
 };