markmap-lib 0.17.3-alpha.2 → 0.17.3-alpha.3

package/dist/browser/index.iife.js

@@ -2646,7 +2646,7 @@
   function isQuote(c) {
     return c === 39 || c === 34;
   }
-  function isWhitespace$2(c) {
+  function isWhitespace$3(c) {
     return c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
   }
   function parse$5(selector) {
@@ -2670,7 +2670,7 @@
     }
     function stripWhitespace(offset) {
       selectorIndex += offset;
-      while (selectorIndex < selector.length && isWhitespace$2(selector.charCodeAt(selectorIndex))) {
+      while (selectorIndex < selector.length && isWhitespace$3(selector.charCodeAt(selectorIndex))) {
         selectorIndex++;
       }
     }
@@ -2820,7 +2820,7 @@
               selectorIndex = sectionEnd + 1;
             } else {
               const valueStart = selectorIndex;
-              while (selectorIndex < selector.length && (!isWhitespace$2(selector.charCodeAt(selectorIndex)) && selector.charCodeAt(selectorIndex) !== 93 || isEscaped(selectorIndex))) {
+              while (selectorIndex < selector.length && (!isWhitespace$3(selector.charCodeAt(selectorIndex)) && selector.charCodeAt(selectorIndex) !== 93 || isEscaped(selectorIndex))) {
                 selectorIndex += 1;
               }
               value = unescapeCSS(selector.slice(valueStart, selectorIndex));
@@ -2937,6 +2937,7 @@
     finalizeSubselector();
     return selectorIndex;
   }
+  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;
   }
@@ -5974,14 +5975,14 @@
   function toAsciiLower(cp) {
     return cp + 32;
   }
-  function isWhitespace$1(cp) {
+  function isWhitespace$2(cp) {
     return cp === CODE_POINTS.SPACE || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.TABULATION || cp === CODE_POINTS.FORM_FEED;
   }
   function isEntityInAttributeInvalidEnd(nextCp) {
     return nextCp === CODE_POINTS.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
   }
   function isScriptDataDoubleEscapeSequenceEnd(cp) {
-    return isWhitespace$1(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN;
+    return isWhitespace$2(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN;
   }
   let Tokenizer$1 = class Tokenizer {
     constructor(options, handler) {
@@ -6272,7 +6273,7 @@
       this._createCharacterToken(type, ch);
     }
     _emitCodePoint(cp) {
-      const type = isWhitespace$1(cp) ? TokenType.WHITESPACE_CHARACTER : cp === CODE_POINTS.NULL ? TokenType.NULL_CHARACTER : TokenType.CHARACTER;
+      const type = isWhitespace$2(cp) ? TokenType.WHITESPACE_CHARACTER : cp === CODE_POINTS.NULL ? TokenType.NULL_CHARACTER : TokenType.CHARACTER;
       this._appendCharToCurrentCharacterToken(type, String.fromCodePoint(cp));
     }
     //NOTE: used when we emit characters explicitly.
@@ -12864,11 +12865,11 @@
     State2[State2["InSpecialTag"] = 25] = "InSpecialTag";
     State2[State2["InEntity"] = 26] = "InEntity";
   })(State || (State = {}));
-  function isWhitespace(c) {
+  function isWhitespace$1(c) {
     return c === CharCodes.Space || c === CharCodes.NewLine || c === CharCodes.Tab || c === CharCodes.FormFeed || c === CharCodes.CarriageReturn;
   }
   function isEndOfTagSection(c) {
-    return c === CharCodes.Slash || c === CharCodes.Gt || isWhitespace(c);
+    return c === CharCodes.Slash || c === CharCodes.Gt || isWhitespace$1(c);
   }
   function isASCIIAlpha(c) {
     return c >= CharCodes.LowerA && c <= CharCodes.LowerZ || c >= CharCodes.UpperA && c <= CharCodes.UpperZ;
@@ -12986,7 +12987,7 @@
     /** Look for an end tag. For <title> tags, also decode entities. */
     stateInSpecialTag(c) {
       if (this.sequenceIndex === this.currentSequence.length) {
-        if (c === CharCodes.Gt || isWhitespace(c)) {
+        if (c === CharCodes.Gt || isWhitespace$1(c)) {
           const endOfText = this.index - this.currentSequence.length;
           if (this.sectionStart < endOfText) {
             const actualIndex = this.index;
@@ -13122,7 +13123,7 @@
       }
     }
     stateBeforeClosingTagName(c) {
-      if (isWhitespace(c)) ;
+      if (isWhitespace$1(c)) ;
       else if (c === CharCodes.Gt) {
         this.state = State.Text;
       } else {
@@ -13131,7 +13132,7 @@
       }
     }
     stateInClosingTagName(c) {
-      if (c === CharCodes.Gt || isWhitespace(c)) {
+      if (c === CharCodes.Gt || isWhitespace$1(c)) {
         this.cbs.onclosetag(this.sectionStart, this.index);
         this.sectionStart = -1;
         this.state = State.AfterClosingTagName;
@@ -13156,7 +13157,7 @@
         this.sectionStart = this.index + 1;
       } else if (c === CharCodes.Slash) {
         this.state = State.InSelfClosingTag;
-      } else if (!isWhitespace(c)) {
+      } else if (!isWhitespace$1(c)) {
         this.state = State.InAttributeName;
         this.sectionStart = this.index;
       }
@@ -13167,7 +13168,7 @@
         this.state = State.Text;
         this.sectionStart = this.index + 1;
         this.isSpecial = false;
-      } else if (!isWhitespace(c)) {
+      } else if (!isWhitespace$1(c)) {
         this.state = State.BeforeAttributeName;
         this.stateBeforeAttributeName(c);
       }
@@ -13188,7 +13189,7 @@
         this.sectionStart = -1;
         this.state = State.BeforeAttributeName;
         this.stateBeforeAttributeName(c);
-      } else if (!isWhitespace(c)) {
+      } else if (!isWhitespace$1(c)) {
         this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);
         this.state = State.InAttributeName;
         this.sectionStart = this.index;
@@ -13201,7 +13202,7 @@
       } else if (c === CharCodes.SingleQuote) {
         this.state = State.InAttributeValueSq;
         this.sectionStart = this.index + 1;
-      } else if (!isWhitespace(c)) {
+      } else if (!isWhitespace$1(c)) {
         this.sectionStart = this.index;
         this.state = State.InAttributeValueNq;
         this.stateInAttributeValueNoQuotes(c);
@@ -13224,7 +13225,7 @@
       this.handleInAttributeValue(c, CharCodes.SingleQuote);
     }
     stateInAttributeValueNoQuotes(c) {
-      if (isWhitespace(c) || c === CharCodes.Gt) {
+      if (isWhitespace$1(c) || c === CharCodes.Gt) {
         this.cbs.onattribdata(this.sectionStart, this.index);
         this.sectionStart = -1;
         this.cbs.onattribend(QuoteType.Unquoted, this.index);
@@ -15057,9 +15058,9 @@
     return -1;
   };
   Ruler.prototype.__compile__ = function() {
-    const self = this;
+    const self2 = this;
     const chains = [""];
-    self.__rules__.forEach(function(rule) {
+    self2.__rules__.forEach(function(rule) {
       if (!rule.enabled) {
         return;
       }
@@ -15069,17 +15070,17 @@
         }
       });
     });
-    self.__cache__ = {};
+    self2.__cache__ = {};
     chains.forEach(function(chain) {
-      self.__cache__[chain] = [];
-      self.__rules__.forEach(function(rule) {
+      self2.__cache__[chain] = [];
+      self2.__rules__.forEach(function(rule) {
         if (!rule.enabled) {
           return;
         }
         if (chain && rule.alt.indexOf(chain) < 0) {
           return;
         }
-        self.__cache__[chain].push(rule.fn);
+        self2.__cache__[chain].push(rule.fn);
       });
     });
   };
@@ -18024,16 +18025,16 @@
   }
   const defaultSchemas = {
     "http:": {
-      validate: function(text2, pos, self) {
+      validate: function(text2, pos, self2) {
         const tail = text2.slice(pos);
-        if (!self.re.http) {
-          self.re.http = new RegExp(
-            "^\\/\\/" + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path,
+        if (!self2.re.http) {
+          self2.re.http = new RegExp(
+            "^\\/\\/" + self2.re.src_auth + self2.re.src_host_port_strict + self2.re.src_path,
             "i"
           );
         }
-        if (self.re.http.test(tail)) {
-          return tail.match(self.re.http)[0].length;
+        if (self2.re.http.test(tail)) {
+          return tail.match(self2.re.http)[0].length;
         }
         return 0;
       }
@@ -18041,39 +18042,39 @@
     "https:": "http:",
     "ftp:": "http:",
     "//": {
-      validate: function(text2, pos, self) {
+      validate: function(text2, pos, self2) {
         const tail = text2.slice(pos);
-        if (!self.re.no_http) {
-          self.re.no_http = new RegExp(
-            "^" + self.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
+        if (!self2.re.no_http) {
+          self2.re.no_http = new RegExp(
+            "^" + self2.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
             // with code comments
-            "(?:localhost|(?:(?:" + self.re.src_domain + ")\\.)+" + self.re.src_domain_root + ")" + self.re.src_port + self.re.src_host_terminator + self.re.src_path,
+            "(?:localhost|(?:(?:" + self2.re.src_domain + ")\\.)+" + self2.re.src_domain_root + ")" + self2.re.src_port + self2.re.src_host_terminator + self2.re.src_path,
             "i"
           );
         }
-        if (self.re.no_http.test(tail)) {
+        if (self2.re.no_http.test(tail)) {
           if (pos >= 3 && text2[pos - 3] === ":") {
             return 0;
           }
           if (pos >= 3 && text2[pos - 3] === "/") {
             return 0;
           }
-          return tail.match(self.re.no_http)[0].length;
+          return tail.match(self2.re.no_http)[0].length;
         }
         return 0;
       }
     },
     "mailto:": {
-      validate: function(text2, pos, self) {
+      validate: function(text2, pos, self2) {
         const tail = text2.slice(pos);
-        if (!self.re.mailto) {
-          self.re.mailto = new RegExp(
-            "^" + self.re.src_email_name + "@" + self.re.src_host_strict,
+        if (!self2.re.mailto) {
+          self2.re.mailto = new RegExp(
+            "^" + self2.re.src_email_name + "@" + self2.re.src_host_strict,
             "i"
           );
         }
-        if (self.re.mailto.test(tail)) {
-          return tail.match(self.re.mailto)[0].length;
+        if (self2.re.mailto.test(tail)) {
+          return tail.match(self2.re.mailto)[0].length;
         }
         return 0;
       }
@@ -18081,9 +18082,9 @@
   };
   const tlds_2ch_src_re = "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
   const tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф".split("|");
-  function resetScanCache(self) {
-    self.__index__ = -1;
-    self.__text_cache__ = "";
+  function resetScanCache(self2) {
+    self2.__index__ = -1;
+    self2.__text_cache__ = "";
   }
   function createValidator(re) {
     return function(text2, pos) {
@@ -18095,15 +18096,15 @@
     };
   }
   function createNormalizer() {
-    return function(match, self) {
-      self.normalize(match);
+    return function(match, self2) {
+      self2.normalize(match);
     };
   }
-  function compile(self) {
-    const re = self.re = reFactory(self.__opts__);
-    const tlds = self.__tlds__.slice();
-    self.onCompile();
-    if (!self.__tlds_replaced__) {
+  function compile(self2) {
+    const re = self2.re = reFactory(self2.__opts__);
+    const tlds = self2.__tlds__.slice();
+    self2.onCompile();
+    if (!self2.__tlds_replaced__) {
       tlds.push(tlds_2ch_src_re);
     }
     tlds.push(re.src_xn);
@@ -18116,17 +18117,17 @@
     re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
     re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
     const aliases2 = [];
-    self.__compiled__ = {};
+    self2.__compiled__ = {};
     function schemaError(name2, val2) {
       throw new Error('(LinkifyIt) Invalid schema "' + name2 + '": ' + val2);
     }
-    Object.keys(self.__schemas__).forEach(function(name2) {
-      const val2 = self.__schemas__[name2];
+    Object.keys(self2.__schemas__).forEach(function(name2) {
+      const val2 = self2.__schemas__[name2];
       if (val2 === null) {
         return;
       }
       const compiled = { validate: null, link: null };
-      self.__compiled__[name2] = compiled;
+      self2.__compiled__[name2] = compiled;
       if (isObject(val2)) {
         if (isRegExp(val2.validate)) {
           compiled.validate = createValidator(val2.validate);
@@ -18151,39 +18152,39 @@
       schemaError(name2, val2);
     });
     aliases2.forEach(function(alias) {
-      if (!self.__compiled__[self.__schemas__[alias]]) {
+      if (!self2.__compiled__[self2.__schemas__[alias]]) {
         return;
       }
-      self.__compiled__[alias].validate = self.__compiled__[self.__schemas__[alias]].validate;
-      self.__compiled__[alias].normalize = self.__compiled__[self.__schemas__[alias]].normalize;
+      self2.__compiled__[alias].validate = self2.__compiled__[self2.__schemas__[alias]].validate;
+      self2.__compiled__[alias].normalize = self2.__compiled__[self2.__schemas__[alias]].normalize;
     });
-    self.__compiled__[""] = { validate: null, normalize: createNormalizer() };
-    const slist = Object.keys(self.__compiled__).filter(function(name2) {
-      return name2.length > 0 && self.__compiled__[name2];
+    self2.__compiled__[""] = { validate: null, normalize: createNormalizer() };
+    const slist = Object.keys(self2.__compiled__).filter(function(name2) {
+      return name2.length > 0 && self2.__compiled__[name2];
     }).map(escapeRE).join("|");
-    self.re.schema_test = RegExp("(^|(?!_)(?:[><｜]|" + re.src_ZPCc + "))(" + slist + ")", "i");
-    self.re.schema_search = RegExp("(^|(?!_)(?:[><｜]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
-    self.re.schema_at_start = RegExp("^" + self.re.schema_search.source, "i");
-    self.re.pretest = RegExp(
-      "(" + self.re.schema_test.source + ")|(" + self.re.host_fuzzy_test.source + ")|@",
+    self2.re.schema_test = RegExp("(^|(?!_)(?:[><｜]|" + re.src_ZPCc + "))(" + slist + ")", "i");
+    self2.re.schema_search = RegExp("(^|(?!_)(?:[><｜]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
+    self2.re.schema_at_start = RegExp("^" + self2.re.schema_search.source, "i");
+    self2.re.pretest = RegExp(
+      "(" + self2.re.schema_test.source + ")|(" + self2.re.host_fuzzy_test.source + ")|@",
       "i"
     );
-    resetScanCache(self);
+    resetScanCache(self2);
   }
-  function Match(self, shift) {
-    const start = self.__index__;
-    const end2 = self.__last_index__;
-    const text2 = self.__text_cache__.slice(start, end2);
-    this.schema = self.__schema__.toLowerCase();
+  function Match(self2, shift) {
+    const start = self2.__index__;
+    const end2 = self2.__last_index__;
+    const text2 = self2.__text_cache__.slice(start, end2);
+    this.schema = self2.__schema__.toLowerCase();
     this.index = start + shift;
     this.lastIndex = end2 + shift;
     this.raw = text2;
     this.text = text2;
     this.url = text2;
   }
-  function createMatch(self, shift) {
-    const match = new Match(self, shift);
-    self.__compiled__[match.schema].normalize(match, self);
+  function createMatch(self2, shift) {
+    const match = new Match(self2, shift);
+    self2.__compiled__[match.schema].normalize(match, self2);
     return match;
   }
   function LinkifyIt(schemas2, options) {
@@ -18798,7 +18799,7 @@
     return this;
   };
   MarkdownIt.prototype.configure = function(presets) {
-    const self = this;
+    const self2 = this;
     if (isString$1(presets)) {
       const presetName = presets;
       presets = config$2[presetName];
@@ -18810,15 +18811,15 @@
       throw new Error("Wrong `markdown-it` preset, can't be empty");
     }
     if (presets.options) {
-      self.set(presets.options);
+      self2.set(presets.options);
     }
     if (presets.components) {
       Object.keys(presets.components).forEach(function(name2) {
         if (presets.components[name2].rules) {
-          self[name2].ruler.enableOnly(presets.components[name2].rules);
+          self2[name2].ruler.enableOnly(presets.components[name2].rules);
         }
         if (presets.components[name2].rules2) {
-          self[name2].ruler2.enableOnly(presets.components[name2].rules2);
+          self2[name2].ruler2.enableOnly(presets.components[name2].rules2);
         }
       });
     }
@@ -25280,28 +25281,56 @@ ${end2.comment}` : end2.comment;
       };
     }
   });
-  var katex = require$$0;
-  function isValidDelim(state, pos) {
-    var prevChar, nextChar, max = state.posMax, can_open = true, can_close = true;
-    prevChar = pos > 0 ? state.src.charCodeAt(pos - 1) : -1;
-    nextChar = pos + 1 <= max ? state.src.charCodeAt(pos + 1) : -1;
-    if (prevChar === 32 || prevChar === 9 || nextChar >= 48 && nextChar <= 57) {
-      can_close = false;
-    }
-    if (nextChar === 32 || nextChar === 9) {
-      can_open = false;
-    }
-    return {
-      can_open,
-      can_close
-    };
-  }
-  function math_inline(state, silent) {
-    var start, match, token, res, pos;
+  var dist = {};
+  var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(dist, "__esModule", { value: true });
+  const katex_1 = __importDefault(require$$0);
+  function isValidInlineDelim(state, pos) {
+    const prevChar = state.src[pos - 1];
+    const char = state.src[pos];
+    const nextChar = state.src[pos + 1];
+    if (char !== "$") {
+      return { can_open: false, can_close: false };
+    }
+    let canOpen = false;
+    let canClose = false;
+    if (prevChar !== "$" && prevChar !== "\\" && (prevChar === void 0 || isWhitespace(prevChar) || !isWordCharacterOrNumber(prevChar))) {
+      canOpen = true;
+    }
+    if (nextChar !== "$" && (nextChar == void 0 || isWhitespace(nextChar) || !isWordCharacterOrNumber(nextChar))) {
+      canClose = true;
+    }
+    return { can_open: canOpen, can_close: canClose };
+  }
+  function isWhitespace(char) {
+    return /^\s$/u.test(char);
+  }
+  function isWordCharacterOrNumber(char) {
+    return /^[\w\d]$/u.test(char);
+  }
+  function isValidBlockDelim(state, pos) {
+    const prevChar = state.src[pos - 1];
+    const char = state.src[pos];
+    const nextChar = state.src[pos + 1];
+    const nextCharPlus1 = state.src[pos + 2];
+    if (char === "$" && prevChar !== "$" && prevChar !== "\\" && nextChar === "$" && nextCharPlus1 !== "$") {
+      return { can_open: true, can_close: true };
+    }
+    return { can_open: false, can_close: false };
+  }
+  function inlineMath(state, silent) {
     if (state.src[state.pos] !== "$") {
       return false;
     }
-    res = isValidDelim(state, state.pos);
+    const lastToken = state.tokens.at(-1);
+    if ((lastToken == null ? void 0 : lastToken.type) === "html_inline") {
+      if (/^<\w+.+[^/]>$/.test(lastToken.content)) {
+        return false;
+      }
+    }
+    let res = isValidInlineDelim(state, state.pos);
     if (!res.can_open) {
       if (!silent) {
         state.pending += "$";
@@ -25309,8 +25338,9 @@ ${end2.comment}` : end2.comment;
       state.pos += 1;
       return true;
     }
-    start = state.pos + 1;
-    match = start;
+    let start = state.pos + 1;
+    let match = start;
+    let pos;
     while ((match = state.src.indexOf("$", match)) !== -1) {
       pos = match - 1;
       while (state.src[pos] === "\\") {
@@ -25335,7 +25365,7 @@ ${end2.comment}` : end2.comment;
       state.pos = start + 1;
       return true;
     }
-    res = isValidDelim(state, match);
+    res = isValidInlineDelim(state, match);
     if (!res.can_close) {
       if (!silent) {
         state.pending += "$";
@@ -25344,15 +25374,15 @@ ${end2.comment}` : end2.comment;
       return true;
     }
     if (!silent) {
-      token = state.push("math_inline", "math", 0);
+      const token = state.push("math_inline", "math", 0);
       token.markup = "$";
       token.content = state.src.slice(start, match);
     }
     state.pos = match + 1;
     return true;
   }
-  function math_block(state, start, end2, silent) {
-    var firstLine, lastLine, next2, lastPos, found = false, token, pos = state.bMarks[start] + state.tShift[start], max = state.eMarks[start];
+  function blockMath(state, start, end2, silent) {
+    var lastLine, next2, lastPos, found = false, token, pos = state.bMarks[start] + state.tShift[start], max = state.eMarks[start];
     if (pos + 2 > max) {
       return false;
     }
@@ -25360,7 +25390,7 @@ ${end2.comment}` : end2.comment;
       return false;
     }
     pos += 2;
-    firstLine = state.src.slice(pos, max);
+    let firstLine = state.src.slice(pos, max);
     if (silent) {
       return true;
     }
@@ -25382,6 +25412,10 @@ ${end2.comment}` : end2.comment;
         lastPos = state.src.slice(0, max).lastIndexOf("$$");
         lastLine = state.src.slice(pos, lastPos);
         found = true;
+      } else if (state.src.slice(pos, max).trim().includes("$$")) {
+        lastPos = state.src.slice(0, max).trim().indexOf("$$");
+        lastLine = state.src.slice(pos, lastPos);
+        found = true;
       }
     }
     state.line = next2 + 1;
@@ -25392,47 +25426,271 @@ ${end2.comment}` : end2.comment;
     token.markup = "$$";
     return true;
   }
+  function blockBareMath(state, start, end2, silent) {
+    const startPos = state.bMarks[start] + state.tShift[start];
+    const startMax = state.eMarks[start];
+    const firstLine = state.src.slice(startPos, startMax);
+    const beginMatch = firstLine.match(/^\s*\\begin\s*\{([^{}]+)\}/);
+    if (!beginMatch) {
+      return false;
+    }
+    if (start > 0) {
+      const previousStart = state.bMarks[start - 1] + state.tShift[start - 1];
+      const previousEnd = state.eMarks[start - 1];
+      const previousLine = state.src.slice(previousStart, previousEnd);
+      if (!/^\s*$/.test(previousLine)) {
+        return false;
+      }
+    }
+    if (silent) {
+      return true;
+    }
+    const beginEndStack = [];
+    let next2 = start;
+    let lastLine;
+    let found = false;
+    outer: for (; !found; next2++) {
+      if (next2 >= end2) {
+        break;
+      }
+      const pos = state.bMarks[next2] + state.tShift[next2];
+      const max = state.eMarks[next2];
+      if (pos < max && state.tShift[next2] < state.blkIndent) {
+        break;
+      }
+      const line = state.src.slice(pos, max);
+      for (const match of line.matchAll(/(\\begin|\\end)\s*\{([^{}]+)\}/g)) {
+        if (match[1] === "\\begin") {
+          beginEndStack.push(match[2].trim());
+        } else if (match[1] === "\\end") {
+          beginEndStack.pop();
+          if (!beginEndStack.length) {
+            lastLine = state.src.slice(pos, max);
+            found = true;
+            break outer;
+          }
+        }
+      }
+    }
+    state.line = next2 + 1;
+    const token = state.push("math_block", "math", 0);
+    token.block = true;
+    token.content = (state.getLines(start, next2, state.tShift[start], true) + (lastLine ?? "")).trim();
+    token.map = [start, state.line];
+    token.markup = "$$";
+    return true;
+  }
+  function inlineMathBlock(state, silent) {
+    var start, match, token, res, pos;
+    if (state.src.slice(state.pos, state.pos + 2) !== "$$") {
+      return false;
+    }
+    res = isValidBlockDelim(state, state.pos);
+    if (!res.can_open) {
+      if (!silent) {
+        state.pending += "$$";
+      }
+      state.pos += 2;
+      return true;
+    }
+    start = state.pos + 2;
+    match = start;
+    while ((match = state.src.indexOf("$$", match)) !== -1) {
+      pos = match - 1;
+      while (state.src[pos] === "\\") {
+        pos -= 1;
+      }
+      if ((match - pos) % 2 == 1) {
+        break;
+      }
+      match += 2;
+    }
+    if (match === -1) {
+      if (!silent) {
+        state.pending += "$$";
+      }
+      state.pos = start;
+      return true;
+    }
+    if (match - start === 0) {
+      if (!silent) {
+        state.pending += "$$$$";
+      }
+      state.pos = start + 2;
+      return true;
+    }
+    res = isValidBlockDelim(state, match);
+    if (!res.can_close) {
+      if (!silent) {
+        state.pending += "$$";
+      }
+      state.pos = start;
+      return true;
+    }
+    if (!silent) {
+      token = state.push("math_block", "math", 0);
+      token.block = true;
+      token.markup = "$$";
+      token.content = state.src.slice(start, match);
+    }
+    state.pos = match + 2;
+    return true;
+  }
+  function inlineBareBlock(state, silent) {
+    const text2 = state.src.slice(state.pos);
+    if (!/^\n\\begin/.test(text2)) {
+      return false;
+    }
+    state.pos += 1;
+    if (silent) {
+      return true;
+    }
+    const lines = text2.split(/\n/g).slice(1);
+    let foundLine;
+    const beginEndStack = [];
+    outer: for (var i = 0; i < lines.length; ++i) {
+      const line = lines[i];
+      for (const match of line.matchAll(/(\\begin|\\end)\s*\{([^{}]+)\}/g)) {
+        if (match[1] === "\\begin") {
+          beginEndStack.push(match[2].trim());
+        } else if (match[1] === "\\end") {
+          beginEndStack.pop();
+          if (!beginEndStack.length) {
+            foundLine = i;
+            break outer;
+          }
+        }
+      }
+    }
+    if (typeof foundLine === "undefined") {
+      return false;
+    }
+    const endIndex = lines.slice(0, foundLine + 1).reduce((p, c) => p + c.length, 0) + foundLine + 1;
+    const token = state.push("math_inline_bare_block", "math", 0);
+    token.block = true;
+    token.markup = "$$";
+    token.content = text2.slice(1, endIndex);
+    state.pos = state.pos + endIndex;
+    return true;
+  }
+  function handleMathInHtml(state, mathType, mathMarkup, mathRegex) {
+    const tokens = state.tokens;
+    for (let index2 = tokens.length - 1; index2 >= 0; index2--) {
+      const currentToken = tokens[index2];
+      const newTokens = [];
+      if (currentToken.type !== "html_block") {
+        continue;
+      }
+      const content = currentToken.content;
+      for (const match of content.matchAll(mathRegex)) {
+        if (!match.groups) {
+          continue;
+        }
+        const html_before_math = match.groups.html_before_math;
+        const math = match.groups.math;
+        const html_after_math = match.groups.html_after_math;
+        if (html_before_math) {
+          newTokens.push({ ...currentToken, type: "html_block", map: null, content: html_before_math });
+        }
+        if (math) {
+          newTokens.push({
+            ...currentToken,
+            type: mathType,
+            map: null,
+            content: math,
+            markup: mathMarkup,
+            block: true,
+            tag: "math"
+          });
+        }
+        if (html_after_math) {
+          newTokens.push({ ...currentToken, type: "html_block", map: null, content: html_after_math });
+        }
+      }
+      if (newTokens.length > 0) {
+        tokens.splice(index2, 1, ...newTokens);
+      }
+    }
+    return true;
+  }
   function escapeHtml(unsafe) {
     return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
   }
-  var markdownItKatex = function math_plugin(md, options) {
-    options = options || {};
-    var katexInline = function(latex) {
-      options.displayMode = false;
+  function default_1(md, options) {
+    const enableBareBlocks = options == null ? void 0 : options.enableBareBlocks;
+    const enableMathBlockInHtml = options == null ? void 0 : options.enableMathBlockInHtml;
+    const enableMathInlineInHtml = options == null ? void 0 : options.enableMathInlineInHtml;
+    const enableFencedBlocks = options == null ? void 0 : options.enableFencedBlocks;
+    md.inline.ruler.after("escape", "math_inline", inlineMath);
+    md.inline.ruler.after("escape", "math_inline_block", inlineMathBlock);
+    if (enableBareBlocks) {
+      md.inline.ruler.before("text", "math_inline_bare_block", inlineBareBlock);
+    }
+    md.block.ruler.after("blockquote", "math_block", (state, start, end2, silent) => {
+      if (enableBareBlocks && blockBareMath(state, start, end2, silent)) {
+        return true;
+      }
+      return blockMath(state, start, end2, silent);
+    }, {
+      alt: ["paragraph", "reference", "blockquote", "list"]
+    });
+    const math_block_within_html_regex = /(?<html_before_math>[\s\S]*?)\$\$(?<math>[\s\S]+?)\$\$(?<html_after_math>(?:(?!\$\$[\s\S]+?\$\$)[\s\S])*)/gm;
+    const math_inline_within_html_regex = /(?<html_before_math>[\s\S]*?)\$(?<math>.*?)\$(?<html_after_math>(?:(?!\$.*?\$)[\s\S])*)/gm;
+    if (enableMathBlockInHtml) {
+      md.core.ruler.push("math_block_in_html_block", (state) => {
+        return handleMathInHtml(state, "math_block", "$$", math_block_within_html_regex);
+      });
+    }
+    if (enableMathInlineInHtml) {
+      md.core.ruler.push("math_inline_in_html_block", (state) => {
+        return handleMathInHtml(state, "math_inline", "$", math_inline_within_html_regex);
+      });
+    }
+    const katexInline = (latex) => {
+      const displayMode = /\\begin\{(align|equation|gather|cd|alignat)\}/ig.test(latex);
       try {
-        return katex.renderToString(latex, options);
+        return katex_1.default.renderToString(latex, { ...options, displayMode });
       } catch (error2) {
-        if (options.throwOnError) {
+        if (options == null ? void 0 : options.throwOnError) {
           console.log(error2);
         }
-        return `<span class='katex-error' title='${escapeHtml(error2.toString())}'>${escapeHtml(latex)}</span>`;
+        return `<span class="katex-error" title="${escapeHtml(latex)}">${escapeHtml(error2 + "")}</span>`;
       }
     };
-    var inlineRenderer = function(tokens, idx) {
+    const inlineRenderer = (tokens, idx) => {
       return katexInline(tokens[idx].content);
     };
-    var katexBlock = function(latex) {
-      options.displayMode = true;
+    const katexBlockRenderer = (latex) => {
       try {
-        return "<p class='katex-block'>" + katex.renderToString(latex, options) + "</p>";
+        return `<p class="katex-block">${katex_1.default.renderToString(latex, { ...options, displayMode: true })}</p>`;
       } catch (error2) {
-        if (options.throwOnError) {
+        if (options == null ? void 0 : options.throwOnError) {
           console.log(error2);
         }
-        return `<p class='katex-block katex-error' title='${escapeHtml(error2.toString())}'>${escapeHtml(latex)}</p>`;
+        return `<p class="katex-block katex-error" title="${escapeHtml(latex)}">${escapeHtml(error2 + "")}</p>`;
       }
     };
-    var blockRenderer = function(tokens, idx) {
-      return katexBlock(tokens[idx].content) + "\n";
+    const blockRenderer = (tokens, idx) => {
+      return katexBlockRenderer(tokens[idx].content) + "\n";
     };
-    md.inline.ruler.after("escape", "math_inline", math_inline);
-    md.block.ruler.after("blockquote", "math_block", math_block, {
-      alt: ["paragraph", "reference", "blockquote", "list"]
-    });
     md.renderer.rules.math_inline = inlineRenderer;
+    md.renderer.rules.math_inline_block = blockRenderer;
+    md.renderer.rules.math_inline_bare_block = blockRenderer;
     md.renderer.rules.math_block = blockRenderer;
-  };
-  const katexPlugin = /* @__PURE__ */ getDefaultExportFromCjs(markdownItKatex);
+    if (enableFencedBlocks) {
+      const mathLanguageId = "math";
+      const originalFenceRenderer = md.renderer.rules.fence;
+      md.renderer.rules.fence = function(tokens, idx, options2, env, self2) {
+        const token = tokens[idx];
+        if (token.info.trim().toLowerCase() === mathLanguageId && enableFencedBlocks) {
+          return katexBlockRenderer(token.content) + "\n";
+        } else {
+          return (originalFenceRenderer == null ? void 0 : originalFenceRenderer.call(this, tokens, idx, options2, env, self2)) || "";
+        }
+      };
+    }
+  }
+  var _default = dist.default = default_1;
   function addDefaultVersions(paths, name2, version) {
     return paths.map((path) => {
       if (typeof path === "string" && !path.includes("://")) {
@@ -25516,9 +25774,9 @@ ${end2.comment}` : end2.comment;
         return loading;
       };
       const renderKatex = (source, displayMode) => {
-        const { katex: katex2 } = window;
-        if (katex2) {
-          return katex2.renderToString(source, {
+        const { katex } = window;
+        if (katex) {
+          return katex.renderToString(source, {
             displayMode,
             throwOnError: false
           });
@@ -25530,7 +25788,7 @@ ${end2.comment}` : end2.comment;
       };
       let enableFeature = noop;
       transformHooks.parser.tap((md) => {
-        md.use(katexPlugin);
+        md.use(_default);
         ["math_block", "math_inline"].forEach((key) => {
           const fn = (tokens, idx) => {
             enableFeature();
@@ -25696,7 +25954,7 @@ ${end2.comment}` : end2.comment;
     }
   }
   const transformerVersions = {
-    "markmap-lib": "0.17.3-alpha.2"
+    "markmap-lib": "0.17.3-alpha.3"
   };
   exports.Transformer = Transformer;
   exports.builtInPlugins = builtInPlugins;

package/dist/browser/index.mjs

@@ -6,7 +6,7 @@ import md_mark from "markdown-it-mark";
 import md_sub from "markdown-it-sub";
 import md_sup from "markdown-it-sup";
 import { parse } from "yaml";
-import require$$0 from "katex";
+import katexPlugin from "@vscode/markdown-it-katex";
 function initializeMarkdownIt() {
   const md = MarkdownIt({
     html: true,
@@ -189,162 +189,6 @@ const plugin$2 = definePlugin({
     };
   }
 });
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-var katex = require$$0;
-function isValidDelim(state, pos) {
-  var prevChar, nextChar, max = state.posMax, can_open = true, can_close = true;
-  prevChar = pos > 0 ? state.src.charCodeAt(pos - 1) : -1;
-  nextChar = pos + 1 <= max ? state.src.charCodeAt(pos + 1) : -1;
-  if (prevChar === 32 || prevChar === 9 || nextChar >= 48 && nextChar <= 57) {
-    can_close = false;
-  }
-  if (nextChar === 32 || nextChar === 9) {
-    can_open = false;
-  }
-  return {
-    can_open,
-    can_close
-  };
-}
-function math_inline(state, silent) {
-  var start, match, token, res, pos;
-  if (state.src[state.pos] !== "$") {
-    return false;
-  }
-  res = isValidDelim(state, state.pos);
-  if (!res.can_open) {
-    if (!silent) {
-      state.pending += "$";
-    }
-    state.pos += 1;
-    return true;
-  }
-  start = state.pos + 1;
-  match = start;
-  while ((match = state.src.indexOf("$", match)) !== -1) {
-    pos = match - 1;
-    while (state.src[pos] === "\\") {
-      pos -= 1;
-    }
-    if ((match - pos) % 2 == 1) {
-      break;
-    }
-    match += 1;
-  }
-  if (match === -1) {
-    if (!silent) {
-      state.pending += "$";
-    }
-    state.pos = start;
-    return true;
-  }
-  if (match - start === 0) {
-    if (!silent) {
-      state.pending += "$$";
-    }
-    state.pos = start + 1;
-    return true;
-  }
-  res = isValidDelim(state, match);
-  if (!res.can_close) {
-    if (!silent) {
-      state.pending += "$";
-    }
-    state.pos = start;
-    return true;
-  }
-  if (!silent) {
-    token = state.push("math_inline", "math", 0);
-    token.markup = "$";
-    token.content = state.src.slice(start, match);
-  }
-  state.pos = match + 1;
-  return true;
-}
-function math_block(state, start, end, silent) {
-  var firstLine, lastLine, next, lastPos, found = false, token, pos = state.bMarks[start] + state.tShift[start], max = state.eMarks[start];
-  if (pos + 2 > max) {
-    return false;
-  }
-  if (state.src.slice(pos, pos + 2) !== "$$") {
-    return false;
-  }
-  pos += 2;
-  firstLine = state.src.slice(pos, max);
-  if (silent) {
-    return true;
-  }
-  if (firstLine.trim().slice(-2) === "$$") {
-    firstLine = firstLine.trim().slice(0, -2);
-    found = true;
-  }
-  for (next = start; !found; ) {
-    next++;
-    if (next >= end) {
-      break;
-    }
-    pos = state.bMarks[next] + state.tShift[next];
-    max = state.eMarks[next];
-    if (pos < max && state.tShift[next] < state.blkIndent) {
-      break;
-    }
-    if (state.src.slice(pos, max).trim().slice(-2) === "$$") {
-      lastPos = state.src.slice(0, max).lastIndexOf("$$");
-      lastLine = state.src.slice(pos, lastPos);
-      found = true;
-    }
-  }
-  state.line = next + 1;
-  token = state.push("math_block", "math", 0);
-  token.block = true;
-  token.content = (firstLine && firstLine.trim() ? firstLine + "\n" : "") + state.getLines(start + 1, next, state.tShift[start], true) + (lastLine && lastLine.trim() ? lastLine : "");
-  token.map = [start, state.line];
-  token.markup = "$$";
-  return true;
-}
-function escapeHtml(unsafe) {
-  return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-var markdownItKatex = function math_plugin(md, options) {
-  options = options || {};
-  var katexInline = function(latex) {
-    options.displayMode = false;
-    try {
-      return katex.renderToString(latex, options);
-    } catch (error) {
-      if (options.throwOnError) {
-        console.log(error);
-      }
-      return `<span class='katex-error' title='${escapeHtml(error.toString())}'>${escapeHtml(latex)}</span>`;
-    }
-  };
-  var inlineRenderer = function(tokens, idx) {
-    return katexInline(tokens[idx].content);
-  };
-  var katexBlock = function(latex) {
-    options.displayMode = true;
-    try {
-      return "<p class='katex-block'>" + katex.renderToString(latex, options) + "</p>";
-    } catch (error) {
-      if (options.throwOnError) {
-        console.log(error);
-      }
-      return `<p class='katex-block katex-error' title='${escapeHtml(error.toString())}'>${escapeHtml(latex)}</p>`;
-    }
-  };
-  var blockRenderer = function(tokens, idx) {
-    return katexBlock(tokens[idx].content) + "\n";
-  };
-  md.inline.ruler.after("escape", "math_inline", math_inline);
-  md.block.ruler.after("blockquote", "math_block", math_block, {
-    alt: ["paragraph", "reference", "blockquote", "list"]
-  });
-  md.renderer.rules.math_inline = inlineRenderer;
-  md.renderer.rules.math_block = blockRenderer;
-};
-const katexPlugin = /* @__PURE__ */ getDefaultExportFromCjs(markdownItKatex);
 function addDefaultVersions(paths, name2, version) {
   return paths.map((path) => {
     if (typeof path === "string" && !path.includes("://")) {
@@ -428,9 +272,9 @@ const plugin$1 = definePlugin({
       return loading;
     };
     const renderKatex = (source, displayMode) => {
-      const { katex: katex2 } = window;
-      if (katex2) {
-        return katex2.renderToString(source, {
+      const { katex } = window;
+      if (katex) {
+        return katex.renderToString(source, {
           displayMode,
           throwOnError: false
         });
@@ -608,7 +452,7 @@ class Transformer {
   }
 }
 const transformerVersions = {
-  "markmap-lib": "0.17.3-alpha.2"
+  "markmap-lib": "0.17.3-alpha.3"
 };
 export {
   Transformer,

package/dist/index.js

@@ -115,7 +115,7 @@ class Transformer {
   }
 }
 const transformerVersions = {
-  "markmap-lib": "0.17.3-alpha.2"
+  "markmap-lib": "0.17.3-alpha.3"
 };
 exports.Transformer = Transformer;
 exports.builtInPlugins = builtInPlugins;

package/dist/index.mjs

@@ -113,7 +113,7 @@ class Transformer {
   }
 }
 const transformerVersions = {
-  "markmap-lib": "0.17.3-alpha.2"
+  "markmap-lib": "0.17.3-alpha.3"
 };
 export {
   Transformer,

package/dist/index.no-plugins.js

@@ -123,7 +123,7 @@ class Transformer {
   }
 }
 const transformerVersions = {
-  "markmap-lib": "0.17.3-alpha.2"
+  "markmap-lib": "0.17.3-alpha.3"
 };
 exports.Transformer = Transformer;
 exports.builtInPlugins = builtInPlugins;

package/dist/index.no-plugins.mjs

@@ -121,7 +121,7 @@ class Transformer {
   }
 }
 const transformerVersions = {
-  "markmap-lib": "0.17.3-alpha.2"
+  "markmap-lib": "0.17.3-alpha.3"
 };
 export {
   Transformer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markmap-lib",
-  "version": "0.17.3-alpha.2+9f2920f",
+  "version": "0.17.3-alpha.3+89ad076",
   "description": "Visualize your Markdown as mindmaps with Markmap",
   "author": "Gerald <gera2ld@live.com>",
   "license": "MIT",
@@ -61,7 +61,7 @@
     "@highlightjs/cdn-assets": "^11.8.0",
     "@types/katex": "^0.16.7",
     "@types/markdown-it": "^14.0.0",
-    "markmap-common": "0.17.1",
+    "markmap-common": "0.17.3-alpha.3+89ad076",
     "webfontloader": "^1.6.28"
   },
   "dependencies": {
@@ -74,8 +74,8 @@
     "markdown-it-mark": "^4.0.0",
     "markdown-it-sub": "^2.0.0",
     "markdown-it-sup": "^2.0.0",
-    "markmap-html-parser": "0.17.3-alpha.2+9f2920f",
-    "markmap-view": "0.17.2",
+    "markmap-html-parser": "0.17.3-alpha.3+89ad076",
+    "markmap-view": "0.17.3-alpha.3+89ad076",
     "prismjs": "^1.29.0",
     "yaml": "^2.5.1"
   },
@@ -96,5 +96,5 @@
       "^(.*\\.svg)\\?raw$": "$1"
     }
   },
-  "gitHead": "9f2920fcb10e39ca7bf714c8768539bf60357752"
+  "gitHead": "89ad076e313dd4c126aeafc49f052315755e8c0d"
 }