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

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,
@@ -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;
@@ -2940,15 +2945,23 @@
   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],
@@ -3098,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) {
@@ -3115,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();
@@ -3135,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();
@@ -3153,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");
@@ -3242,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;
@@ -3277,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);
@@ -3296,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);
@@ -3315,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);
@@ -3335,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);
@@ -3378,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);
@@ -3485,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) {
@@ -3512,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,
@@ -3523,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;
@@ -3534,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))
@@ -3611,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");
@@ -3623,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) {
@@ -3763,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) {
@@ -4015,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.
@@ -4039,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) {
@@ -12243,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:
@@ -12256,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:
@@ -14613,7 +14630,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);
     }
@@ -14637,10 +14654,15 @@
     }
     switch (code2) {
       case 9:
+      // \t
       case 10:
+      // \n
       case 11:
+      // \v
       case 12:
+      // \f
       case 13:
+      // \r
       case 32:
       case 160:
       case 5760:
@@ -14705,7 +14727,7 @@
     __proto__: null,
     arrayReplaceAt,
     assign: assign$1,
-    escapeHtml: escapeHtml$1,
+    escapeHtml,
     escapeRE: escapeRE$1,
     fromCodePoint,
     has,
@@ -14886,11 +14908,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];
@@ -14904,9 +14926,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";
@@ -14941,7 +14963,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;
@@ -14959,7 +14981,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;
   };
@@ -20293,21 +20315,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;
@@ -20427,10 +20457,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;
@@ -20616,41 +20651,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");
@@ -20672,6 +20695,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 "";
@@ -21271,7 +21321,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
     },
@@ -21762,7 +21812,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,
@@ -21779,6 +21829,7 @@ ${cn.comment}` : item.comment;
     floatExp,
     float,
     binary,
+    merge,
     omap,
     pairs,
     set,
@@ -21805,6 +21856,7 @@ ${cn.comment}` : item.comment;
     intOct: intOct$1,
     intTime,
     map,
+    merge,
     null: nullTag,
     omap,
     pairs,
@@ -21814,13 +21866,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 = [];
@@ -21835,24 +21892,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 });
@@ -21955,6 +22015,7 @@ ${cn.comment}` : item.comment;
         logLevel: "warn",
         prettyErrors: true,
         strict: true,
+        stringKeys: false,
         uniqueKeys: true,
         version: "1.2"
       }, options);
@@ -22156,7 +22217,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":
@@ -22164,7 +22225,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)
@@ -22379,6 +22440,7 @@ ${pointer}
             hasSpace = false;
             break;
           }
+        // else fallthrough
         default:
           onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.type} token`);
           atNewline = false;
@@ -22452,7 +22514,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";
@@ -22498,10 +22560,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 ?? [], {
@@ -22553,6 +22617,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) {
@@ -22632,6 +22698,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];
@@ -22707,10 +22775,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",
@@ -22982,6 +23052,7 @@ ${pointer}
       switch (token.type) {
         case "space":
           hasSpace = true;
+        // fallthrough
         case "newline":
           length += token.source.length;
           break;
@@ -22997,6 +23068,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);
@@ -23036,6 +23108,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 {
@@ -23057,6 +23130,7 @@ ${pointer}
   function plainValue(source, onError) {
     let badChar = "";
     switch (source[0]) {
+      /* istanbul ignore next should not happen */
       case "	":
         badChar = "a tab character";
         break;
@@ -23228,7 +23302,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);
@@ -23274,10 +23356,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) => {
@@ -23318,6 +23400,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;
@@ -23351,6 +23434,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) {
@@ -23401,6 +23488,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,
@@ -23890,6 +23978,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();
@@ -23985,6 +24074,7 @@ ${end2.comment}` : end2.comment;
             return "flow";
           }
         }
+        // fallthrough
         default:
           this.flowKey = false;
           return yield* this.parsePlainScalar();
@@ -24062,6 +24152,7 @@ ${end2.comment}` : end2.comment;
             if (next2 === "\n")
               break;
           }
+          // fallthrough
           default:
             break loop;
         }
@@ -24179,7 +24270,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);
@@ -24309,6 +24402,7 @@ ${end2.comment}` : end2.comment;
       }
       case "block-seq":
         return parent2.items[parent2.items.length - 1].start;
+      /* istanbul ignore next should not happen */
       default:
         return [];
     }
@@ -24541,6 +24635,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);
@@ -24662,6 +24757,7 @@ ${end2.comment}` : end2.comment;
           }
           yield* this.pop();
           break;
+        /* istanbul ignore next should not happen */
         default:
           yield* this.pop();
           yield* this.step();
@@ -25099,6 +25195,7 @@ ${end2.comment}` : end2.comment;
           break;
         case "newline":
           this.onKeyLine = false;
+        // fallthrough
         case "space":
         case "comment":
         default:
@@ -25280,159 +25377,6 @@ ${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;
-    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, end2, silent) {
-    var firstLine, 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;
-    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;
-      }
-    }
-    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 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 (error2) {
-        if (options.throwOnError) {
-          console.log(error2);
-        }
-        return `<span class='katex-error' title='${escapeHtml(error2.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 (error2) {
-        if (options.throwOnError) {
-          console.log(error2);
-        }
-        return `<p class='katex-block katex-error' title='${escapeHtml(error2.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("://")) {
@@ -25451,18 +25395,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,
@@ -25502,6 +25446,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,
@@ -25516,9 +25886,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
           });
@@ -25696,7 +26066,7 @@ ${end2.comment}` : end2.comment;
     }
   }
   const transformerVersions = {
-    "markmap-lib": "0.17.3-alpha.2"
+    "markmap-lib": "0.17.3-alpha.4"
   };
   exports.Transformer = Transformer;
   exports.builtInPlugins = builtInPlugins;