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

package/dist/browser/index.iife.js

@@ -1116,6 +1116,7 @@
         case EntityDecoderState.NamedEntity: {
           return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
         }
+        // Otherwise, emit a numeric entity if we have one.
         case EntityDecoderState.NumericDecimal: {
           return this.emitNumericEntity(0, 2);
         }
@@ -1410,6 +1411,7 @@
     switch (node.type) {
       case Root:
         return render$1(node.children, options);
+      // @ts-expect-error We don't use `Doctype` yet
       case Doctype:
       case Directive:
         return renderDirective(node);
@@ -2117,7 +2119,7 @@
   function extract$1(map2) {
     return this.root().extract(map2);
   }
-  function merge(arr1, arr2) {
+  function merge$1(arr1, arr2) {
     if (!isArrayLike(arr1) || !isArrayLike(arr2)) {
       return;
     }
@@ -2148,7 +2150,7 @@
     contains,
     extract: extract$1,
     html: html$1,
-    merge,
+    merge: merge$1,
     parseHTML,
     root,
     text: text$2,
@@ -2646,7 +2648,7 @@
   function isQuote(c) {
     return c === 39 || c === 34;
   }
-  function isWhitespace$3(c) {
+  function isWhitespace$2(c) {
     return c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
   }
   function parse$5(selector) {
@@ -2670,7 +2672,7 @@
     }
     function stripWhitespace(offset) {
       selectorIndex += offset;
-      while (selectorIndex < selector.length && isWhitespace$3(selector.charCodeAt(selectorIndex))) {
+      while (selectorIndex < selector.length && isWhitespace$2(selector.charCodeAt(selectorIndex))) {
         selectorIndex++;
       }
     }
@@ -2735,6 +2737,7 @@
     loop: while (selectorIndex < selector.length) {
       const firstChar = selector.charCodeAt(selectorIndex);
       switch (firstChar) {
+        // Whitespace
         case 32:
         case 9:
         case 10:
@@ -2747,6 +2750,7 @@
           stripWhitespace(1);
           break;
         }
+        // Traversals
         case 62: {
           addTraversal(SelectorType.Child);
           stripWhitespace(1);
@@ -2767,6 +2771,7 @@
           stripWhitespace(1);
           break;
         }
+        // Special attribute selectors: .class, #id
         case 46: {
           addSpecialAttribute("class", AttributeAction.Element);
           break;
@@ -2820,7 +2825,7 @@
               selectorIndex = sectionEnd + 1;
             } else {
               const valueStart = selectorIndex;
-              while (selectorIndex < selector.length && (!isWhitespace$3(selector.charCodeAt(selectorIndex)) && selector.charCodeAt(selectorIndex) !== 93 || isEscaped(selectorIndex))) {
+              while (selectorIndex < selector.length && (!isWhitespace$2(selector.charCodeAt(selectorIndex)) && selector.charCodeAt(selectorIndex) !== 93 || isEscaped(selectorIndex))) {
                 selectorIndex += 1;
               }
               value = unescapeCSS(selector.slice(valueStart, selectorIndex));
@@ -2937,19 +2942,26 @@
     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;
   }
-  var boolbase = {
-    trueFunc: function trueFunc() {
-      return true;
-    },
-    falseFunc: function falseFunc() {
-      return false;
-    }
-  };
-  const boolbase$1 = /* @__PURE__ */ getDefaultExportFromCjs(boolbase);
+  var boolbase$1;
+  var hasRequiredBoolbase;
+  function requireBoolbase() {
+    if (hasRequiredBoolbase) return boolbase$1;
+    hasRequiredBoolbase = 1;
+    boolbase$1 = {
+      trueFunc: function trueFunc() {
+        return true;
+      },
+      falseFunc: function falseFunc() {
+        return false;
+      }
+    };
+    return boolbase$1;
+  }
+  var boolbaseExports = requireBoolbase();
+  const boolbase = /* @__PURE__ */ getDefaultExportFromCjs(boolbaseExports);
   const procedure = /* @__PURE__ */ new Map([
     [SelectorType.Universal, 50],
     [SelectorType.Tag, 30],
@@ -3099,7 +3111,7 @@
       const { adapter: adapter2 } = options;
       const { name: name2, value } = data2;
       if (/\s/.test(value)) {
-        return boolbase$1.falseFunc;
+        return boolbase.falseFunc;
       }
       const regex2 = new RegExp(`(?:^|\\s)${escapeRegex(value)}(?:$|\\s)`, shouldIgnoreCase(data2, options) ? "i" : "");
       return function element(elem) {
@@ -3116,7 +3128,7 @@
       let { value } = data2;
       const len = value.length;
       if (len === 0) {
-        return boolbase$1.falseFunc;
+        return boolbase.falseFunc;
       }
       if (shouldIgnoreCase(data2, options)) {
         value = value.toLowerCase();
@@ -3136,7 +3148,7 @@
       let { value } = data2;
       const len = -value.length;
       if (len === 0) {
-        return boolbase$1.falseFunc;
+        return boolbase.falseFunc;
       }
       if (shouldIgnoreCase(data2, options)) {
         value = value.toLowerCase();
@@ -3154,7 +3166,7 @@
       const { adapter: adapter2 } = options;
       const { name: name2, value } = data2;
       if (value === "") {
-        return boolbase$1.falseFunc;
+        return boolbase.falseFunc;
       }
       if (shouldIgnoreCase(data2, options)) {
         const regex2 = new RegExp(escapeRegex(value), "i");
@@ -3243,13 +3255,13 @@
     const a = parsed[0];
     const b = parsed[1] - 1;
     if (b < 0 && a <= 0)
-      return boolbase$1.falseFunc;
+      return boolbase.falseFunc;
     if (a === -1)
       return (index2) => index2 <= b;
     if (a === 0)
       return (index2) => index2 === b;
     if (a === 1)
-      return b < 0 ? boolbase$1.trueFunc : (index2) => index2 >= b;
+      return b < 0 ? boolbase.trueFunc : (index2) => index2 >= b;
     const absA = Math.abs(a);
     const bMod = (b % absA + absA) % absA;
     return a > 1 ? (index2) => index2 >= b && index2 % absA === bMod : (index2) => index2 <= b && index2 % absA === bMod;
@@ -3278,9 +3290,9 @@
     // Location specific methods
     "nth-child"(next2, rule, { adapter: adapter2, equals }) {
       const func = nthCheck(rule);
-      if (func === boolbase$1.falseFunc)
-        return boolbase$1.falseFunc;
-      if (func === boolbase$1.trueFunc)
+      if (func === boolbase.falseFunc)
+        return boolbase.falseFunc;
+      if (func === boolbase.trueFunc)
         return getChildFunc(next2, adapter2);
       return function nthChild(elem) {
         const siblings2 = adapter2.getSiblings(elem);
@@ -3297,9 +3309,9 @@
     },
     "nth-last-child"(next2, rule, { adapter: adapter2, equals }) {
       const func = nthCheck(rule);
-      if (func === boolbase$1.falseFunc)
-        return boolbase$1.falseFunc;
-      if (func === boolbase$1.trueFunc)
+      if (func === boolbase.falseFunc)
+        return boolbase.falseFunc;
+      if (func === boolbase.trueFunc)
         return getChildFunc(next2, adapter2);
       return function nthLastChild(elem) {
         const siblings2 = adapter2.getSiblings(elem);
@@ -3316,9 +3328,9 @@
     },
     "nth-of-type"(next2, rule, { adapter: adapter2, equals }) {
       const func = nthCheck(rule);
-      if (func === boolbase$1.falseFunc)
-        return boolbase$1.falseFunc;
-      if (func === boolbase$1.trueFunc)
+      if (func === boolbase.falseFunc)
+        return boolbase.falseFunc;
+      if (func === boolbase.trueFunc)
         return getChildFunc(next2, adapter2);
       return function nthOfType(elem) {
         const siblings2 = adapter2.getSiblings(elem);
@@ -3336,9 +3348,9 @@
     },
     "nth-last-of-type"(next2, rule, { adapter: adapter2, equals }) {
       const func = nthCheck(rule);
-      if (func === boolbase$1.falseFunc)
-        return boolbase$1.falseFunc;
-      if (func === boolbase$1.trueFunc)
+      if (func === boolbase.falseFunc)
+        return boolbase.falseFunc;
+      if (func === boolbase.trueFunc)
         return getChildFunc(next2, adapter2);
       return function nthLastOfType(elem) {
         const siblings2 = adapter2.getSiblings(elem);
@@ -3379,7 +3391,7 @@
     return function dynamicPseudo(next2, _rule, { adapter: adapter2 }) {
       const func = adapter2[name2];
       if (typeof func !== "function") {
-        return boolbase$1.falseFunc;
+        return boolbase.falseFunc;
       }
       return function active(elem) {
         return func(elem) && next2(elem);
@@ -3486,8 +3498,8 @@
   };
   const PLACEHOLDER_ELEMENT = {};
   function ensureIsTag(next2, adapter2) {
-    if (next2 === boolbase$1.falseFunc)
-      return boolbase$1.falseFunc;
+    if (next2 === boolbase.falseFunc)
+      return boolbase.falseFunc;
     return (elem) => adapter2.isTag(elem) && next2(elem);
   }
   function getNextSiblings(elem, adapter2) {
@@ -3513,7 +3525,7 @@
   }
   const is$2 = (next2, token, options, context, compileToken2) => {
     const func = compileToken2(token, copyOptions(options), context);
-    return func === boolbase$1.trueFunc ? next2 : func === boolbase$1.falseFunc ? boolbase$1.falseFunc : (elem) => func(elem) && next2(elem);
+    return func === boolbase.trueFunc ? next2 : func === boolbase.falseFunc ? boolbase.falseFunc : (elem) => func(elem) && next2(elem);
   };
   const subselects = {
     is: is$2,
@@ -3524,7 +3536,7 @@
     where: is$2,
     not(next2, token, options, context, compileToken2) {
       const func = compileToken2(token, copyOptions(options), context);
-      return func === boolbase$1.falseFunc ? next2 : func === boolbase$1.trueFunc ? boolbase$1.falseFunc : (elem) => !func(elem) && next2(elem);
+      return func === boolbase.falseFunc ? next2 : func === boolbase.trueFunc ? boolbase.falseFunc : (elem) => !func(elem) && next2(elem);
     },
     has(next2, subselect, options, _context, compileToken2) {
       const { adapter: adapter2 } = options;
@@ -3535,10 +3547,10 @@
         [PLACEHOLDER_ELEMENT]
       ) : void 0;
       const compiled = compileToken2(subselect, opts, context);
-      if (compiled === boolbase$1.falseFunc)
-        return boolbase$1.falseFunc;
+      if (compiled === boolbase.falseFunc)
+        return boolbase.falseFunc;
       const hasElement = ensureIsTag(compiled, adapter2);
-      if (context && compiled !== boolbase$1.trueFunc) {
+      if (context && compiled !== boolbase.trueFunc) {
         const { shouldTestNextSiblings = false } = compiled;
         return (elem) => {
           if (!next2(elem))
@@ -3612,6 +3624,7 @@
       case SelectorType.Pseudo: {
         return compilePseudoSelector(next2, selector, options, context, compileToken2);
       }
+      // Tags
       case SelectorType.Tag: {
         if (selector.namespace != null) {
           throw new Error("Namespaced tag names are not yet supported by css-select");
@@ -3624,6 +3637,7 @@
           return adapter2.getName(elem) === name2 && next2(elem);
         };
       }
+      // Traversal
       case SelectorType.Descendant: {
         if (options.cacheResults === false || typeof WeakSet === "undefined") {
           return function descendant(elem) {
@@ -3764,19 +3778,19 @@
         }
       }
       return compileRules(rules, options, finalContext);
-    }).reduce(reduceRules, boolbase$1.falseFunc);
+    }).reduce(reduceRules, boolbase.falseFunc);
     query.shouldTestNextSiblings = shouldTestNextSiblings;
     return query;
   }
   function compileRules(rules, options, context) {
     var _a2;
-    return rules.reduce((previous, rule) => previous === boolbase$1.falseFunc ? boolbase$1.falseFunc : compileGeneralSelector(previous, rule, options, context, compileToken), (_a2 = options.rootFunc) !== null && _a2 !== void 0 ? _a2 : boolbase$1.trueFunc);
+    return rules.reduce((previous, rule) => previous === boolbase.falseFunc ? boolbase.falseFunc : compileGeneralSelector(previous, rule, options, context, compileToken), (_a2 = options.rootFunc) !== null && _a2 !== void 0 ? _a2 : boolbase.trueFunc);
   }
   function reduceRules(a, b) {
-    if (b === boolbase$1.falseFunc || a === boolbase$1.trueFunc) {
+    if (b === boolbase.falseFunc || a === boolbase.trueFunc) {
       return a;
     }
-    if (a === boolbase$1.falseFunc || b === boolbase$1.trueFunc) {
+    if (a === boolbase.falseFunc || b === boolbase.trueFunc) {
       return b;
     }
     return function combine(elem) {
@@ -4016,8 +4030,8 @@
          */
         rootFunc: (el) => result.includes(el)
       };
-    } else if (options.rootFunc && options.rootFunc !== boolbase.trueFunc) {
-      options = { ...options, rootFunc: boolbase.trueFunc };
+    } else if (options.rootFunc && options.rootFunc !== boolbaseExports.trueFunc) {
+      options = { ...options, rootFunc: boolbaseExports.trueFunc };
     }
     return remainingSelector.some(isFilter) ? findFilterElements(result, remainingSelector, options, false, totalLimit) : remainingHasTraversal ? (
       // Query existing elements to resolve traversal.
@@ -4040,7 +4054,7 @@
     if (els.length === 0)
       return els;
     const query = _compileToken(sel, options);
-    return query === boolbase.trueFunc ? els : els.filter(query);
+    return query === boolbaseExports.trueFunc ? els : els.filter(query);
   }
   const reSiblingSelector = /^\s*[+~]/;
   function find(selectorOrHaystack) {
@@ -5975,14 +5989,14 @@
   function toAsciiLower(cp) {
     return cp + 32;
   }
-  function isWhitespace$2(cp) {
+  function isWhitespace$1(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$2(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN;
+    return isWhitespace$1(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN;
   }
   let Tokenizer$1 = class Tokenizer {
     constructor(options, handler) {
@@ -6273,7 +6287,7 @@
       this._createCharacterToken(type, ch);
     }
     _emitCodePoint(cp) {
-      const type = isWhitespace$2(cp) ? TokenType.WHITESPACE_CHARACTER : cp === CODE_POINTS.NULL ? TokenType.NULL_CHARACTER : TokenType.CHARACTER;
+      const type = isWhitespace$1(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.
@@ -12244,6 +12258,7 @@
   }
   function startTagInTemplate(p, token) {
     switch (token.tagID) {
+      // First, handle tags that can start without a mode change
       case TAG_ID.BASE:
       case TAG_ID.BASEFONT:
       case TAG_ID.BGSOUND:
@@ -12257,6 +12272,7 @@
         startTagInHead(p, token);
         break;
       }
+      // Re-process the token in the appropriate mode
       case TAG_ID.CAPTION:
       case TAG_ID.COLGROUP:
       case TAG_ID.TBODY:
@@ -12865,11 +12881,11 @@
     State2[State2["InSpecialTag"] = 25] = "InSpecialTag";
     State2[State2["InEntity"] = 26] = "InEntity";
   })(State || (State = {}));
-  function isWhitespace$1(c) {
+  function isWhitespace(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$1(c);
+    return c === CharCodes.Slash || c === CharCodes.Gt || isWhitespace(c);
   }
   function isASCIIAlpha(c) {
     return c >= CharCodes.LowerA && c <= CharCodes.LowerZ || c >= CharCodes.UpperA && c <= CharCodes.UpperZ;
@@ -12987,7 +13003,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$1(c)) {
+        if (c === CharCodes.Gt || isWhitespace(c)) {
           const endOfText = this.index - this.currentSequence.length;
           if (this.sectionStart < endOfText) {
             const actualIndex = this.index;
@@ -13123,7 +13139,7 @@
       }
     }
     stateBeforeClosingTagName(c) {
-      if (isWhitespace$1(c)) ;
+      if (isWhitespace(c)) ;
       else if (c === CharCodes.Gt) {
         this.state = State.Text;
       } else {
@@ -13132,7 +13148,7 @@
       }
     }
     stateInClosingTagName(c) {
-      if (c === CharCodes.Gt || isWhitespace$1(c)) {
+      if (c === CharCodes.Gt || isWhitespace(c)) {
         this.cbs.onclosetag(this.sectionStart, this.index);
         this.sectionStart = -1;
         this.state = State.AfterClosingTagName;
@@ -13157,7 +13173,7 @@
         this.sectionStart = this.index + 1;
       } else if (c === CharCodes.Slash) {
         this.state = State.InSelfClosingTag;
-      } else if (!isWhitespace$1(c)) {
+      } else if (!isWhitespace(c)) {
         this.state = State.InAttributeName;
         this.sectionStart = this.index;
       }
@@ -13168,7 +13184,7 @@
         this.state = State.Text;
         this.sectionStart = this.index + 1;
         this.isSpecial = false;
-      } else if (!isWhitespace$1(c)) {
+      } else if (!isWhitespace(c)) {
         this.state = State.BeforeAttributeName;
         this.stateBeforeAttributeName(c);
       }
@@ -13189,7 +13205,7 @@
         this.sectionStart = -1;
         this.state = State.BeforeAttributeName;
         this.stateBeforeAttributeName(c);
-      } else if (!isWhitespace$1(c)) {
+      } else if (!isWhitespace(c)) {
         this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);
         this.state = State.InAttributeName;
         this.sectionStart = this.index;
@@ -13202,7 +13218,7 @@
       } else if (c === CharCodes.SingleQuote) {
         this.state = State.InAttributeValueSq;
         this.sectionStart = this.index + 1;
-      } else if (!isWhitespace$1(c)) {
+      } else if (!isWhitespace(c)) {
         this.sectionStart = this.index;
         this.state = State.InAttributeValueNq;
         this.stateInAttributeValueNoQuotes(c);
@@ -13225,7 +13241,7 @@
       this.handleInAttributeValue(c, CharCodes.SingleQuote);
     }
     stateInAttributeValueNoQuotes(c) {
-      if (isWhitespace$1(c) || c === CharCodes.Gt) {
+      if (isWhitespace(c) || c === CharCodes.Gt) {
         this.cbs.onattribdata(this.sectionStart, this.index);
         this.sectionStart = -1;
         this.cbs.onattribend(QuoteType.Unquoted, this.index);
@@ -14042,7 +14058,7 @@
     }
     function getCurrentHeading(level) {
       let heading2;
-      while ((heading2 = headingStack.at(-1)) && heading2.level >= level) {
+      while ((heading2 = headingStack[headingStack.length - 1]) && heading2.level >= level) {
         headingStack.pop();
       }
       return heading2 || rootNode;
@@ -14129,6 +14145,7 @@
       };
       if (htmlNode.data) {
         node.payload = {
+          tag: htmlNode.tag,
           ...htmlNode.data
         };
       }
@@ -14614,7 +14631,7 @@
   function replaceUnsafeChar(ch) {
     return HTML_REPLACEMENTS[ch];
   }
-  function escapeHtml$1(str) {
+  function escapeHtml(str) {
     if (HTML_ESCAPE_TEST_RE.test(str)) {
       return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
     }
@@ -14638,10 +14655,15 @@
     }
     switch (code2) {
       case 9:
+      // \t
       case 10:
+      // \n
       case 11:
+      // \v
       case 12:
+      // \f
       case 13:
+      // \r
       case 32:
       case 160:
       case 5760:
@@ -14706,7 +14728,7 @@
     __proto__: null,
     arrayReplaceAt,
     assign: assign$1,
-    escapeHtml: escapeHtml$1,
+    escapeHtml,
     escapeRE: escapeRE$1,
     fromCodePoint,
     has,
@@ -14887,11 +14909,11 @@
   const default_rules = {};
   default_rules.code_inline = function(tokens, idx, options, env, slf) {
     const token = tokens[idx];
-    return "<code" + slf.renderAttrs(token) + ">" + escapeHtml$1(token.content) + "</code>";
+    return "<code" + slf.renderAttrs(token) + ">" + escapeHtml(token.content) + "</code>";
   };
   default_rules.code_block = function(tokens, idx, options, env, slf) {
     const token = tokens[idx];
-    return "<pre" + slf.renderAttrs(token) + "><code>" + escapeHtml$1(tokens[idx].content) + "</code></pre>\n";
+    return "<pre" + slf.renderAttrs(token) + "><code>" + escapeHtml(tokens[idx].content) + "</code></pre>\n";
   };
   default_rules.fence = function(tokens, idx, options, env, slf) {
     const token = tokens[idx];
@@ -14905,9 +14927,9 @@
     }
     let highlighted;
     if (options.highlight) {
-      highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml$1(token.content);
+      highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);
     } else {
-      highlighted = escapeHtml$1(token.content);
+      highlighted = escapeHtml(token.content);
     }
     if (highlighted.indexOf("<pre") === 0) {
       return highlighted + "\n";
@@ -14942,7 +14964,7 @@
     return options.breaks ? options.xhtmlOut ? "<br />\n" : "<br>\n" : "\n";
   };
   default_rules.text = function(tokens, idx) {
-    return escapeHtml$1(tokens[idx].content);
+    return escapeHtml(tokens[idx].content);
   };
   default_rules.html_block = function(tokens, idx) {
     return tokens[idx].content;
@@ -14960,7 +14982,7 @@
     }
     result = "";
     for (i = 0, l = token.attrs.length; i < l; i++) {
-      result += " " + escapeHtml$1(token.attrs[i][0]) + '="' + escapeHtml$1(token.attrs[i][1]) + '"';
+      result += " " + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
     }
     return result;
   };
@@ -15058,9 +15080,9 @@
     return -1;
   };
   Ruler.prototype.__compile__ = function() {
-    const self2 = this;
+    const self = this;
     const chains = [""];
-    self2.__rules__.forEach(function(rule) {
+    self.__rules__.forEach(function(rule) {
       if (!rule.enabled) {
         return;
       }
@@ -15070,17 +15092,17 @@
         }
       });
     });
-    self2.__cache__ = {};
+    self.__cache__ = {};
     chains.forEach(function(chain) {
-      self2.__cache__[chain] = [];
-      self2.__rules__.forEach(function(rule) {
+      self.__cache__[chain] = [];
+      self.__rules__.forEach(function(rule) {
         if (!rule.enabled) {
           return;
         }
         if (chain && rule.alt.indexOf(chain) < 0) {
           return;
         }
-        self2.__cache__[chain].push(rule.fn);
+        self.__cache__[chain].push(rule.fn);
       });
     });
   };
@@ -18025,16 +18047,16 @@
   }
   const defaultSchemas = {
     "http:": {
-      validate: function(text2, pos, self2) {
+      validate: function(text2, pos, self) {
         const tail = text2.slice(pos);
-        if (!self2.re.http) {
-          self2.re.http = new RegExp(
-            "^\\/\\/" + self2.re.src_auth + self2.re.src_host_port_strict + self2.re.src_path,
+        if (!self.re.http) {
+          self.re.http = new RegExp(
+            "^\\/\\/" + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path,
             "i"
           );
         }
-        if (self2.re.http.test(tail)) {
-          return tail.match(self2.re.http)[0].length;
+        if (self.re.http.test(tail)) {
+          return tail.match(self.re.http)[0].length;
         }
         return 0;
       }
@@ -18042,39 +18064,39 @@
     "https:": "http:",
     "ftp:": "http:",
     "//": {
-      validate: function(text2, pos, self2) {
+      validate: function(text2, pos, self) {
         const tail = text2.slice(pos);
-        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'
+        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'
             // with code comments
-            "(?:localhost|(?:(?:" + self2.re.src_domain + ")\\.)+" + self2.re.src_domain_root + ")" + self2.re.src_port + self2.re.src_host_terminator + self2.re.src_path,
+            "(?:localhost|(?:(?:" + self.re.src_domain + ")\\.)+" + self.re.src_domain_root + ")" + self.re.src_port + self.re.src_host_terminator + self.re.src_path,
             "i"
           );
         }
-        if (self2.re.no_http.test(tail)) {
+        if (self.re.no_http.test(tail)) {
           if (pos >= 3 && text2[pos - 3] === ":") {
             return 0;
           }
           if (pos >= 3 && text2[pos - 3] === "/") {
             return 0;
           }
-          return tail.match(self2.re.no_http)[0].length;
+          return tail.match(self.re.no_http)[0].length;
         }
         return 0;
       }
     },
     "mailto:": {
-      validate: function(text2, pos, self2) {
+      validate: function(text2, pos, self) {
         const tail = text2.slice(pos);
-        if (!self2.re.mailto) {
-          self2.re.mailto = new RegExp(
-            "^" + self2.re.src_email_name + "@" + self2.re.src_host_strict,
+        if (!self.re.mailto) {
+          self.re.mailto = new RegExp(
+            "^" + self.re.src_email_name + "@" + self.re.src_host_strict,
             "i"
           );
         }
-        if (self2.re.mailto.test(tail)) {
-          return tail.match(self2.re.mailto)[0].length;
+        if (self.re.mailto.test(tail)) {
+          return tail.match(self.re.mailto)[0].length;
         }
         return 0;
       }
@@ -18082,9 +18104,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(self2) {
-    self2.__index__ = -1;
-    self2.__text_cache__ = "";
+  function resetScanCache(self) {
+    self.__index__ = -1;
+    self.__text_cache__ = "";
   }
   function createValidator(re) {
     return function(text2, pos) {
@@ -18096,15 +18118,15 @@
     };
   }
   function createNormalizer() {
-    return function(match, self2) {
-      self2.normalize(match);
+    return function(match, self) {
+      self.normalize(match);
     };
   }
-  function compile(self2) {
-    const re = self2.re = reFactory(self2.__opts__);
-    const tlds = self2.__tlds__.slice();
-    self2.onCompile();
-    if (!self2.__tlds_replaced__) {
+  function compile(self) {
+    const re = self.re = reFactory(self.__opts__);
+    const tlds = self.__tlds__.slice();
+    self.onCompile();
+    if (!self.__tlds_replaced__) {
       tlds.push(tlds_2ch_src_re);
     }
     tlds.push(re.src_xn);
@@ -18117,17 +18139,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 = [];
-    self2.__compiled__ = {};
+    self.__compiled__ = {};
     function schemaError(name2, val2) {
       throw new Error('(LinkifyIt) Invalid schema "' + name2 + '": ' + val2);
     }
-    Object.keys(self2.__schemas__).forEach(function(name2) {
-      const val2 = self2.__schemas__[name2];
+    Object.keys(self.__schemas__).forEach(function(name2) {
+      const val2 = self.__schemas__[name2];
       if (val2 === null) {
         return;
       }
       const compiled = { validate: null, link: null };
-      self2.__compiled__[name2] = compiled;
+      self.__compiled__[name2] = compiled;
       if (isObject(val2)) {
         if (isRegExp(val2.validate)) {
           compiled.validate = createValidator(val2.validate);
@@ -18152,39 +18174,39 @@
       schemaError(name2, val2);
     });
     aliases2.forEach(function(alias) {
-      if (!self2.__compiled__[self2.__schemas__[alias]]) {
+      if (!self.__compiled__[self.__schemas__[alias]]) {
         return;
       }
-      self2.__compiled__[alias].validate = self2.__compiled__[self2.__schemas__[alias]].validate;
-      self2.__compiled__[alias].normalize = self2.__compiled__[self2.__schemas__[alias]].normalize;
+      self.__compiled__[alias].validate = self.__compiled__[self.__schemas__[alias]].validate;
+      self.__compiled__[alias].normalize = self.__compiled__[self.__schemas__[alias]].normalize;
     });
-    self2.__compiled__[""] = { validate: null, normalize: createNormalizer() };
-    const slist = Object.keys(self2.__compiled__).filter(function(name2) {
-      return name2.length > 0 && self2.__compiled__[name2];
+    self.__compiled__[""] = { validate: null, normalize: createNormalizer() };
+    const slist = Object.keys(self.__compiled__).filter(function(name2) {
+      return name2.length > 0 && self.__compiled__[name2];
     }).map(escapeRE).join("|");
-    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 + ")|@",
+    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 + ")|@",
       "i"
     );
-    resetScanCache(self2);
+    resetScanCache(self);
   }
-  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();
+  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();
     this.index = start + shift;
     this.lastIndex = end2 + shift;
     this.raw = text2;
     this.text = text2;
     this.url = text2;
   }
-  function createMatch(self2, shift) {
-    const match = new Match(self2, shift);
-    self2.__compiled__[match.schema].normalize(match, self2);
+  function createMatch(self, shift) {
+    const match = new Match(self, shift);
+    self.__compiled__[match.schema].normalize(match, self);
     return match;
   }
   function LinkifyIt(schemas2, options) {
@@ -18799,7 +18821,7 @@
     return this;
   };
   MarkdownIt.prototype.configure = function(presets) {
-    const self2 = this;
+    const self = this;
     if (isString$1(presets)) {
       const presetName = presets;
       presets = config$2[presetName];
@@ -18811,15 +18833,15 @@
       throw new Error("Wrong `markdown-it` preset, can't be empty");
     }
     if (presets.options) {
-      self2.set(presets.options);
+      self.set(presets.options);
     }
     if (presets.components) {
       Object.keys(presets.components).forEach(function(name2) {
         if (presets.components[name2].rules) {
-          self2[name2].ruler.enableOnly(presets.components[name2].rules);
+          self[name2].ruler.enableOnly(presets.components[name2].rules);
         }
         if (presets.components[name2].rules2) {
-          self2[name2].ruler2.enableOnly(presets.components[name2].rules2);
+          self[name2].ruler2.enableOnly(presets.components[name2].rules2);
         }
       });
     }
@@ -20294,21 +20316,29 @@ ${indent}`) + "'";
       start = start.replace(/\n+/g, `$&${indent}`);
     }
     const indentSize = indent ? "2" : "1";
-    let header = (literal ? "|" : ">") + (startWithSpace ? indentSize : "") + chomp;
+    let header = (startWithSpace ? indentSize : "") + chomp;
     if (comment2) {
       header += " " + commentString(comment2.replace(/ ?[\r\n]+/g, " "));
       if (onComment)
         onComment();
     }
-    if (literal) {
-      value = value.replace(/\n+/g, `$&${indent}`);
-      return `${header}
-${indent}${start}${value}${end2}`;
-    }
-    value = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`);
-    const body = foldFlowLines(`${start}${value}${end2}`, indent, FOLD_BLOCK, getFoldOptions(ctx, true));
-    return `${header}
+    if (!literal) {
+      const foldedValue = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`);
+      let literalFallback = false;
+      const foldOptions = getFoldOptions(ctx, true);
+      if (blockQuote !== "folded" && type !== Scalar.BLOCK_FOLDED) {
+        foldOptions.onOverflow = () => {
+          literalFallback = true;
+        };
+      }
+      const body = foldFlowLines(`${start}${foldedValue}${end2}`, indent, FOLD_BLOCK, foldOptions);
+      if (!literalFallback)
+        return `>${header}
 ${indent}${body}`;
+    }
+    value = value.replace(/\n+/g, `$&${indent}`);
+    return `|${header}
+${indent}${start}${value}${end2}`;
   }
   function plainString(item, ctx, onComment, onChompKeep) {
     const { type, value } = item;
@@ -20428,10 +20458,15 @@ ${indent}`);
     let obj;
     if (isScalar(item)) {
       obj = item.value;
-      const match = tags.filter((t) => {
+      let match = tags.filter((t) => {
         var _a3;
         return (_a3 = t.identify) == null ? void 0 : _a3.call(t, obj);
       });
+      if (match.length > 1) {
+        const testMatch = match.filter((t) => t.test);
+        if (testMatch.length > 0)
+          match = testMatch;
+      }
       tagObj = match.find((t) => t.format === item.format) ?? match.find((t) => !t.format);
     } else {
       obj = item;
@@ -20617,41 +20652,29 @@ ${ctx.indent}`;
     }
   }
   const MERGE_KEY = "<<";
-  function addPairToJSMap(ctx, map2, { key, value }) {
-    if ((ctx == null ? void 0 : ctx.doc.schema.merge) && isMergeKey(key)) {
-      value = isAlias(value) ? value.resolve(ctx.doc) : value;
-      if (isSeq(value))
-        for (const it of value.items)
-          mergeToJSMap(ctx, map2, it);
-      else if (Array.isArray(value))
-        for (const it of value)
-          mergeToJSMap(ctx, map2, it);
-      else
-        mergeToJSMap(ctx, map2, value);
-    } else {
-      const jsKey = toJS(key, "", ctx);
-      if (map2 instanceof Map) {
-        map2.set(jsKey, toJS(value, jsKey, ctx));
-      } else if (map2 instanceof Set) {
-        map2.add(jsKey);
-      } else {
-        const stringKey = stringifyKey(key, jsKey, ctx);
-        const jsValue = toJS(value, stringKey, ctx);
-        if (stringKey in map2)
-          Object.defineProperty(map2, stringKey, {
-            value: jsValue,
-            writable: true,
-            enumerable: true,
-            configurable: true
-          });
-        else
-          map2[stringKey] = jsValue;
-      }
-    }
-    return map2;
+  const merge = {
+    identify: (value) => value === MERGE_KEY || typeof value === "symbol" && value.description === MERGE_KEY,
+    default: "key",
+    tag: "tag:yaml.org,2002:merge",
+    test: /^<<$/,
+    resolve: () => Object.assign(new Scalar(Symbol(MERGE_KEY)), {
+      addToJSMap: addMergeToJSMap
+    }),
+    stringify: () => MERGE_KEY
+  };
+  const isMergeKey = (ctx, key) => (merge.identify(key) || isScalar(key) && (!key.type || key.type === Scalar.PLAIN) && merge.identify(key.value)) && (ctx == null ? void 0 : ctx.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default));
+  function addMergeToJSMap(ctx, map2, value) {
+    value = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
+    if (isSeq(value))
+      for (const it of value.items)
+        mergeValue(ctx, map2, it);
+    else if (Array.isArray(value))
+      for (const it of value)
+        mergeValue(ctx, map2, it);
+    else
+      mergeValue(ctx, map2, value);
   }
-  const isMergeKey = (key) => key === MERGE_KEY || isScalar(key) && key.value === MERGE_KEY && (!key.type || key.type === Scalar.PLAIN);
-  function mergeToJSMap(ctx, map2, value) {
+  function mergeValue(ctx, map2, value) {
     const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
     if (!isMap(source))
       throw new Error("Merge sources must be maps or map aliases");
@@ -20673,6 +20696,33 @@ ${ctx.indent}`;
     }
     return map2;
   }
+  function addPairToJSMap(ctx, map2, { key, value }) {
+    if (isNode(key) && key.addToJSMap)
+      key.addToJSMap(ctx, map2, value);
+    else if (isMergeKey(ctx, key))
+      addMergeToJSMap(ctx, map2, value);
+    else {
+      const jsKey = toJS(key, "", ctx);
+      if (map2 instanceof Map) {
+        map2.set(jsKey, toJS(value, jsKey, ctx));
+      } else if (map2 instanceof Set) {
+        map2.add(jsKey);
+      } else {
+        const stringKey = stringifyKey(key, jsKey, ctx);
+        const jsValue = toJS(value, stringKey, ctx);
+        if (stringKey in map2)
+          Object.defineProperty(map2, stringKey, {
+            value: jsValue,
+            writable: true,
+            enumerable: true,
+            configurable: true
+          });
+        else
+          map2[stringKey] = jsValue;
+      }
+    }
+    return map2;
+  }
   function stringifyKey(key, jsKey, ctx) {
     if (jsKey === null)
       return "";
@@ -21272,7 +21322,7 @@ ${indent}${end2}`;
       identify: (value) => typeof value === "boolean",
       default: true,
       tag: "tag:yaml.org,2002:bool",
-      test: /^true|false$/,
+      test: /^true$|^false$/,
       resolve: (str) => str === "true",
       stringify: stringifyJSON
     },
@@ -21763,7 +21813,7 @@ ${cn.comment}` : item.comment;
       }
       return new Date(date);
     },
-    stringify: ({ value }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, "")
+    stringify: ({ value }) => value.toISOString().replace(/(T00:00:00)?\.000Z$/, "")
   };
   const schema = [
     map,
@@ -21780,6 +21830,7 @@ ${cn.comment}` : item.comment;
     floatExp,
     float,
     binary,
+    merge,
     omap,
     pairs,
     set,
@@ -21806,6 +21857,7 @@ ${cn.comment}` : item.comment;
     intOct: intOct$1,
     intTime,
     map,
+    merge,
     null: nullTag,
     omap,
     pairs,
@@ -21815,13 +21867,18 @@ ${cn.comment}` : item.comment;
   };
   const coreKnownTags = {
     "tag:yaml.org,2002:binary": binary,
+    "tag:yaml.org,2002:merge": merge,
     "tag:yaml.org,2002:omap": omap,
     "tag:yaml.org,2002:pairs": pairs,
     "tag:yaml.org,2002:set": set,
     "tag:yaml.org,2002:timestamp": timestamp
   };
-  function getTags(customTags, schemaName) {
-    let tags = schemas.get(schemaName);
+  function getTags(customTags, schemaName, addMergeTag) {
+    const schemaTags = schemas.get(schemaName);
+    if (schemaTags && !customTags) {
+      return addMergeTag && !schemaTags.includes(merge) ? schemaTags.concat(merge) : schemaTags.slice();
+    }
+    let tags = schemaTags;
     if (!tags) {
       if (Array.isArray(customTags))
         tags = [];
@@ -21836,24 +21893,27 @@ ${cn.comment}` : item.comment;
     } else if (typeof customTags === "function") {
       tags = customTags(tags.slice());
     }
-    return tags.map((tag) => {
-      if (typeof tag !== "string")
-        return tag;
-      const tagObj = tagsByName[tag];
-      if (tagObj)
-        return tagObj;
-      const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", ");
-      throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
-    });
+    if (addMergeTag)
+      tags = tags.concat(merge);
+    return tags.reduce((tags2, tag) => {
+      const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
+      if (!tagObj) {
+        const tagName = JSON.stringify(tag);
+        const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", ");
+        throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
+      }
+      if (!tags2.includes(tagObj))
+        tags2.push(tagObj);
+      return tags2;
+    }, []);
   }
   const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
   class Schema {
     constructor({ compat, customTags, merge: merge2, resolveKnownTags, schema: schema2, sortMapEntries, toStringDefaults }) {
       this.compat = Array.isArray(compat) ? getTags(compat, "compat") : compat ? getTags(null, compat) : null;
-      this.merge = !!merge2;
       this.name = typeof schema2 === "string" && schema2 || "core";
       this.knownTags = resolveKnownTags ? coreKnownTags : {};
-      this.tags = getTags(customTags, this.name);
+      this.tags = getTags(customTags, this.name, merge2);
       this.toStringOptions = toStringDefaults ?? null;
       Object.defineProperty(this, MAP, { value: map });
       Object.defineProperty(this, SCALAR$1, { value: string });
@@ -21956,6 +22016,7 @@ ${cn.comment}` : item.comment;
         logLevel: "warn",
         prettyErrors: true,
         strict: true,
+        stringKeys: false,
         uniqueKeys: true,
         version: "1.2"
       }, options);
@@ -22157,7 +22218,7 @@ ${cn.comment}` : item.comment;
             this.directives.yaml.version = "1.1";
           else
             this.directives = new Directives({ version: "1.1" });
-          opt = { merge: true, resolveKnownTags: false, schema: "yaml-1.1" };
+          opt = { resolveKnownTags: false, schema: "yaml-1.1" };
           break;
         case "1.2":
         case "next":
@@ -22165,7 +22226,7 @@ ${cn.comment}` : item.comment;
             this.directives.yaml.version = version;
           else
             this.directives = new Directives({ version });
-          opt = { merge: false, resolveKnownTags: true, schema: "core" };
+          opt = { resolveKnownTags: true, schema: "core" };
           break;
         case null:
           if (this.directives)
@@ -22380,6 +22441,7 @@ ${pointer}
             hasSpace = false;
             break;
           }
+        // else fallthrough
         default:
           onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.type} token`);
           atNewline = false;
@@ -22453,7 +22515,7 @@ ${pointer}
     const { uniqueKeys } = ctx.options;
     if (uniqueKeys === false)
       return false;
-    const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || isScalar(a) && isScalar(b) && a.value === b.value && !(a.value === "<<" && ctx.schema.merge);
+    const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || isScalar(a) && isScalar(b) && a.value === b.value;
     return items.some((pair) => isEqual(pair.key, search));
   }
   const startColMsg = "All mapping items must start at the same column";
@@ -22499,10 +22561,12 @@ ${pointer}
       } else if (((_a2 = keyProps.found) == null ? void 0 : _a2.indent) !== bm.indent) {
         onError(offset, "BAD_INDENT", startColMsg);
       }
+      ctx.atKey = true;
       const keyStart = keyProps.end;
       const keyNode = key ? composeNode2(ctx, key, keyProps, onError) : composeEmptyNode2(ctx, keyStart, start, null, keyProps, onError);
       if (ctx.schema.compat)
         flowIndentCheck(bm.indent, key, onError);
+      ctx.atKey = false;
       if (mapIncludes(ctx, map2.items, keyNode))
         onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
       const valueProps = resolveProps(sep ?? [], {
@@ -22554,6 +22618,8 @@ ${pointer}
     const seq2 = new NodeClass(ctx.schema);
     if (ctx.atRoot)
       ctx.atRoot = false;
+    if (ctx.atKey)
+      ctx.atKey = false;
     let offset = bs.offset;
     let commentEnd = null;
     for (const { start, value } of bs.items) {
@@ -22633,6 +22699,8 @@ ${pointer}
     const atRoot = ctx.atRoot;
     if (atRoot)
       ctx.atRoot = false;
+    if (ctx.atKey)
+      ctx.atKey = false;
     let offset = fc.offset + fc.start.source.length;
     for (let i = 0; i < fc.items.length; ++i) {
       const collItem = fc.items[i];
@@ -22708,10 +22776,12 @@ ${pointer}
         if (isBlock(value))
           onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
       } else {
+        ctx.atKey = true;
         const keyStart = props.end;
         const keyNode = key ? composeNode2(ctx, key, props, onError) : composeEmptyNode2(ctx, keyStart, start, null, props, onError);
         if (isBlock(key))
           onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
+        ctx.atKey = false;
         const valueProps = resolveProps(sep ?? [], {
           flow: fcName,
           indicator: "map-value-ind",
@@ -22983,6 +23053,7 @@ ${pointer}
       switch (token.type) {
         case "space":
           hasSpace = true;
+        // fallthrough
         case "newline":
           length += token.source.length;
           break;
@@ -22998,6 +23069,7 @@ ${pointer}
           onError(token, "UNEXPECTED_TOKEN", token.message);
           length += token.source.length;
           break;
+        /* istanbul ignore next should not happen */
         default: {
           const message = `Unexpected token in block scalar header: ${token.type}`;
           onError(token, "UNEXPECTED_TOKEN", message);
@@ -23037,6 +23109,7 @@ ${pointer}
         _type = Scalar.QUOTE_DOUBLE;
         value = doubleQuotedValue(source, _onError);
         break;
+      /* istanbul ignore next should not happen */
       default:
         onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
         return {
@@ -23058,6 +23131,7 @@ ${pointer}
   function plainValue(source, onError) {
     let badChar = "";
     switch (source[0]) {
+      /* istanbul ignore next should not happen */
       case "	":
         badChar = "a tab character";
         break;
@@ -23229,7 +23303,15 @@ ${pointer}
   function composeScalar(ctx, token, tagToken, onError) {
     const { value, type, comment: comment2, range } = token.type === "block-scalar" ? resolveBlockScalar(ctx, token, onError) : resolveFlowScalar(token, ctx.options.strict, onError);
     const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
-    const tag = tagToken && tagName ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError) : token.type === "scalar" ? findScalarTagByTest(ctx, value, token, onError) : ctx.schema[SCALAR$1];
+    let tag;
+    if (ctx.options.stringKeys && ctx.atKey) {
+      tag = ctx.schema[SCALAR$1];
+    } else if (tagName)
+      tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);
+    else if (token.type === "scalar")
+      tag = findScalarTagByTest(ctx, value, token, onError);
+    else
+      tag = ctx.schema[SCALAR$1];
     let scalar;
     try {
       const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
@@ -23275,10 +23357,10 @@ ${pointer}
     onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
     return schema2[SCALAR$1];
   }
-  function findScalarTagByTest({ directives, schema: schema2 }, value, token, onError) {
+  function findScalarTagByTest({ atKey, directives, schema: schema2 }, value, token, onError) {
     const tag = schema2.tags.find((tag2) => {
       var _a2;
-      return tag2.default && ((_a2 = tag2.test) == null ? void 0 : _a2.test(value));
+      return (tag2.default === true || atKey && tag2.default === "key") && ((_a2 = tag2.test) == null ? void 0 : _a2.test(value));
     }) || schema2[SCALAR$1];
     if (schema2.compat) {
       const compat = schema2.compat.find((tag2) => {
@@ -23319,6 +23401,7 @@ ${pointer}
   }
   const CN = { composeNode, composeEmptyNode };
   function composeNode(ctx, token, props, onError) {
+    const atKey = ctx.atKey;
     const { spaceBefore, comment: comment2, anchor, tag } = props;
     let node;
     let isSrcToken = true;
@@ -23352,6 +23435,10 @@ ${pointer}
     }
     if (anchor && node.anchor === "")
       onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+    if (atKey && ctx.options.stringKeys && (!isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) {
+      const msg = "With stringKeys, all keys must be strings";
+      onError(tag ?? token, "NON_STRING_KEY", msg);
+    }
     if (spaceBefore)
       node.spaceBefore = true;
     if (comment2) {
@@ -23402,6 +23489,7 @@ ${pointer}
     const opts = Object.assign({ _directives: directives }, options);
     const doc = new Document(void 0, opts);
     const ctx = {
+      atKey: false,
       atRoot: true,
       directives: doc.directives,
       options: doc.options,
@@ -23891,6 +23979,7 @@ ${end2.comment}` : end2.comment;
       switch (line[n]) {
         case "#":
           yield* this.pushCount(line.length - n);
+        // fallthrough
         case void 0:
           yield* this.pushNewline();
           return yield* this.parseLineStart();
@@ -23986,6 +24075,7 @@ ${end2.comment}` : end2.comment;
             return "flow";
           }
         }
+        // fallthrough
         default:
           this.flowKey = false;
           return yield* this.parsePlainScalar();
@@ -24063,6 +24153,7 @@ ${end2.comment}` : end2.comment;
             if (next2 === "\n")
               break;
           }
+          // fallthrough
           default:
             break loop;
         }
@@ -24180,7 +24271,9 @@ ${end2.comment}` : end2.comment;
         case "&":
           return (yield* this.pushUntil(isNotAnchorChar)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
         case "-":
+        // this is an error
         case "?":
+        // this is an error outside flow collections
         case ":": {
           const inFlow = this.flowLevel > 0;
           const ch1 = this.charAt(1);
@@ -24310,6 +24403,7 @@ ${end2.comment}` : end2.comment;
       }
       case "block-seq":
         return parent2.items[parent2.items.length - 1].start;
+      /* istanbul ignore next should not happen */
       default:
         return [];
     }
@@ -24542,6 +24636,7 @@ ${end2.comment}` : end2.comment;
               Object.assign(it, { key: token, sep: [] });
             return;
           }
+          /* istanbul ignore next should not happen */
           default:
             yield* this.pop();
             yield* this.pop(token);
@@ -24663,6 +24758,7 @@ ${end2.comment}` : end2.comment;
           }
           yield* this.pop();
           break;
+        /* istanbul ignore next should not happen */
         default:
           yield* this.pop();
           yield* this.step();
@@ -25100,6 +25196,7 @@ ${end2.comment}` : end2.comment;
           break;
         case "newline":
           this.onKeyLine = false;
+        // fallthrough
         case "space":
         case "comment":
         default:
@@ -25281,416 +25378,6 @@ ${end2.comment}` : end2.comment;
       };
     }
   });
-  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;
-    }
-    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 += "$";
-      }
-      state.pos += 1;
-      return true;
-    }
-    let start = state.pos + 1;
-    let match = start;
-    let pos;
-    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 = isValidInlineDelim(state, match);
-    if (!res.can_close) {
-      if (!silent) {
-        state.pending += "$";
-      }
-      state.pos = start;
-      return true;
-    }
-    if (!silent) {
-      const token = state.push("math_inline", "math", 0);
-      token.markup = "$";
-      token.content = state.src.slice(start, match);
-    }
-    state.pos = match + 1;
-    return true;
-  }
-  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;
-    }
-    if (state.src.slice(pos, pos + 2) !== "$$") {
-      return false;
-    }
-    pos += 2;
-    let firstLine = state.src.slice(pos, max);
-    if (silent) {
-      return true;
-    }
-    if (firstLine.trim().slice(-2) === "$$") {
-      firstLine = firstLine.trim().slice(0, -2);
-      found = true;
-    }
-    for (next2 = start; !found; ) {
-      next2++;
-      if (next2 >= end2) {
-        break;
-      }
-      pos = state.bMarks[next2] + state.tShift[next2];
-      max = state.eMarks[next2];
-      if (pos < max && state.tShift[next2] < 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;
-      } 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;
-    token = state.push("math_block", "math", 0);
-    token.block = true;
-    token.content = (firstLine && firstLine.trim() ? firstLine + "\n" : "") + state.getLines(start + 1, next2, state.tShift[start], true) + (lastLine && lastLine.trim() ? lastLine : "");
-    token.map = [start, state.line];
-    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;");
-  }
-  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_1.default.renderToString(latex, { ...options, displayMode });
-      } catch (error2) {
-        if (options == null ? void 0 : options.throwOnError) {
-          console.log(error2);
-        }
-        return `<span class="katex-error" title="${escapeHtml(latex)}">${escapeHtml(error2 + "")}</span>`;
-      }
-    };
-    const inlineRenderer = (tokens, idx) => {
-      return katexInline(tokens[idx].content);
-    };
-    const katexBlockRenderer = (latex) => {
-      try {
-        return `<p class="katex-block">${katex_1.default.renderToString(latex, { ...options, displayMode: true })}</p>`;
-      } catch (error2) {
-        if (options == null ? void 0 : options.throwOnError) {
-          console.log(error2);
-        }
-        return `<p class="katex-block katex-error" title="${escapeHtml(latex)}">${escapeHtml(error2 + "")}</p>`;
-      }
-    };
-    const blockRenderer = (tokens, idx) => {
-      return katexBlockRenderer(tokens[idx].content) + "\n";
-    };
-    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;
-    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("://")) {
@@ -25709,18 +25396,18 @@ ${end2.comment}` : end2.comment;
   }
   const name$2 = "katex";
   const preloadScripts = [
-    `katex@${"0.16.11"}/dist/katex.min.js`
+    `katex@${"0.16.15"}/dist/katex.min.js`
   ].map((path) => buildJSItem(path));
   const webfontloader = buildJSItem(
     `webfontloader@${"1.6.28"}/webfontloader.js`
   );
   webfontloader.data.defer = true;
-  const styles = [`katex@${"0.16.11"}/dist/katex.min.css`].map(
+  const styles = [`katex@${"0.16.15"}/dist/katex.min.css`].map(
     (path) => buildCSSItem(path)
   );
   const config = {
     versions: {
-      katex: "0.16.11",
+      katex: "0.16.15",
       webfontloader: "1.6.28"
     },
     preloadScripts,
@@ -25760,6 +25447,432 @@ ${end2.comment}` : end2.comment;
     ],
     styles
   };
+  var dist = {};
+  var hasRequiredDist;
+  function requireDist() {
+    if (hasRequiredDist) return dist;
+    hasRequiredDist = 1;
+    var __importDefault = dist && dist.__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 || isWhitespace2(prevChar) || !isWordCharacterOrNumber(prevChar))) {
+        canOpen = true;
+      }
+      if (nextChar !== "$" && (nextChar == void 0 || isWhitespace2(nextChar) || !isWordCharacterOrNumber(nextChar))) {
+        canClose = true;
+      }
+      return { can_open: canOpen, can_close: canClose };
+    }
+    function isWhitespace2(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;
+      }
+      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 += "$";
+        }
+        state.pos += 1;
+        return true;
+      }
+      let start = state.pos + 1;
+      let match = start;
+      let pos;
+      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 = isValidInlineDelim(state, match);
+      if (!res.can_close) {
+        if (!silent) {
+          state.pending += "$";
+        }
+        state.pos = start;
+        return true;
+      }
+      if (!silent) {
+        const token = state.push("math_inline", "math", 0);
+        token.markup = "$";
+        token.content = state.src.slice(start, match);
+      }
+      state.pos = match + 1;
+      return true;
+    }
+    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;
+      }
+      if (state.src.slice(pos, pos + 2) !== "$$") {
+        return false;
+      }
+      pos += 2;
+      let firstLine = state.src.slice(pos, max);
+      if (silent) {
+        return true;
+      }
+      if (firstLine.trim().slice(-2) === "$$") {
+        firstLine = firstLine.trim().slice(0, -2);
+        found = true;
+      }
+      for (next2 = start; !found; ) {
+        next2++;
+        if (next2 >= end2) {
+          break;
+        }
+        pos = state.bMarks[next2] + state.tShift[next2];
+        max = state.eMarks[next2];
+        if (pos < max && state.tShift[next2] < 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;
+        } 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;
+      token = state.push("math_block", "math", 0);
+      token.block = true;
+      token.content = (firstLine && firstLine.trim() ? firstLine + "\n" : "") + state.getLines(start + 1, next2, state.tShift[start], true) + (lastLine && lastLine.trim() ? lastLine : "");
+      token.map = [start, state.line];
+      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 escapeHtml2(unsafe) {
+      return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+    }
+    function default_1(md, options) {
+      const katex = (options == null ? void 0 : options.katex) ?? katex_1.default;
+      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, displayMode });
+        } catch (error2) {
+          if (options == null ? void 0 : options.throwOnError) {
+            console.log(error2);
+          }
+          return `<span class="katex-error" title="${escapeHtml2(latex)}">${escapeHtml2(error2 + "")}</span>`;
+        }
+      };
+      const inlineRenderer = (tokens, idx) => {
+        const content = tokens[idx].content;
+        const hasBacktick = content.length > 2 && content[0] === "`" && content[content.length - 1] === "`";
+        const sanitized = hasBacktick ? content.slice(1, -1) : content;
+        return katexInline(sanitized);
+      };
+      const katexBlockRenderer = (latex) => {
+        try {
+          return `<p class="katex-block">${katex.renderToString(latex, { ...options, displayMode: true })}</p>`;
+        } catch (error2) {
+          if (options == null ? void 0 : options.throwOnError) {
+            console.log(error2);
+          }
+          return `<p class="katex-block katex-error" title="${escapeHtml2(latex)}">${escapeHtml2(error2 + "")}</p>`;
+        }
+      };
+      const blockRenderer = (tokens, idx) => {
+        return katexBlockRenderer(tokens[idx].content) + "\n";
+      };
+      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;
+      if (enableFencedBlocks) {
+        const mathLanguageId = "math";
+        const originalFenceRenderer = md.renderer.rules.fence;
+        md.renderer.rules.fence = function(tokens, idx, options2, env, self) {
+          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, self)) || "";
+          }
+        };
+      }
+    }
+    dist.default = default_1;
+    return dist;
+  }
+  var distExports = requireDist();
+  const katexPluginModule = /* @__PURE__ */ getDefaultExportFromCjs(distExports);
+  function interop(mod) {
+    return mod.default || mod;
+  }
+  const katexPlugin = interop(katexPluginModule);
   const plugin$1 = definePlugin({
     name: name$2,
     config,
@@ -25788,7 +25901,7 @@ ${end2.comment}` : end2.comment;
       };
       let enableFeature = noop;
       transformHooks.parser.tap((md) => {
-        md.use(_default);
+        md.use(katexPlugin);
         ["math_block", "math_inline"].forEach((key) => {
           const fn = (tokens, idx) => {
             enableFeature();
@@ -25954,7 +26067,7 @@ ${end2.comment}` : end2.comment;
     }
   }
   const transformerVersions = {
-    "markmap-lib": "0.17.3-alpha.3"
+    "markmap-lib": "0.17.3-alpha.8"
   };
   exports.Transformer = Transformer;
   exports.builtInPlugins = builtInPlugins;