npm - @anyblock/remark-any-block - Versions diffs - 1.0.3-beta1 → 3.4.11 - Mend

@anyblock/remark-any-block 1.0.3-beta1 → 3.4.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/anyblock.ts +1 -1
package/dist/remark-any-block.cjs +1561 -326
package/dist/remark-any-block.js +1561 -326
package/index.ts +1 -1
package/package.json +1 -1
package/styles.css +1217 -1203
package/tsconfig.json +1 -4

package/dist/remark-any-block.cjs CHANGED Viewed

@@ -62,6 +62,16 @@ function jsdom_disable() {
   global.history = void 0;
   global.document = void 0;
 }
+const ABCSetting = {
+  env: "obsidian",
+  // 某些环境的独占 api，其他环境用不上
+  obsidian: {
+    global_app: null,
+    global_ctx: null,
+    mermaid: void 0,
+    markmap_event: void 0
+  }
+};
 const ABReg = {
   /**
    * AB块头部
@@ -83,9 +93,9 @@ const ABReg = {
    * - 不允许 `::` 是避免与 dataview 的 inline property 冲突
    */
   // 有前缀版本（给选择器用）
-  reg_header: /^((\s|>\s|-\s|\*\s|\+\s)*)(%%)?(\[((?!toc|TOC|\!|< )[\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?(%%)?\s*$/,
+  reg_header: /^((\s|>\s|-\s|\*\s|\+\s)*)(%%)?(\[((?!toc|TOC|\!|< )[\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?\3\s*$/,
   // 可以用空`|`来解除首字符限制。(`|`注意：可以用来弄严格模式，`#`注意：建议后面空一格避免变成“标签”，`!`注意：别易误触发 `> [!note]`
-  reg_header_up: /^((\s|>\s|-\s|\*\s|\+\s)*)(%%)?(\[((?!toc|TOC|\!)< [\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?(%%)?\s*$/,
+  reg_header_up: /^((\s|>\s|-\s|\*\s|\+\s)*)(%%)?(\[((?!toc|TOC|\!)< [\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?\3\s*$/,
   // 向上检查标志的 头部选择器
   reg_mdit_head: /^((\s|>\s|-\s|\*\s|\+\s)*)(::::*)\s?(.*)/,
   reg_mdit_tail: /^((\s|>\s|-\s|\*\s|\+\s)*)(::::*)/,
@@ -98,8 +108,8 @@ const ABReg = {
   reg_heading: /^((\s|>\s|-\s|\*\s|\+\s)*)(\#+\s)(.*)/,
   reg_table: /^((\s|>\s|-\s|\*\s|\+\s)*)(\|(.*)\|)/,
   // 无前缀版本（给处理器用，处理器不需要处理前缀，前缀在选择器阶段已经被去除了）
-  reg_header_noprefix: /^((\s)*)(%%)?(\[((?!toc|TOC|\!|< )[\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?(%%)?\s*$/,
-  reg_header_up_noprefix: /^((\s)*)(%%)?(\[((?!toc|TOC|\!)< [\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?(%%)?\s*$/,
+  reg_header_noprefix: /^((\s)*)(%%)?(\[((?!toc|TOC|\!|< )[\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?\3\s*$/,
+  reg_header_up_noprefix: /^((\s)*)(%%)?(\[((?!toc|TOC|\!)< [\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?\3\s*$/,
   reg_mdit_head_noprefix: /^((\s)*)(::::*)\s?(.*)/,
   reg_mdit_tail_noprefix: /^((\s)*)(::::*)/,
   reg_list_noprefix: /^((\s)*)(-\s|\*\s|\+\s)(.*)/,
@@ -112,12 +122,6 @@ const ABReg = {
   inline_split: /\| |,  |， |\.  |。 |:  |： /
   // 内联切分。`|`或全角符号+一空格，半角符号+两空格 (后者由于空格压缩，若经历了重渲染可能有问题)
 };
-const ABCSetting = {
-  env: "obsidian",
-  // MarkdownPostProcessorContext类型, obsidian专用
-  mermaid: void 0
-  // obsidian专用，表示使用哪种方式渲染mermaid
-};
 const convert = (
   // Note: overloads in JSDoc can’t yet use different `@template`s.
   /**
@@ -392,11 +396,11 @@ function autoABAlias(header, selectorName, content) {
   } else if (selectorName == "table" || ABReg.reg_table_noprefix.test(content.trimStart())) {
     header = "|table_140lne" + header;
   }
-  for (const item of ABAlias_json) {
+  for (const item of get_ABAlias_iter()) {
     header = header.replace(item.regex, item.replacement);
   }
   for (const item of ABAlias_json_withSub) {
-    header = header.replace(item.regex, (match2, ...groups) => {
+    header = header.replace(item.regex, (_match, ...groups) => {
       return item.replacement.replace(/\$(\d+)/g, (_, number) => groups[number - 1] ?? "");
     });
   }
@@ -429,15 +433,35 @@ const ABAlias_json_withSub = [
   // 注意避免和原上/上面的callout语法冲突，以及自身递归
 ];
 const ABAlias_json_mdit = [
-  { regex: /\|:::_140lne\|(2?tabs?|标签页?)\|/, replacement: "|mditTabs|" },
+  { regex: /\|:::_140lne\|((?:mdit2|2)?tabs?|标签页?)\|/, replacement: "|mditTabs|" },
   { regex: "|:::_140lne|demo|", replacement: "|mditDemo|" },
   { regex: "|:::_140lne|abDemo|", replacement: "|mditABDemo|" },
-  { regex: /\|:::_140lne\|(2?col|分栏)\|/, replacement: "|mditCol|" },
-  { regex: /\|:::_140lne\|(2?card|卡片)\|/, replacement: "|mditCard|" },
-  { regex: /\|:::_140lne\|(2?chat|聊天)\|/, replacement: "|mditChat|code(chat)|" }
+  { regex: /\|:::_140lne\|((?:mdit2|2)?col|分栏)\|/, replacement: "|mditCol|" },
+  { regex: /\|:::_140lne\|((?:mdit2|2)?card|卡片)\|/, replacement: "|mditCard|" },
+  { regex: /\|:::_140lne\|((?:mdit2|2)?chat|聊天)\|/, replacement: "|mditChat|code(chat)|" },
+  //
+  // {regex: /\|:::_140lne\|2?(timeline|时间线)\|/, replacement: "|title2timeline|"},
+  // {regex: /\|:::_140lne\|2?(tabs?|标签页?)\||\|title2tabs?\|/, replacement: "|title2c2listdata|c2listdata2tab|"},
+  // {regex: /\|:::_140lne\|2?(col|分栏)\||\|title2col\|/, replacement: "|title2c2listdata|c2listdata2items|addClass(ab-col)|"},
+  // {regex: /\|:::_140lne\|2?(card|卡片)\||\|title2card\|/, replacement: "|title2c2listdata|c2listdata2items|addClass(ab-card)|addClass(ab-lay-vfall)|"},
+  // {regex: /\|:::_140lne\|2?(nodes?|节点)\||\|(title2node|title2abMindmap)\|/, replacement: "|title2listdata|listdata2strict|listdata2nodes|"},
+  // list  - 多叉多层树
+  { regex: /\|:::_140lne\|(?:mdit2|2)?(mermaid|flow|流程图)\|/, replacement: "|mdit2list|list2mermaid|" },
+  { regex: /\|:::_140lne\|(?:mdit2|2)?(mehrmaid|mdmermaid)\|/, replacement: "|mdit2list|list2mehrmaidText|code(mehrmaid)|" },
+  { regex: /\|:::_140lne\|(?:mdit2|2)?(puml)?(plantuml|mindmap|脑图|思维导图)\|/, replacement: "|mdit2list|list2pumlMindmap|" },
+  { regex: /\|:::_140lne\|(?:mdit2|2)?(markmap|mdMindmap|md脑图|md思维导图)\|/, replacement: "|mdit2list|list2markmap|" },
+  { regex: /\|:::_140lne\|(?:mdit2|2)?(wbs|(工作)?分解(图|结构))\|/, replacement: "|mdit2list|list2pumlWBS|" },
+  { regex: /\|:::_140lne\|(?:mdit2|2)?(table|multiWayTable|multiCrossTable|表格?|多叉表格?|跨行表格?)\|/, replacement: "|mdit2list|list2table|" },
+  // list - lt树 (属于多层一叉树)
+  { regex: /\|:::_140lne\|(?:mdit2|2)?(lt|listTable|treeTable|listGrid|treeGrid|列表格|树形表格?)\|/, replacement: "|mdit2list|list2lt|" },
+  { regex: /\|:::_140lne\|(?:mdit2|2)?(list|列表)\|/, replacement: "|mdit2list|list2lt|addClass(ab-listtable-likelist)|" },
+  { regex: /\|:::_140lne\|(?:mdit2|2)?(dir|dirTree|目录树?|目录结构)\|/, replacement: "|mdit2list|list2dt|" },
+  // list - 二层树
+  { regex: /\|:::_140lne\|(fakeList|仿列表)\|/, replacement: "|mdit2list|list2table|addClass(ab-table-fc)|addClass(ab-table-likelist)|" },
+  // 至后
+  { regex: "|mdit2list|", replacement: "|mdit2listdata|listdata2strict|listdata2list|" }
 ];
 const ABAlias_json_title = [
-  { regex: "|title2list|", replacement: "|title2listdata|listdata2strict|listdata2list|" },
   // title - list&title
   { regex: /\|heading_140lne\|2?(timeline|时间线)\|/, replacement: "|title2timeline|" },
   { regex: /\|heading_140lne\|2?(tabs?|标签页?)\||\|title2tabs?\|/, replacement: "|title2c2listdata|c2listdata2tab|" },
@@ -456,7 +480,9 @@ const ABAlias_json_title = [
   { regex: /\|heading_140lne\|2?(list|列表)\|/, replacement: "|title2list|list2lt|addClass(ab-listtable-likelist)|" },
   { regex: /\|heading_140lne\|2?(dir|dirTree|目录树?|目录结构)\|/, replacement: "|title2list|list2dt|" },
   // list - 二层树
-  { regex: /\|heading_140lne\|(fakeList|仿列表)\|/, replacement: "|title2list|list2table|addClass(ab-table-fc)|addClass(ab-table-likelist)|" }
+  { regex: /\|heading_140lne\|(fakeList|仿列表)\|/, replacement: "|title2list|list2table|addClass(ab-table-fc)|addClass(ab-table-likelist)|" },
+  // 至后
+  { regex: "|title2list|", replacement: "|title2listdata|listdata2strict|listdata2list|" }
 ];
 const ABAlias_json_list = [
   // 特殊
@@ -540,7 +566,9 @@ const ABAlias_json_general = [
   { regex: "|超超小字|", replacement: "|addClass(ab-custom-font-smallxx)|" },
   { regex: "|加粗|", replacement: "|addClass(ab-custom-font-bold)|" }
 ];
-const ABAlias_json_default = [
+const ABAlias_user = [];
+const ABAlias_pro = [];
+const ABAlias_default = [
   ...ABAlias_json_mdit,
   ...ABAlias_json_title,
   ...ABAlias_json_list,
@@ -550,10 +578,11 @@ const ABAlias_json_default = [
   ...ABAlias_json_general
   // 这个放最后
 ];
-let ABAlias_json = [
-  ...ABAlias_json_default
-  // 设置决定是否停用
-];
+function* get_ABAlias_iter() {
+  yield* ABAlias_user;
+  yield* ABAlias_pro;
+  yield* ABAlias_default;
+}
 const ABAlias_json_end = [
   { regex: "|:::_140lne", replacement: "" },
   { regex: "|heading_140lne", replacement: "" },
@@ -610,24 +639,18 @@ class ABConvertManager {
    * @param header 转换方式
    * @param content 要转换的初始文本 (无前缀版本，前缀在选择器环节已经删除了)
    * @param selectorName 选择器名，空表示未知
-   * @return 等于el，无用，后面可以删了
    */
   static autoABConvert(el, header, content, selectorName = "", ctx) {
-    let prev_result = content;
-    let prev_type = "string";
-    let prev_type2 = ABConvert_IOEnum.text;
-    let prev_processor;
     let prev2 = {
-      // 组合在一起是为了引用传参
-      prev_result,
-      prev_type,
-      prev_type2,
-      prev_processor
+      prev_result: content,
+      prev_type: "string",
+      prev_type2: ABConvert_IOEnum.text,
+      prev_processor: void 0
     };
     {
-      header = autoABAlias(header, selectorName, prev_result);
+      header = autoABAlias(header, selectorName, prev2.prev_result);
       let list_header = header.split("|");
-      prev_result = this.autoABConvert_runConvert(el, list_header, prev2, ctx);
+      this.autoABConvert_runConvert(el, list_header, prev2, ctx);
       this.autoABConvert_last(el, header, selectorName, prev2, ctx);
     }
   }
@@ -686,7 +709,12 @@ class ABConvertManager {
               break;
             }
           }
-          prev2.prev_result = abReplaceProcessor.process(el, item_header, prev2.prev_result, ctx);
+          try {
+            prev2.prev_result = abReplaceProcessor.process(el, item_header, prev2.prev_result, ctx);
+          } catch (e) {
+            console.error(`处理器执行错误, id:${abReplaceProcessor.id}, header:${item_header}, error:`, e);
+            break;
+          }
           prev2.prev_type = typeof prev2.prev_result;
           prev2.prev_type2 = abReplaceProcessor.process_return;
           prev2.prev_processor = abReplaceProcessor.process;
@@ -700,7 +728,7 @@ class ABConvertManager {
   /**
    * 子函数，后处理/尾处理，主要进行末尾追加指令
    */
-  static autoABConvert_last(el, header, selectorName, prev2, ctx) {
+  static autoABConvert_last(el, _header, _selectorName, prev2, _ctx) {
     if (prev2.prev_type == "string" && prev2.prev_type2 == ABConvert_IOEnum.text) {
       const subEl = document.createElement("div");
       el.appendChild(subEl);
@@ -708,7 +736,7 @@ class ABConvertManager {
       prev2.prev_result = el;
       prev2.prev_type = "object";
       prev2.prev_type2 = ABConvert_IOEnum.el;
-      prev2.process = "md";
+      prev2.prev_processor = "md";
     } else if (prev2.prev_type == "string" && prev2.prev_type2 == ABConvert_IOEnum.json) {
       const code_str = "```json\n" + prev2.prev_result + "\n```\n";
       const subEl = document.createElement("div");
@@ -717,7 +745,7 @@ class ABConvertManager {
       prev2.prev_result = el;
       prev2.prev_type = "object";
       prev2.prev_type2 = ABConvert_IOEnum.el;
-      prev2.process = "show_json";
+      prev2.prev_processor = "show_json";
     } else if (prev2.prev_type == "object" && (prev2.prev_type2 == ABConvert_IOEnum.list_stream || prev2.prev_type2 == ABConvert_IOEnum.c2list_stream || prev2.prev_type2 == ABConvert_IOEnum.json)) {
       const code_str = "```json\n" + JSON.stringify(prev2.prev_result, null, 2) + "\n```\n";
       const subEl = document.createElement("div");
@@ -726,7 +754,7 @@ class ABConvertManager {
       prev2.prev_result = el;
       prev2.prev_type = "object";
       prev2.prev_type2 = ABConvert_IOEnum.el;
-      prev2.process = "show_listStream";
+      prev2.prev_processor = "show_listStream";
     } else if (prev2.prev_type == "object" && prev2.prev_type2 == ABConvert_IOEnum.el) {
       return prev2;
     } else {
@@ -1170,7 +1198,7 @@ class ListProcess {
     }
   }
   /**
-   * 标题大纲转列表数据（@todo 正文的level+10，要减掉）
+   * 标题大纲转列表数据
    *
    * @detail
    * 这里要将标题、正文、列表 的等级合为一块，所以存在偏移值：
@@ -1179,6 +1207,7 @@ class ListProcess {
    * 2. 正文等级,  = 0,              取值[+1,+Infi]
    * 3. 列表等级,  = `(.*)-`个数+1,  取值[0]
    *
+   * (比较旧版是正文+10，列表+11，后来允许标题等级为负数。这样方便很多)
    */
   static title2data(text2) {
     let list_itemInfo = [];
@@ -1189,13 +1218,21 @@ class ListProcess {
       if (codeBlockFlag == "") {
         const match2 = line.match(ABReg.reg_code);
         if (match2 && match2[3]) {
-          codeBlockFlag = match2[1] + match2[3];
-          list_itemInfo[list_itemInfo.length - 1].content = list_itemInfo[list_itemInfo.length - 1].content + "\n" + line;
+          if (mul_mode === "heading" || mul_mode === "") {
+            list_itemInfo.push({
+              content: line,
+              level: 0
+            });
+            mul_mode = "para";
+          } else {
+            codeBlockFlag = match2[1] + match2[3];
+            list_itemInfo[list_itemInfo.length - 1].content += "\n" + line;
+          }
           continue;
         }
       } else {
         if (line.indexOf(codeBlockFlag) == 0) codeBlockFlag = "";
-        list_itemInfo[list_itemInfo.length - 1].content = list_itemInfo[list_itemInfo.length - 1].content + "\n" + line;
+        list_itemInfo[list_itemInfo.length - 1].content += "\n" + line;
         continue;
       }
       const match_heading = line.match(ABReg.reg_heading_noprefix);
@@ -1212,21 +1249,125 @@ class ListProcess {
         list_itemInfo.push({
           content: match_list[4],
           level: match_list[1].length + 1
-          //+10
         });
         mul_mode = "list";
       } else if (/^\S/.test(line) && mul_mode == "list") {
-        list_itemInfo[list_itemInfo.length - 1].content = list_itemInfo[list_itemInfo.length - 1].content + "\n" + line;
+        list_itemInfo[list_itemInfo.length - 1].content += "\n" + line;
       } else {
         if (mul_mode == "para") {
-          list_itemInfo[list_itemInfo.length - 1].content = list_itemInfo[list_itemInfo.length - 1].content + "\n" + line;
+          list_itemInfo[list_itemInfo.length - 1].content += "\n" + line;
+        } else if (/^\s*$/.test(line)) {
+          continue;
+        } else {
+          list_itemInfo.push({
+            content: line,
+            level: 0
+          });
+          mul_mode = "para";
+        }
+      }
+    }
+    removeTailBlank();
+    return list_itemInfo;
+    function removeTailBlank() {
+      if (mul_mode == "para" || mul_mode == "list") {
+        list_itemInfo[list_itemInfo.length - 1].content = list_itemInfo[list_itemInfo.length - 1].content.replace(/\s*$/, "");
+      }
+    }
+  }
+  /**
+   * MarkdownIt 转列表数据
+   *
+   * @detail
+   * 与 title2data 的逻辑基本相同
+   *
+   * 这里要将Mdit标识 (@xxx)、正文、列表 的等级合为一块，所以存在偏移值：
+   *
+   * 1. Mdit等级,  = `@<数字>`-100,
+   * 2. 正文等级,  = 0,              取值[+1,+Infi]
+   * 3. 列表等级,  = `(.*)-`个数+1,  取值[0]
+   *
+   * 例如:
+   *
+   * :::
+   *
+   * @1 AAA
+   *
+   * aaa
+   *
+   * @2 BBB
+   *
+   * @2 B22
+   *
+   * ccc
+   * ddd
+   *
+   * @1 A22
+   *
+   * :::
+   *
+   * 会被转化为
+   *
+   * - AAA
+   *   - BBB
+   *   - B22
+   *     - ccc
+   *       ddd
+   * - A22
+   */
+  static mdit2data(text2) {
+    let list_itemInfo = [];
+    const list_text = text2.split("\n");
+    let mul_mode = "";
+    let codeBlockFlag = "";
+    for (let line of list_text) {
+      if (codeBlockFlag == "") {
+        const match2 = line.match(ABReg.reg_code);
+        if (match2 && match2[3]) {
+          if (mul_mode === "mdit" || mul_mode === "") {
+            list_itemInfo.push({
+              content: line,
+              level: 0
+            });
+            mul_mode = "para";
+          } else {
+            codeBlockFlag = match2[1] + match2[3];
+            list_itemInfo[list_itemInfo.length - 1].content += "\n" + line;
+          }
+          continue;
+        }
+      } else {
+        if (line.indexOf(codeBlockFlag) == 0) codeBlockFlag = "";
+        list_itemInfo[list_itemInfo.length - 1].content += "\n" + line;
+        continue;
+      }
+      const match_mdit = line.match(/^(\s*)@(\d+)\s+(.*)$/);
+      const match_list = line.match(ABReg.reg_list_noprefix);
+      if (match_mdit && !match_mdit[1]) {
+        removeTailBlank();
+        list_itemInfo.push({
+          content: match_mdit[3],
+          level: Number(match_mdit[2]) - 100
+        });
+        mul_mode = "mdit";
+      } else if (match_list) {
+        removeTailBlank();
+        list_itemInfo.push({
+          content: match_list[4],
+          level: match_list[1].length + 1
+        });
+        mul_mode = "list";
+      } else if (/^\S/.test(line) && mul_mode == "list") {
+        list_itemInfo[list_itemInfo.length - 1].content += "\n" + line;
+      } else {
+        if (mul_mode == "para") {
+          list_itemInfo[list_itemInfo.length - 1].content += "\n" + line;
         } else if (/^\s*$/.test(line)) {
           continue;
         } else {
           list_itemInfo.push({
             content: line,
             level: 0
-            //+10
           });
           mul_mode = "para";
         }
@@ -1461,6 +1602,16 @@ const abc_title2listdata = ABConvert.factory({
     return ListProcess.title2data(content);
   }
 });
+ABConvert.factory({
+  id: "mdit2listdata",
+  name: "mdit到listdata",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.list_stream,
+  detail: "mdit到listdata",
+  process: (el, header, content) => {
+    return ListProcess.mdit2data(content);
+  }
+});
 ABConvert.factory({
   id: "listdata2list",
   name: "listdata到列表",
@@ -2456,6 +2607,1085 @@ ABConvert.factory({
     return newContent;
   }
 });
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n2 = Array(a); e < a; e++) n2[e] = r[e];
+  return n2;
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function _iterableToArrayLimit(r, l2) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n2, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l2) ;
+      else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l2); f = true) ;
+    } catch (r2) {
+      o = true, n2 = r2;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n2;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+const entries = Object.entries, setPrototypeOf = Object.setPrototypeOf, isFrozen = Object.isFrozen, getPrototypeOf = Object.getPrototypeOf, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+let freeze = Object.freeze, seal = Object.seal, create = Object.create;
+let _ref = typeof Reflect !== "undefined" && Reflect, apply = _ref.apply, construct = _ref.construct;
+if (!freeze) {
+  freeze = function freeze2(x) {
+    return x;
+  };
+}
+if (!seal) {
+  seal = function seal2(x) {
+    return x;
+  };
+}
+if (!apply) {
+  apply = function apply2(func, thisArg) {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    return func.apply(thisArg, args);
+  };
+}
+if (!construct) {
+  construct = function construct2(Func) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    return new Func(...args);
+  };
+}
+const arrayForEach = unapply(Array.prototype.forEach);
+const arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
+const arrayPop = unapply(Array.prototype.pop);
+const arrayPush = unapply(Array.prototype.push);
+const arraySplice = unapply(Array.prototype.splice);
+const arrayIsArray = Array.isArray;
+const stringToLowerCase = unapply(String.prototype.toLowerCase);
+const stringToString = unapply(String.prototype.toString);
+const stringMatch = unapply(String.prototype.match);
+const stringReplace = unapply(String.prototype.replace);
+const stringIndexOf = unapply(String.prototype.indexOf);
+const stringTrim = unapply(String.prototype.trim);
+const numberToString = unapply(Number.prototype.toString);
+const booleanToString = unapply(Boolean.prototype.toString);
+const bigintToString = typeof BigInt === "undefined" ? null : unapply(BigInt.prototype.toString);
+const symbolToString = typeof Symbol === "undefined" ? null : unapply(Symbol.prototype.toString);
+const objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
+const objectToString = unapply(Object.prototype.toString);
+const regExpTest = unapply(RegExp.prototype.test);
+const typeErrorCreate = unconstruct(TypeError);
+function unapply(func) {
+  return function(thisArg) {
+    if (thisArg instanceof RegExp) {
+      thisArg.lastIndex = 0;
+    }
+    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      args[_key3 - 1] = arguments[_key3];
+    }
+    return apply(func, thisArg, args);
+  };
+}
+function unconstruct(Func) {
+  return function() {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    return construct(Func, args);
+  };
+}
+function addToSet(set2, array) {
+  let transformCaseFunc = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : stringToLowerCase;
+  if (setPrototypeOf) {
+    setPrototypeOf(set2, null);
+  }
+  if (!arrayIsArray(array)) {
+    return set2;
+  }
+  let l2 = array.length;
+  while (l2--) {
+    let element = array[l2];
+    if (typeof element === "string") {
+      const lcElement = transformCaseFunc(element);
+      if (lcElement !== element) {
+        if (!isFrozen(array)) {
+          array[l2] = lcElement;
+        }
+        element = lcElement;
+      }
+    }
+    set2[element] = true;
+  }
+  return set2;
+}
+function cleanArray(array) {
+  for (let index2 = 0; index2 < array.length; index2++) {
+    const isPropertyExist = objectHasOwnProperty(array, index2);
+    if (!isPropertyExist) {
+      array[index2] = null;
+    }
+  }
+  return array;
+}
+function clone$3(object) {
+  const newObject = create(null);
+  for (const _ref2 of entries(object)) {
+    var _ref3 = _slicedToArray(_ref2, 2);
+    const property = _ref3[0];
+    const value = _ref3[1];
+    const isPropertyExist = objectHasOwnProperty(object, property);
+    if (isPropertyExist) {
+      if (arrayIsArray(value)) {
+        newObject[property] = cleanArray(value);
+      } else if (value && typeof value === "object" && value.constructor === Object) {
+        newObject[property] = clone$3(value);
+      } else {
+        newObject[property] = value;
+      }
+    }
+  }
+  return newObject;
+}
+function stringifyValue(value) {
+  switch (typeof value) {
+    case "string": {
+      return value;
+    }
+    case "number": {
+      return numberToString(value);
+    }
+    case "boolean": {
+      return booleanToString(value);
+    }
+    case "bigint": {
+      return bigintToString ? bigintToString(value) : "0";
+    }
+    case "symbol": {
+      return symbolToString ? symbolToString(value) : "Symbol()";
+    }
+    case "undefined": {
+      return objectToString(value);
+    }
+    case "function":
+    case "object": {
+      if (value === null) {
+        return objectToString(value);
+      }
+      const valueAsRecord = value;
+      const valueToString = lookupGetter(valueAsRecord, "toString");
+      if (typeof valueToString === "function") {
+        const stringified = valueToString(valueAsRecord);
+        return typeof stringified === "string" ? stringified : objectToString(stringified);
+      }
+      return objectToString(value);
+    }
+    default: {
+      return objectToString(value);
+    }
+  }
+}
+function lookupGetter(object, prop2) {
+  while (object !== null) {
+    const desc = getOwnPropertyDescriptor(object, prop2);
+    if (desc) {
+      if (desc.get) {
+        return unapply(desc.get);
+      }
+      if (typeof desc.value === "function") {
+        return unapply(desc.value);
+      }
+    }
+    object = getPrototypeOf(object);
+  }
+  function fallbackValue() {
+    return null;
+  }
+  return fallbackValue;
+}
+function isRegex(value) {
+  try {
+    regExpTest(value, "");
+    return true;
+  } catch (_unused) {
+    return false;
+  }
+}
+const html$1$1 = freeze(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "search", "section", "select", "shadow", "slot", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]);
+const svg$1 = freeze(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "enterkeyhint", "exportparts", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "inputmode", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "part", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]);
+const svgFilters = freeze(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]);
+const svgDisallowed = freeze(["animate", "color-profile", "cursor", "discard", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]);
+const mathMl$1 = freeze(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "mprescripts"]);
+const mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]);
+const text$2 = freeze(["#text"]);
+const html$2 = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "exportparts", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inert", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "part", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "slot", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "wrap", "xmlns"]);
+const svg = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "exponent", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "intercept", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "mask-type", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "slope", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "tablevalues", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]);
+const mathMl = freeze(["accent", "accentunder", "align", "bevelled", "close", "columnalign", "columnlines", "columnspacing", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lquote", "lspace", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]);
+const xml$1 = freeze(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]);
+const MUSTACHE_EXPR = seal(/{{[\w\W]*|^[\w\W]*}}/g);
+const ERB_EXPR = seal(/<%[\w\W]*|^[\w\W]*%>/g);
+const TMPLIT_EXPR = seal(/\${[\w\W]*/g);
+const DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/);
+const ARIA_ATTR = seal(/^aria-[\-\w]+$/);
+const IS_ALLOWED_URI = seal(
+  /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
+  // eslint-disable-line no-useless-escape
+);
+const IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+const ATTR_WHITESPACE = seal(
+  /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
+  // eslint-disable-line no-control-regex
+);
+const DOCTYPE_NAME = seal(/^html$/i);
+const CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
+const NODE_TYPE$1 = {
+  element: 1,
+  text: 3,
+  // Deprecated
+  progressingInstruction: 7,
+  comment: 8,
+  document: 9
+};
+const getGlobal = function getGlobal2() {
+  return typeof window === "undefined" ? null : window;
+};
+const _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes, purifyHostElement) {
+  if (typeof trustedTypes !== "object" || typeof trustedTypes.createPolicy !== "function") {
+    return null;
+  }
+  let suffix = null;
+  const ATTR_NAME = "data-tt-policy-suffix";
+  if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
+    suffix = purifyHostElement.getAttribute(ATTR_NAME);
+  }
+  const policyName = "dompurify" + (suffix ? "#" + suffix : "");
+  try {
+    return trustedTypes.createPolicy(policyName, {
+      createHTML(html2) {
+        return html2;
+      },
+      createScriptURL(scriptUrl) {
+        return scriptUrl;
+      }
+    });
+  } catch (_) {
+    console.warn("TrustedTypes policy " + policyName + " could not be created.");
+    return null;
+  }
+};
+const _createHooksMap = function _createHooksMap2() {
+  return {
+    afterSanitizeAttributes: [],
+    afterSanitizeElements: [],
+    afterSanitizeShadowDOM: [],
+    beforeSanitizeAttributes: [],
+    beforeSanitizeElements: [],
+    beforeSanitizeShadowDOM: [],
+    uponSanitizeAttribute: [],
+    uponSanitizeElement: [],
+    uponSanitizeShadowNode: []
+  };
+};
+function createDOMPurify() {
+  let window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
+  const DOMPurify = (root2) => createDOMPurify(root2);
+  DOMPurify.version = "3.4.3";
+  DOMPurify.removed = [];
+  if (!window2 || !window2.document || window2.document.nodeType !== NODE_TYPE$1.document || !window2.Element) {
+    DOMPurify.isSupported = false;
+    return DOMPurify;
+  }
+  let document2 = window2.document;
+  const originalDocument = document2;
+  const currentScript = originalDocument.currentScript;
+  const DocumentFragment = window2.DocumentFragment, HTMLTemplateElement = window2.HTMLTemplateElement, Node3 = window2.Node, Element2 = window2.Element, NodeFilter = window2.NodeFilter, _window$NamedNodeMap = window2.NamedNodeMap, NamedNodeMap = _window$NamedNodeMap === void 0 ? window2.NamedNodeMap || window2.MozNamedAttrMap : _window$NamedNodeMap, HTMLFormElement = window2.HTMLFormElement, DOMParser = window2.DOMParser, trustedTypes = window2.trustedTypes;
+  const ElementPrototype = Element2.prototype;
+  const cloneNode2 = lookupGetter(ElementPrototype, "cloneNode");
+  const remove2 = lookupGetter(ElementPrototype, "remove");
+  const getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
+  const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
+  const getParentNode = lookupGetter(ElementPrototype, "parentNode");
+  if (typeof HTMLTemplateElement === "function") {
+    const template = document2.createElement("template");
+    if (template.content && template.content.ownerDocument) {
+      document2 = template.content.ownerDocument;
+    }
+  }
+  let trustedTypesPolicy;
+  let emptyHTML = "";
+  const _document = document2, implementation = _document.implementation, createNodeIterator = _document.createNodeIterator, createDocumentFragment = _document.createDocumentFragment, getElementsByTagName2 = _document.getElementsByTagName;
+  const importNode = originalDocument.importNode;
+  let hooks = _createHooksMap();
+  DOMPurify.isSupported = typeof entries === "function" && typeof getParentNode === "function" && implementation && implementation.createHTMLDocument !== void 0;
+  const MUSTACHE_EXPR$1 = MUSTACHE_EXPR, ERB_EXPR$1 = ERB_EXPR, TMPLIT_EXPR$1 = TMPLIT_EXPR, DATA_ATTR$1 = DATA_ATTR, ARIA_ATTR$1 = ARIA_ATTR, IS_SCRIPT_OR_DATA$1 = IS_SCRIPT_OR_DATA, ATTR_WHITESPACE$1 = ATTR_WHITESPACE, CUSTOM_ELEMENT$1 = CUSTOM_ELEMENT;
+  let IS_ALLOWED_URI$1 = IS_ALLOWED_URI;
+  let ALLOWED_TAGS = null;
+  const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text$2]);
+  let ALLOWED_ATTR = null;
+  const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html$2, ...svg, ...mathMl, ...xml$1]);
+  let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {
+    tagNameCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    },
+    attributeNameCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    },
+    allowCustomizedBuiltInElements: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: false
+    }
+  }));
+  let FORBID_TAGS = null;
+  let FORBID_ATTR = null;
+  const EXTRA_ELEMENT_HANDLING = Object.seal(create(null, {
+    tagCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    },
+    attributeCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    }
+  }));
+  let ALLOW_ARIA_ATTR = true;
+  let ALLOW_DATA_ATTR = true;
+  let ALLOW_UNKNOWN_PROTOCOLS = false;
+  let ALLOW_SELF_CLOSE_IN_ATTR = true;
+  let SAFE_FOR_TEMPLATES = false;
+  let SAFE_FOR_XML = true;
+  let WHOLE_DOCUMENT = false;
+  let SET_CONFIG = false;
+  let FORCE_BODY = false;
+  let RETURN_DOM = false;
+  let RETURN_DOM_FRAGMENT = false;
+  let RETURN_TRUSTED_TYPE = false;
+  let SANITIZE_DOM = true;
+  let SANITIZE_NAMED_PROPS = false;
+  const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
+  let KEEP_CONTENT = true;
+  let IN_PLACE = false;
+  let USE_PROFILES = {};
+  let FORBID_CONTENTS = null;
+  const DEFAULT_FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
+  let DATA_URI_TAGS = null;
+  const DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]);
+  let URI_SAFE_ATTRIBUTES = null;
+  const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]);
+  const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+  const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+  const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+  let NAMESPACE = HTML_NAMESPACE;
+  let IS_EMPTY_INPUT = false;
+  let ALLOWED_NAMESPACES = null;
+  const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
+  let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
+  let HTML_INTEGRATION_POINTS = addToSet({}, ["annotation-xml"]);
+  const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ["title", "style", "font", "a", "script"]);
+  let PARSER_MEDIA_TYPE = null;
+  const SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
+  const DEFAULT_PARSER_MEDIA_TYPE = "text/html";
+  let transformCaseFunc = null;
+  let CONFIG = null;
+  const formElement = document2.createElement("form");
+  const isRegexOrFunction = function isRegexOrFunction2(testValue) {
+    return testValue instanceof RegExp || testValue instanceof Function;
+  };
+  const _parseConfig = function _parseConfig2() {
+    let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    if (CONFIG && CONFIG === cfg) {
+      return;
+    }
+    if (!cfg || typeof cfg !== "object") {
+      cfg = {};
+    }
+    cfg = clone$3(cfg);
+    PARSER_MEDIA_TYPE = // eslint-disable-next-line unicorn/prefer-includes
+    SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
+    transformCaseFunc = PARSER_MEDIA_TYPE === "application/xhtml+xml" ? stringToString : stringToLowerCase;
+    ALLOWED_TAGS = objectHasOwnProperty(cfg, "ALLOWED_TAGS") && arrayIsArray(cfg.ALLOWED_TAGS) ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
+    ALLOWED_ATTR = objectHasOwnProperty(cfg, "ALLOWED_ATTR") && arrayIsArray(cfg.ALLOWED_ATTR) ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
+    ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, "ALLOWED_NAMESPACES") && arrayIsArray(cfg.ALLOWED_NAMESPACES) ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
+    URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") && arrayIsArray(cfg.ADD_URI_SAFE_ATTR) ? addToSet(clone$3(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+    DATA_URI_TAGS = objectHasOwnProperty(cfg, "ADD_DATA_URI_TAGS") && arrayIsArray(cfg.ADD_DATA_URI_TAGS) ? addToSet(clone$3(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
+    FORBID_CONTENTS = objectHasOwnProperty(cfg, "FORBID_CONTENTS") && arrayIsArray(cfg.FORBID_CONTENTS) ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
+    FORBID_TAGS = objectHasOwnProperty(cfg, "FORBID_TAGS") && arrayIsArray(cfg.FORBID_TAGS) ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone$3({});
+    FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") && arrayIsArray(cfg.FORBID_ATTR) ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone$3({});
+    USE_PROFILES = objectHasOwnProperty(cfg, "USE_PROFILES") ? cfg.USE_PROFILES && typeof cfg.USE_PROFILES === "object" ? clone$3(cfg.USE_PROFILES) : cfg.USE_PROFILES : false;
+    ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
+    ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
+    ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false;
+    ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false;
+    SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false;
+    SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false;
+    WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false;
+    RETURN_DOM = cfg.RETURN_DOM || false;
+    RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false;
+    RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false;
+    FORCE_BODY = cfg.FORCE_BODY || false;
+    SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
+    SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false;
+    KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
+    IN_PLACE = cfg.IN_PLACE || false;
+    IS_ALLOWED_URI$1 = isRegex(cfg.ALLOWED_URI_REGEXP) ? cfg.ALLOWED_URI_REGEXP : IS_ALLOWED_URI;
+    NAMESPACE = typeof cfg.NAMESPACE === "string" ? cfg.NAMESPACE : HTML_NAMESPACE;
+    MATHML_TEXT_INTEGRATION_POINTS = objectHasOwnProperty(cfg, "MATHML_TEXT_INTEGRATION_POINTS") && cfg.MATHML_TEXT_INTEGRATION_POINTS && typeof cfg.MATHML_TEXT_INTEGRATION_POINTS === "object" ? clone$3(cfg.MATHML_TEXT_INTEGRATION_POINTS) : addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
+    HTML_INTEGRATION_POINTS = objectHasOwnProperty(cfg, "HTML_INTEGRATION_POINTS") && cfg.HTML_INTEGRATION_POINTS && typeof cfg.HTML_INTEGRATION_POINTS === "object" ? clone$3(cfg.HTML_INTEGRATION_POINTS) : addToSet({}, ["annotation-xml"]);
+    const customElementHandling = objectHasOwnProperty(cfg, "CUSTOM_ELEMENT_HANDLING") && cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING === "object" ? clone$3(cfg.CUSTOM_ELEMENT_HANDLING) : create(null);
+    CUSTOM_ELEMENT_HANDLING = create(null);
+    if (objectHasOwnProperty(customElementHandling, "tagNameCheck") && isRegexOrFunction(customElementHandling.tagNameCheck)) {
+      CUSTOM_ELEMENT_HANDLING.tagNameCheck = customElementHandling.tagNameCheck;
+    }
+    if (objectHasOwnProperty(customElementHandling, "attributeNameCheck") && isRegexOrFunction(customElementHandling.attributeNameCheck)) {
+      CUSTOM_ELEMENT_HANDLING.attributeNameCheck = customElementHandling.attributeNameCheck;
+    }
+    if (objectHasOwnProperty(customElementHandling, "allowCustomizedBuiltInElements") && typeof customElementHandling.allowCustomizedBuiltInElements === "boolean") {
+      CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = customElementHandling.allowCustomizedBuiltInElements;
+    }
+    if (SAFE_FOR_TEMPLATES) {
+      ALLOW_DATA_ATTR = false;
+    }
+    if (RETURN_DOM_FRAGMENT) {
+      RETURN_DOM = true;
+    }
+    if (USE_PROFILES) {
+      ALLOWED_TAGS = addToSet({}, text$2);
+      ALLOWED_ATTR = create(null);
+      if (USE_PROFILES.html === true) {
+        addToSet(ALLOWED_TAGS, html$1$1);
+        addToSet(ALLOWED_ATTR, html$2);
+      }
+      if (USE_PROFILES.svg === true) {
+        addToSet(ALLOWED_TAGS, svg$1);
+        addToSet(ALLOWED_ATTR, svg);
+        addToSet(ALLOWED_ATTR, xml$1);
+      }
+      if (USE_PROFILES.svgFilters === true) {
+        addToSet(ALLOWED_TAGS, svgFilters);
+        addToSet(ALLOWED_ATTR, svg);
+        addToSet(ALLOWED_ATTR, xml$1);
+      }
+      if (USE_PROFILES.mathMl === true) {
+        addToSet(ALLOWED_TAGS, mathMl$1);
+        addToSet(ALLOWED_ATTR, mathMl);
+        addToSet(ALLOWED_ATTR, xml$1);
+      }
+    }
+    EXTRA_ELEMENT_HANDLING.tagCheck = null;
+    EXTRA_ELEMENT_HANDLING.attributeCheck = null;
+    if (objectHasOwnProperty(cfg, "ADD_TAGS")) {
+      if (typeof cfg.ADD_TAGS === "function") {
+        EXTRA_ELEMENT_HANDLING.tagCheck = cfg.ADD_TAGS;
+      } else if (arrayIsArray(cfg.ADD_TAGS)) {
+        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+          ALLOWED_TAGS = clone$3(ALLOWED_TAGS);
+        }
+        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
+      }
+    }
+    if (objectHasOwnProperty(cfg, "ADD_ATTR")) {
+      if (typeof cfg.ADD_ATTR === "function") {
+        EXTRA_ELEMENT_HANDLING.attributeCheck = cfg.ADD_ATTR;
+      } else if (arrayIsArray(cfg.ADD_ATTR)) {
+        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+          ALLOWED_ATTR = clone$3(ALLOWED_ATTR);
+        }
+        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
+      }
+    }
+    if (objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") && arrayIsArray(cfg.ADD_URI_SAFE_ATTR)) {
+      addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
+    }
+    if (objectHasOwnProperty(cfg, "FORBID_CONTENTS") && arrayIsArray(cfg.FORBID_CONTENTS)) {
+      if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+        FORBID_CONTENTS = clone$3(FORBID_CONTENTS);
+      }
+      addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
+    }
+    if (objectHasOwnProperty(cfg, "ADD_FORBID_CONTENTS") && arrayIsArray(cfg.ADD_FORBID_CONTENTS)) {
+      if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+        FORBID_CONTENTS = clone$3(FORBID_CONTENTS);
+      }
+      addToSet(FORBID_CONTENTS, cfg.ADD_FORBID_CONTENTS, transformCaseFunc);
+    }
+    if (KEEP_CONTENT) {
+      ALLOWED_TAGS["#text"] = true;
+    }
+    if (WHOLE_DOCUMENT) {
+      addToSet(ALLOWED_TAGS, ["html", "head", "body"]);
+    }
+    if (ALLOWED_TAGS.table) {
+      addToSet(ALLOWED_TAGS, ["tbody"]);
+      delete FORBID_TAGS.tbody;
+    }
+    if (cfg.TRUSTED_TYPES_POLICY) {
+      if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== "function") {
+        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+      }
+      if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== "function") {
+        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+      }
+      trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
+      emptyHTML = trustedTypesPolicy.createHTML("");
+    } else {
+      if (trustedTypesPolicy === void 0) {
+        trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+      }
+      if (trustedTypesPolicy !== null && typeof emptyHTML === "string") {
+        emptyHTML = trustedTypesPolicy.createHTML("");
+      }
+    }
+    if (freeze) {
+      freeze(cfg);
+    }
+    CONFIG = cfg;
+  };
+  const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
+  const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
+  const _checkValidNamespace = function _checkValidNamespace2(element) {
+    let parent2 = getParentNode(element);
+    if (!parent2 || !parent2.tagName) {
+      parent2 = {
+        namespaceURI: NAMESPACE,
+        tagName: "template"
+      };
+    }
+    const tagName = stringToLowerCase(element.tagName);
+    const parentTagName = stringToLowerCase(parent2.tagName);
+    if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
+      return false;
+    }
+    if (element.namespaceURI === SVG_NAMESPACE) {
+      if (parent2.namespaceURI === HTML_NAMESPACE) {
+        return tagName === "svg";
+      }
+      if (parent2.namespaceURI === MATHML_NAMESPACE) {
+        return tagName === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+      }
+      return Boolean(ALL_SVG_TAGS[tagName]);
+    }
+    if (element.namespaceURI === MATHML_NAMESPACE) {
+      if (parent2.namespaceURI === HTML_NAMESPACE) {
+        return tagName === "math";
+      }
+      if (parent2.namespaceURI === SVG_NAMESPACE) {
+        return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
+      }
+      return Boolean(ALL_MATHML_TAGS[tagName]);
+    }
+    if (element.namespaceURI === HTML_NAMESPACE) {
+      if (parent2.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+        return false;
+      }
+      if (parent2.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+        return false;
+      }
+      return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+    }
+    if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) {
+      return true;
+    }
+    return false;
+  };
+  const _forceRemove = function _forceRemove2(node) {
+    arrayPush(DOMPurify.removed, {
+      element: node
+    });
+    try {
+      getParentNode(node).removeChild(node);
+    } catch (_) {
+      remove2(node);
+    }
+  };
+  const _removeAttribute = function _removeAttribute2(name2, element) {
+    try {
+      arrayPush(DOMPurify.removed, {
+        attribute: element.getAttributeNode(name2),
+        from: element
+      });
+    } catch (_) {
+      arrayPush(DOMPurify.removed, {
+        attribute: null,
+        from: element
+      });
+    }
+    element.removeAttribute(name2);
+    if (name2 === "is") {
+      if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+        try {
+          _forceRemove(element);
+        } catch (_) {
+        }
+      } else {
+        try {
+          element.setAttribute(name2, "");
+        } catch (_) {
+        }
+      }
+    }
+  };
+  const _initDocument = function _initDocument2(dirty) {
+    let doc = null;
+    let leadingWhitespace = null;
+    if (FORCE_BODY) {
+      dirty = "<remove></remove>" + dirty;
+    } else {
+      const matches = stringMatch(dirty, /^[\r\n\t ]+/);
+      leadingWhitespace = matches && matches[0];
+    }
+    if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && NAMESPACE === HTML_NAMESPACE) {
+      dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + "</body></html>";
+    }
+    const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+    if (NAMESPACE === HTML_NAMESPACE) {
+      try {
+        doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+      } catch (_) {
+      }
+    }
+    if (!doc || !doc.documentElement) {
+      doc = implementation.createDocument(NAMESPACE, "template", null);
+      try {
+        doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
+      } catch (_) {
+      }
+    }
+    const body = doc.body || doc.documentElement;
+    if (dirty && leadingWhitespace) {
+      body.insertBefore(document2.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+    }
+    if (NAMESPACE === HTML_NAMESPACE) {
+      return getElementsByTagName2.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0];
+    }
+    return WHOLE_DOCUMENT ? doc.documentElement : body;
+  };
+  const _createNodeIterator = function _createNodeIterator2(root2) {
+    return createNodeIterator.call(
+      root2.ownerDocument || root2,
+      root2,
+      // eslint-disable-next-line no-bitwise
+      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION,
+      null
+    );
+  };
+  const _isClobbered = function _isClobbered2(element) {
+    return element instanceof HTMLFormElement && (typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function");
+  };
+  const _isNode = function _isNode2(value) {
+    return typeof Node3 === "function" && value instanceof Node3;
+  };
+  function _executeHooks(hooks2, currentNode, data2) {
+    arrayForEach(hooks2, (hook) => {
+      hook.call(DOMPurify, currentNode, data2, CONFIG);
+    });
+  }
+  const _sanitizeElements = function _sanitizeElements2(currentNode) {
+    let content = null;
+    _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+    if (_isClobbered(currentNode)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    const tagName = transformCaseFunc(currentNode.nodeName);
+    _executeHooks(hooks.uponSanitizeElement, currentNode, {
+      tagName,
+      allowedTags: ALLOWED_TAGS
+    });
+    if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (SAFE_FOR_XML && currentNode.namespaceURI === HTML_NAMESPACE && tagName === "style" && _isNode(currentNode.firstElementChild)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (currentNode.nodeType === NODE_TYPE$1.progressingInstruction) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE$1.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (FORBID_TAGS[tagName] || !(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && !ALLOWED_TAGS[tagName]) {
+      if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
+        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
+          return false;
+        }
+        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
+          return false;
+        }
+      }
+      if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+        const parentNode = getParentNode(currentNode) || currentNode.parentNode;
+        const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+        if (childNodes && parentNode) {
+          const childCount = childNodes.length;
+          for (let i = childCount - 1; i >= 0; --i) {
+            const childClone = cloneNode2(childNodes[i], true);
+            parentNode.insertBefore(childClone, getNextSibling(currentNode));
+          }
+        }
+      }
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (currentNode instanceof Element2 && !_checkValidNamespace(currentNode)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE$1.text) {
+      content = currentNode.textContent;
+      arrayForEach([MUSTACHE_EXPR$1, ERB_EXPR$1, TMPLIT_EXPR$1], (expr) => {
+        content = stringReplace(content, expr, " ");
+      });
+      if (currentNode.textContent !== content) {
+        arrayPush(DOMPurify.removed, {
+          element: currentNode.cloneNode()
+        });
+        currentNode.textContent = content;
+      }
+    }
+    _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+    return false;
+  };
+  const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
+    if (FORBID_ATTR[lcName]) {
+      return false;
+    }
+    if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) {
+      return false;
+    }
+    const nameIsPermitted = ALLOWED_ATTR[lcName] || EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag);
+    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR$1, lcName)) ;
+    else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$1, lcName)) ;
+    else if (!nameIsPermitted || FORBID_ATTR[lcName]) {
+      if (
+        // First condition does a very basic check if a) it's basically a valid custom element tagname AND
+        // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+        // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
+        _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName, lcTag)) || // Alternative, second condition checks if it's an `is`-attribute, AND
+        // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+        lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))
+      ) ;
+      else {
+        return false;
+      }
+    } else if (URI_SAFE_ATTRIBUTES[lcName]) ;
+    else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE$1, ""))) ;
+    else if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]) ;
+    else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$1, stringReplace(value, ATTR_WHITESPACE$1, ""))) ;
+    else if (value) {
+      return false;
+    } else ;
+    return true;
+  };
+  const RESERVED_CUSTOM_ELEMENT_NAMES = addToSet({}, ["annotation-xml", "color-profile", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "missing-glyph"]);
+  const _isBasicCustomElement = function _isBasicCustomElement2(tagName) {
+    return !RESERVED_CUSTOM_ELEMENT_NAMES[stringToLowerCase(tagName)] && regExpTest(CUSTOM_ELEMENT$1, tagName);
+  };
+  const _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
+    _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
+    const attributes2 = currentNode.attributes;
+    if (!attributes2 || _isClobbered(currentNode)) {
+      return;
+    }
+    const hookEvent = {
+      attrName: "",
+      attrValue: "",
+      keepAttr: true,
+      allowedAttributes: ALLOWED_ATTR,
+      forceKeepAttr: void 0
+    };
+    let l2 = attributes2.length;
+    while (l2--) {
+      const attr2 = attributes2[l2];
+      const name2 = attr2.name, namespaceURI = attr2.namespaceURI, attrValue = attr2.value;
+      const lcName = transformCaseFunc(name2);
+      const initValue = attrValue;
+      let value = name2 === "value" ? initValue : stringTrim(initValue);
+      hookEvent.attrName = lcName;
+      hookEvent.attrValue = value;
+      hookEvent.keepAttr = true;
+      hookEvent.forceKeepAttr = void 0;
+      _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
+      value = hookEvent.attrValue;
+      if (SANITIZE_NAMED_PROPS && (lcName === "id" || lcName === "name") && stringIndexOf(value, SANITIZE_NAMED_PROPS_PREFIX) !== 0) {
+        _removeAttribute(name2, currentNode);
+        value = SANITIZE_NAMED_PROPS_PREFIX + value;
+      }
+      if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) {
+        _removeAttribute(name2, currentNode);
+        continue;
+      }
+      if (lcName === "attributename" && stringMatch(value, "href")) {
+        _removeAttribute(name2, currentNode);
+        continue;
+      }
+      if (hookEvent.forceKeepAttr) {
+        continue;
+      }
+      if (!hookEvent.keepAttr) {
+        _removeAttribute(name2, currentNode);
+        continue;
+      }
+      if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
+        _removeAttribute(name2, currentNode);
+        continue;
+      }
+      if (SAFE_FOR_TEMPLATES) {
+        arrayForEach([MUSTACHE_EXPR$1, ERB_EXPR$1, TMPLIT_EXPR$1], (expr) => {
+          value = stringReplace(value, expr, " ");
+        });
+      }
+      const lcTag = transformCaseFunc(currentNode.nodeName);
+      if (!_isValidAttribute(lcTag, lcName, value)) {
+        _removeAttribute(name2, currentNode);
+        continue;
+      }
+      if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") {
+        if (namespaceURI) ;
+        else {
+          switch (trustedTypes.getAttributeType(lcTag, lcName)) {
+            case "TrustedHTML": {
+              value = trustedTypesPolicy.createHTML(value);
+              break;
+            }
+            case "TrustedScriptURL": {
+              value = trustedTypesPolicy.createScriptURL(value);
+              break;
+            }
+          }
+        }
+      }
+      if (value !== initValue) {
+        try {
+          if (namespaceURI) {
+            currentNode.setAttributeNS(namespaceURI, name2, value);
+          } else {
+            currentNode.setAttribute(name2, value);
+          }
+          if (_isClobbered(currentNode)) {
+            _forceRemove(currentNode);
+          } else {
+            arrayPop(DOMPurify.removed);
+          }
+        } catch (_) {
+          _removeAttribute(name2, currentNode);
+        }
+      }
+    }
+    _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
+  };
+  const _sanitizeShadowDOM2 = function _sanitizeShadowDOM(fragment) {
+    let shadowNode = null;
+    const shadowIterator = _createNodeIterator(fragment);
+    _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
+    while (shadowNode = shadowIterator.nextNode()) {
+      _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
+      _sanitizeElements(shadowNode);
+      _sanitizeAttributes(shadowNode);
+      if (shadowNode.content instanceof DocumentFragment) {
+        _sanitizeShadowDOM2(shadowNode.content);
+      }
+    }
+    _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
+  };
+  const _sanitizeAttachedShadowRoots2 = function _sanitizeAttachedShadowRoots(root2) {
+    if (root2.nodeType === NODE_TYPE$1.element && root2.shadowRoot instanceof DocumentFragment) {
+      const sr = root2.shadowRoot;
+      _sanitizeAttachedShadowRoots2(sr);
+      _sanitizeShadowDOM2(sr);
+    }
+    const childNodes = root2.childNodes;
+    if (!childNodes) {
+      return;
+    }
+    const snapshot = [];
+    arrayForEach(childNodes, (child) => {
+      arrayPush(snapshot, child);
+    });
+    for (const child of snapshot) {
+      _sanitizeAttachedShadowRoots2(child);
+    }
+  };
+  DOMPurify.sanitize = function(dirty) {
+    let cfg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    let body = null;
+    let importedNode = null;
+    let currentNode = null;
+    let returnNode = null;
+    IS_EMPTY_INPUT = !dirty;
+    if (IS_EMPTY_INPUT) {
+      dirty = "<!-->";
+    }
+    if (typeof dirty !== "string" && !_isNode(dirty)) {
+      dirty = stringifyValue(dirty);
+      if (typeof dirty !== "string") {
+        throw typeErrorCreate("dirty is not a string, aborting");
+      }
+    }
+    if (!DOMPurify.isSupported) {
+      return dirty;
+    }
+    if (!SET_CONFIG) {
+      _parseConfig(cfg);
+    }
+    DOMPurify.removed = [];
+    if (typeof dirty === "string") {
+      IN_PLACE = false;
+    }
+    if (IN_PLACE) {
+      const nn = dirty.nodeName;
+      if (typeof nn === "string") {
+        const tagName = transformCaseFunc(nn);
+        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+          throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
+        }
+      }
+      _sanitizeAttachedShadowRoots2(dirty);
+    } else if (dirty instanceof Node3) {
+      body = _initDocument("<!---->");
+      importedNode = body.ownerDocument.importNode(dirty, true);
+      if (importedNode.nodeType === NODE_TYPE$1.element && importedNode.nodeName === "BODY") {
+        body = importedNode;
+      } else if (importedNode.nodeName === "HTML") {
+        body = importedNode;
+      } else {
+        body.appendChild(importedNode);
+      }
+      _sanitizeAttachedShadowRoots2(importedNode);
+    } else {
+      if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && // eslint-disable-next-line unicorn/prefer-includes
+      dirty.indexOf("<") === -1) {
+        return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+      }
+      body = _initDocument(dirty);
+      if (!body) {
+        return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
+      }
+    }
+    if (body && FORCE_BODY) {
+      _forceRemove(body.firstChild);
+    }
+    const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
+    while (currentNode = nodeIterator.nextNode()) {
+      _sanitizeElements(currentNode);
+      _sanitizeAttributes(currentNode);
+      if (currentNode.content instanceof DocumentFragment) {
+        _sanitizeShadowDOM2(currentNode.content);
+      }
+    }
+    if (IN_PLACE) {
+      return dirty;
+    }
+    if (RETURN_DOM) {
+      if (SAFE_FOR_TEMPLATES) {
+        body.normalize();
+        let html2 = body.innerHTML;
+        arrayForEach([MUSTACHE_EXPR$1, ERB_EXPR$1, TMPLIT_EXPR$1], (expr) => {
+          html2 = stringReplace(html2, expr, " ");
+        });
+        body.innerHTML = html2;
+      }
+      if (RETURN_DOM_FRAGMENT) {
+        returnNode = createDocumentFragment.call(body.ownerDocument);
+        while (body.firstChild) {
+          returnNode.appendChild(body.firstChild);
+        }
+      } else {
+        returnNode = body;
+      }
+      if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {
+        returnNode = importNode.call(originalDocument, returnNode, true);
+      }
+      return returnNode;
+    }
+    let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+    if (WHOLE_DOCUMENT && ALLOWED_TAGS["!doctype"] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
+      serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
+    }
+    if (SAFE_FOR_TEMPLATES) {
+      arrayForEach([MUSTACHE_EXPR$1, ERB_EXPR$1, TMPLIT_EXPR$1], (expr) => {
+        serializedHTML = stringReplace(serializedHTML, expr, " ");
+      });
+    }
+    return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+  };
+  DOMPurify.setConfig = function() {
+    let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    _parseConfig(cfg);
+    SET_CONFIG = true;
+  };
+  DOMPurify.clearConfig = function() {
+    CONFIG = null;
+    SET_CONFIG = false;
+  };
+  DOMPurify.isValidAttribute = function(tag, attr2, value) {
+    if (!CONFIG) {
+      _parseConfig({});
+    }
+    const lcTag = transformCaseFunc(tag);
+    const lcName = transformCaseFunc(attr2);
+    return _isValidAttribute(lcTag, lcName, value);
+  };
+  DOMPurify.addHook = function(entryPoint, hookFunction) {
+    if (typeof hookFunction !== "function") {
+      return;
+    }
+    arrayPush(hooks[entryPoint], hookFunction);
+  };
+  DOMPurify.removeHook = function(entryPoint, hookFunction) {
+    if (hookFunction !== void 0) {
+      const index2 = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+      return index2 === -1 ? void 0 : arraySplice(hooks[entryPoint], index2, 1)[0];
+    }
+    return arrayPop(hooks[entryPoint]);
+  };
+  DOMPurify.removeHooks = function(entryPoint) {
+    hooks[entryPoint] = [];
+  };
+  DOMPurify.removeAllHooks = function() {
+    hooks = _createHooksMap();
+  };
+  return DOMPurify;
+}
+var purify = createDOMPurify();
 ABConvert.factory({
   id: "md",
   name: "md",
@@ -2475,7 +3705,7 @@ ABConvert.factory({
   process_param: ABConvert_IOEnum.text,
   process_return: ABConvert_IOEnum.el,
   process: (el, header, content) => {
-    el.innerHTML = `<p>${content.replace(/ /g, "&nbsp;").split("\n").join("<br/>")}</p>`;
+    el.innerHTML = purify.sanitize(`<p>${content.replace(/ /g, "&nbsp;").split("\n").join("<br/>")}</p>`);
     return el;
   }
 });
@@ -3195,12 +4425,10 @@ ABConvert.factory({
   process_return: ABConvert_IOEnum.json,
   process: (el, header, content) => {
     return JSON.stringify(
-      ABAlias_json.map((item) => {
-        return {
-          regex: item.regex.toString(),
-          replacement: item.replacement
-        };
-      }),
+      Array.from(get_ABAlias_iter(), (item) => ({
+        regex: item.regex.toString(),
+        replacement: item.replacement
+      })),
       null,
       2
     );
@@ -15151,7 +16379,7 @@ ABConvert.factory({
 async function render_pumlText(text2, div) {
   var encoded = plantumlEncoder.encode(text2);
   let url = "http://www.plantuml.com/plantuml/img/" + encoded;
-  div.innerHTML = `<img src="${url}">`;
+  div.innerHTML = purify.sanitize(`<img src="${url}">`);
   return div;
 }
 function getID(length = 16) {
@@ -15326,206 +16554,20 @@ async function data2mindmap(list_itemInfo, div) {
   return render_mermaidText(mermaidText, div);
 }
 async function render_mermaidText(mermaidText, div) {
-  if (ABCSetting.env.startsWith("obsidian") && ABCSetting.mermaid) {
-    ABCSetting.mermaid.then(async (mermaid) => {
-      const { svg } = await mermaid.render("ab-mermaid-" + getID(), mermaidText);
-      div.innerHTML = svg;
+  if (ABCSetting.env.startsWith("obsidian") && ABCSetting.obsidian.mermaid) {
+    ABCSetting.obsidian.mermaid.then(async (mermaid) => {
+      const { svg: svg2 } = await mermaid.render("ab-mermaid-" + getID(), mermaidText);
+      const div_mermaid = document.createElement("div");
+      div.appendChild(div_mermaid);
+      div_mermaid.classList.add("mermaid");
+      div_mermaid.innerHTML = svg2;
     });
   } else {
     div.classList.add("ab-raw");
-    div.innerHTML = `<div class="ab-raw-data" type-data="mermaid" content-data='${mermaidText}'></div>`;
+    div.innerHTML = purify.sanitize(`<div class="ab-raw-data" type-data="mermaid" content-data='${mermaidText}'></div>`);
   }
   return div;
 }
-function abConvertEvent(d, isCycle = false) {
-  if (d.querySelector(".ab-super-width")) {
-    const els_note = d.querySelectorAll(".ab-note");
-    for (const el_note of els_note) {
-      if (el_note.querySelector(".ab-super-width")) {
-        const el_replace = el_note.parentNode;
-        if (el_replace && el_replace.classList.contains("ab-replace")) {
-          el_replace.classList.add("ab-super-width-p");
-        }
-      }
-    }
-    const els_view = document.querySelectorAll(".app-container .workspace-leaf");
-    for (const el_view of els_view) {
-      el_view.style.setProperty("--ab-width-outer", (el_view.offsetWidth - 40).toString() + "px");
-    }
-  }
-  if (d.querySelector(".ab-nodes-node")) {
-    const els_min = document.querySelectorAll(".ab-nodes.min .ab-nodes-node");
-    const list_children = d.querySelectorAll(".ab-nodes-node");
-    for (const children2 of list_children) {
-      const el_content = children2.querySelector(".ab-nodes-content");
-      if (!el_content) continue;
-      const el_child = children2.querySelector(".ab-nodes-children");
-      if (!el_child) continue;
-      const el_bracket = el_child.querySelector(".ab-nodes-bracket");
-      if (!el_bracket) continue;
-      const el_bracket2 = el_child.querySelector(".ab-nodes-bracket2");
-      if (!el_bracket2) continue;
-      const els_child = el_child.childNodes;
-      if (els_child.length < 3) {
-        el_bracket.style.setProperty("display", "none");
-        el_bracket2.style.setProperty("display", "none");
-        continue;
-      }
-      const el_child_first = els_child[2];
-      const el_child_last = els_child[els_child.length - 1];
-      const el_child_first_content = el_child_first.querySelector(".ab-nodes-content");
-      const el_child_last_content = el_child_last.querySelector(".ab-nodes-content");
-      let height = 0;
-      let heightToReduce = (el_child_first.offsetHeight + el_child_last.offsetHeight) / 2;
-      if (els_child.length == 3) {
-        height = el_child_first_content.offsetHeight - 20 > 20 ? el_child_first_content.offsetHeight - 20 : 20;
-        el_bracket2.style.cssText = `
-          height: ${height}px;
-          top: calc(50% - ${height / 2}px);
-        `;
-      } else {
-        el_bracket2.style.cssText = `
-          height: calc(100% - ${heightToReduce}px);
-          top: ${el_child_first.offsetHeight / 2}px;
-        `;
-      }
-      if (Array.prototype.includes.call(els_min, children2)) {
-        if (els_child.length == 3) {
-          el_bracket.style.cssText = `
-            display: block;
-            top: calc(50% + ${el_content.offsetHeight / 2}px - 3px);
-            clip-path: circle(40% at 50% 40%);
-          `;
-        } else {
-          el_bracket.setAttribute("display", "none");
-        }
-        if (els_child.length == 3 && el_content.offsetHeight == el_child_first_content.offsetHeight) {
-          el_bracket2.style.cssText = `
-            height: 1px;
-            top: calc(50% + ${el_content.offsetHeight / 2}px - 1px);
-            width: 18px; /* 可以溢出点 */
-            border-radius: 0;
-            border: none;
-            border-bottom: 1px solid var(--node-color);
-          `;
-        } else {
-          if (els_child.length == 3) {
-            height = el_child_last_content.offsetHeight / 2 - el_content.offsetHeight / 2;
-            el_bracket2.style.setProperty("height", `${height}px`);
-            el_bracket2.style.setProperty("top", `calc(50% + ${el_content.offsetHeight / 2}px)`);
-            el_bracket2.style.setProperty("border-radius", `0 0 0 10px`);
-            el_bracket2.style.setProperty("border-top", `0`);
-          } else {
-            heightToReduce = el_child_first.offsetHeight / 2 + el_child_first_content.offsetHeight / 2 + el_child_last.offsetHeight / 2 - el_child_last_content.offsetHeight / 2;
-            el_bracket2.style.setProperty("height", `calc(100% - ${heightToReduce}px + 1px)`);
-            el_bracket2.style.setProperty("top", `${el_child_first.offsetHeight / 2 + el_child_first_content.offsetHeight / 2 - 1}px`);
-          }
-          el_bracket2.style.setProperty("width", "20px");
-        }
-      }
-    }
-  }
-  if (d.querySelector(".ab-items.ab-lay-vfall:not(.js-waterfall):not(.ab-lay-hfall):not(.ab-lay-grid)")) {
-    const root_el_list = d.querySelectorAll(".ab-items.ab-lay-vfall:not(.js-waterfall):not(.ab-lay-hfall):not(.ab-lay-grid)");
-    for (const root_el of root_el_list) {
-      root_el.classList.add("js-waterfall");
-      const list_children = root_el.querySelectorAll(".ab-items-item");
-      const columnCountTmp = parseInt(window.getComputedStyle(root_el).getPropertyValue("column-count"));
-      let columnCount;
-      if (columnCountTmp && !isNaN(columnCountTmp) && columnCountTmp > 0) {
-        columnCount = columnCountTmp;
-      } else if (root_el.classList.contains("ab-col-auto") && list_children.length <= 4) {
-        columnCount = list_children.length;
-        root_el.classList.add("ab-col" + columnCount);
-      } else {
-        columnCount = 4;
-        root_el.classList.add("ab-col" + columnCount);
-      }
-      const height_cache = [];
-      const el_cache = [];
-      for (let i = 0; i < columnCount; i++) {
-        height_cache.push(0);
-        el_cache.push([]);
-      }
-      for (const children2 of list_children) {
-        const minValue = Math.min.apply(null, height_cache);
-        const minIndex = height_cache.indexOf(minValue);
-        const heightTmp = parseInt(window.getComputedStyle(children2).getPropertyValue("height"));
-        height_cache[minIndex] += heightTmp && !isNaN(heightTmp) && heightTmp > 0 ? heightTmp : 10;
-        el_cache[minIndex].push(children2);
-      }
-      const fillNumber = columnCount - list_children.length % columnCount;
-      if (fillNumber != 4) {
-        for (let i = 0; i < fillNumber; i++) {
-          const children2 = document.createElement("div");
-          children2.classList.add(".ab-items-item.placeholder");
-          children2.setAttribute("style", "height: 20px");
-          const minValue = Math.min.apply(null, height_cache);
-          const minIndex = height_cache.indexOf(minValue);
-          height_cache[minIndex] += 20;
-          el_cache[minIndex].push(children2);
-        }
-      }
-      root_el.innerHTML = "";
-      for (let i = 0; i < columnCount; i++) {
-        for (const j of el_cache[i]) {
-          root_el.appendChild(j);
-        }
-      }
-    }
-  }
-  if (!isCycle && d.querySelector(".ab-markmap-div")) {
-    const divEl = d;
-    let markmapId = "";
-    if (divEl.tagName === "DIV") {
-      markmapId = divEl.querySelector(".ab-markmap-div")?.id || "";
-    }
-    let mindmaps;
-    if (markmapId) {
-      mindmaps = document.querySelectorAll("#" + markmapId);
-    } else {
-      mindmaps = document.querySelectorAll(".ab-markmap-div");
-    }
-    for (const el_div of mindmaps) {
-      const el_svg = el_div.querySelector("svg");
-      const el_g = el_svg?.querySelector("g");
-      if (el_svg && el_g) {
-        const scale_new = el_g.getBBox().height / el_div.offsetWidth;
-        el_svg.setAttribute("style", `height:${el_g.getBBox().height * scale_new + 40}px`);
-        markmap_event(d);
-      }
-    }
-  }
-}
-function markmap_event(d) {
-  if (d.querySelector(".ab-markmap-svg")) {
-    console.log("  - markmap_event");
-    let script_el = document.querySelector('script[script-id="ab-markmap-script"]');
-    if (script_el) script_el.remove();
-    const divEl = d;
-    let markmapId = "";
-    if (divEl.tagName === "DIV") {
-      markmapId = divEl.querySelector(".ab-markmap-svg")?.id || "";
-    }
-    script_el = document.createElement("script");
-    document.head.appendChild(script_el);
-    script_el.type = "module";
-    script_el.setAttribute("script-id", "ab-markmap-script");
-    script_el.textContent = `
-    import { Markmap, } from 'https://jspm.dev/markmap-view';
-    const markmapId = "${markmapId || ""}";
-    let mindmaps;
-    if (markmapId) {
-      mindmaps = document.querySelectorAll('#' + markmapId);
-    } else {
-      mindmaps = document.querySelectorAll('.ab-markmap-svg'); // 注意一下这里的选择器
-    }
-    for(const mindmap of mindmaps) {
-      mindmap.innerHTML = "";
-      Markmap.create(mindmap,null,JSON.parse(mindmap.getAttribute('data-json')));
-    }`;
-  }
-}
 const testPath = "npm2url/dist/index.cjs";
 const defaultProviders = {
   jsdelivr: (path) => `https://cdn.jsdelivr.net/npm/${path}`,
@@ -41151,8 +42193,8 @@ function requireKatex() {
             var _functions = {};
             var _htmlGroupBuilders = {};
             var _mathmlGroupBuilders = {};
-            function defineFunction(_ref) {
-              var type = _ref.type, names = _ref.names, props = _ref.props, handler = _ref.handler, htmlBuilder = _ref.htmlBuilder, mathmlBuilder = _ref.mathmlBuilder;
+            function defineFunction(_ref2) {
+              var type = _ref2.type, names = _ref2.names, props = _ref2.props, handler = _ref2.handler, htmlBuilder = _ref2.htmlBuilder, mathmlBuilder = _ref2.mathmlBuilder;
               var data2 = {
                 type,
                 numArgs: props.numArgs,
@@ -42150,8 +43192,8 @@ function requireKatex() {
               props: {
                 numArgs: 1
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var base = args[0];
                 return {
                   type: "accentUnder",
@@ -42226,8 +43268,8 @@ function requireKatex() {
                 numArgs: 1,
                 numOptionalArgs: 1
               },
-              handler: function handler(_ref, args, optArgs) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args, optArgs) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 return {
                   type: "xArrow",
                   mode: parser.mode,
@@ -42319,8 +43361,8 @@ function requireKatex() {
                 numArgs: 1,
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser;
                 var arg = assertNodeType(args[0], "ordgroup");
                 var group = arg.body;
                 var number = "";
@@ -42358,8 +43400,8 @@ function requireKatex() {
                 greediness: 3,
                 argTypes: ["color", "original"]
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser;
                 var color2 = assertNodeType(args[0], "color-token").color;
                 var body = args[1];
                 return {
@@ -42405,8 +43447,8 @@ function requireKatex() {
                 argTypes: ["size"],
                 allowedInText: true
               },
-              handler: function handler(_ref, args, optArgs) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args, optArgs) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var size = optArgs[0];
                 var newRow = funcName === "\\cr";
                 var newLine = false;
@@ -42499,8 +43541,8 @@ function requireKatex() {
                 numArgs: 0,
                 allowedInText: true
               },
-              handler: function handler(_ref) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 parser.consumeSpaces();
                 var token = parser.fetch();
                 if (globalMap[token.text]) {
@@ -42834,14 +43876,14 @@ function requireKatex() {
             var delimiter_sqrtSvg = function sqrtSvg(sqrtName, height, viewBoxHeight, extraViniculum, options) {
               var path = sqrtPath(sqrtName, extraViniculum, viewBoxHeight);
               var pathNode = new domTree_PathNode(sqrtName, path);
-              var svg = new SvgNode([pathNode], {
+              var svg2 = new SvgNode([pathNode], {
                 // Note: 1000:1 ratio of viewBox to document em width.
                 "width": "400em",
                 "height": height + "em",
                 "viewBox": "0 0 400000 " + viewBoxHeight,
                 "preserveAspectRatio": "xMinYMin slice"
               });
-              return buildCommon.makeSvgSpan(["hide-tail"], [svg], options);
+              return buildCommon.makeSvgSpan(["hide-tail"], [svg2], options);
             };
             var makeSqrtImage = function makeSqrtImage2(height, options) {
               var newOptions = options.havingBaseSizing();
@@ -43451,8 +44493,8 @@ function requireKatex() {
                 greediness: 3,
                 argTypes: ["color", "text"]
               },
-              handler: function handler(_ref, args, optArgs) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args, optArgs) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var color2 = assertNodeType(args[0], "color-token").color;
                 var body = args[1];
                 return {
@@ -43530,8 +44572,8 @@ function requireKatex() {
               mathmlBuilder: enclose_mathmlBuilder
             });
             var _environments = {};
-            function defineEnvironment(_ref) {
-              var type = _ref.type, names = _ref.names, props = _ref.props, handler = _ref.handler, htmlBuilder = _ref.htmlBuilder, mathmlBuilder = _ref.mathmlBuilder;
+            function defineEnvironment(_ref2) {
+              var type = _ref2.type, names = _ref2.names, props = _ref2.props, handler = _ref2.handler, htmlBuilder = _ref2.htmlBuilder, mathmlBuilder = _ref2.mathmlBuilder;
               var data2 = {
                 type,
                 numArgs: props.numArgs || 0,
@@ -43562,8 +44604,8 @@ function requireKatex() {
               }
               return hlineInfo;
             }
-            function parseArray(parser, _ref, style) {
-              var hskipBeforeAndAfter = _ref.hskipBeforeAndAfter, addJot = _ref.addJot, cols = _ref.cols, arraystretch = _ref.arraystretch, colSeparationType = _ref.colSeparationType;
+            function parseArray(parser, _ref2, style) {
+              var hskipBeforeAndAfter = _ref2.hskipBeforeAndAfter, addJot = _ref2.addJot, cols = _ref2.cols, arraystretch = _ref2.arraystretch, colSeparationType = _ref2.colSeparationType;
               parser.gullet.beginGroup();
               parser.gullet.macros.set("\\\\", "\\cr");
               if (!arraystretch) {
@@ -44202,8 +45244,8 @@ function requireKatex() {
                 numArgs: 1,
                 argTypes: ["text"]
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var nameGroup = args[0];
                 if (nameGroup.type !== "ordgroup") {
                   throw new src_ParseError("Invalid environment name", nameGroup);
@@ -44283,8 +45325,8 @@ function requireKatex() {
               props: {
                 numArgs: 1
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var body = args[0];
                 return {
                   type: "mclass",
@@ -44407,8 +45449,8 @@ function requireKatex() {
                 numArgs: 1,
                 greediness: 2
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var body = args[0];
                 var func = funcName;
                 if (func in fontAliases) {
@@ -44662,8 +45704,8 @@ function requireKatex() {
                 numArgs: 2,
                 greediness: 2
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var numer = args[0];
                 var denom = args[1];
                 var hasBarLine;
@@ -44964,8 +46006,8 @@ function requireKatex() {
               props: {
                 numArgs: 1
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 return {
                   type: "horizBrace",
                   mode: parser.mode,
@@ -44985,8 +46027,8 @@ function requireKatex() {
                 argTypes: ["url", "original"],
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser;
                 var body = args[1];
                 var href = assertNodeType(args[0], "url").url;
                 if (!parser.settings.isTrusted({
@@ -45066,9 +46108,9 @@ function requireKatex() {
                 argTypes: ["raw", "original"],
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
-                _ref.token;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
+                _ref2.token;
                 var value = assertNodeType(args[0], "raw").string;
                 var body = args[1];
                 if (parser.settings.strict) {
@@ -45151,8 +46193,8 @@ function requireKatex() {
                 numArgs: 2,
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser;
                 return {
                   type: "htmlmathml",
                   mode: parser.mode,
@@ -45199,8 +46241,8 @@ function requireKatex() {
                 argTypes: ["raw", "url"],
                 allowedInText: false
               },
-              handler: function handler(_ref, args, optArgs) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args, optArgs) {
+                var parser = _ref2.parser;
                 var width = {
                   number: 0,
                   unit: "em"
@@ -45314,8 +46356,8 @@ function requireKatex() {
                 argTypes: ["size"],
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var size = assertNodeType(args[0], "size");
                 if (parser.settings.strict) {
                   var mathFunction = funcName[1] === "m";
@@ -45354,8 +46396,8 @@ function requireKatex() {
                 numArgs: 1,
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var body = args[0];
                 return {
                   type: "lap",
@@ -45399,8 +46441,8 @@ function requireKatex() {
                 allowedInText: true,
                 allowedInMath: false
               },
-              handler: function handler(_ref, args) {
-                var funcName = _ref.funcName, parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var funcName = _ref2.funcName, parser = _ref2.parser;
                 var outerMode = parser.mode;
                 parser.switchMode("math");
                 var close = funcName === "\\(" ? "\\)" : "$";
@@ -45448,8 +46490,8 @@ function requireKatex() {
               props: {
                 numArgs: 4
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser;
                 return {
                   type: "mathchoice",
                   mode: parser.mode,
@@ -45681,8 +46723,8 @@ function requireKatex() {
               props: {
                 numArgs: 0
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var fName = funcName;
                 if (fName.length === 1) {
                   fName = singleCharBigOps[fName];
@@ -45888,8 +46930,8 @@ function requireKatex() {
               props: {
                 numArgs: 1
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var body = args[0];
                 return {
                   type: "operatorname",
@@ -45921,8 +46963,8 @@ function requireKatex() {
               props: {
                 numArgs: 1
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser;
                 var body = args[0];
                 return {
                   type: "overline",
@@ -45967,8 +47009,8 @@ function requireKatex() {
                 numArgs: 1,
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser;
                 var body = args[0];
                 return {
                   type: "phantom",
@@ -46066,8 +47108,8 @@ function requireKatex() {
                 argTypes: ["size", "hbox"],
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser;
                 var amount = assertNodeType(args[0], "size").value;
                 var body = args[1];
                 return {
@@ -46104,8 +47146,8 @@ function requireKatex() {
                 numOptionalArgs: 1,
                 argTypes: ["size", "size", "size"]
               },
-              handler: function handler(_ref, args, optArgs) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args, optArgs) {
+                var parser = _ref2.parser;
                 var shift = optArgs[0];
                 var width = assertNodeType(args[0], "size");
                 var height = assertNodeType(args[1], "size");
@@ -46178,8 +47220,8 @@ function requireKatex() {
                 numArgs: 0,
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var breakOnTokenText = _ref.breakOnTokenText, funcName = _ref.funcName, parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var breakOnTokenText = _ref2.breakOnTokenText, funcName = _ref2.funcName, parser = _ref2.parser;
                 var body = parser.parseExpression(false, breakOnTokenText);
                 return {
                   type: "sizing",
@@ -46206,8 +47248,8 @@ function requireKatex() {
                 numOptionalArgs: 1,
                 allowedInText: true
               },
-              handler: function handler(_ref, args, optArgs) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args, optArgs) {
+                var parser = _ref2.parser;
                 var smashHeight = false;
                 var smashDepth = false;
                 var tbArg = optArgs[0] && assertNodeType(optArgs[0], "ordgroup");
@@ -46287,8 +47329,8 @@ function requireKatex() {
                 numArgs: 1,
                 numOptionalArgs: 1
               },
-              handler: function handler(_ref, args, optArgs) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args, optArgs) {
+                var parser = _ref2.parser;
                 var index2 = optArgs[0];
                 var body = args[0];
                 return {
@@ -46372,8 +47414,8 @@ function requireKatex() {
                 numArgs: 0,
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var breakOnTokenText = _ref.breakOnTokenText, funcName = _ref.funcName, parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var breakOnTokenText = _ref2.breakOnTokenText, funcName = _ref2.funcName, parser = _ref2.parser;
                 var body = parser.parseExpression(true, breakOnTokenText);
                 var style = funcName.slice(1, funcName.length - 5);
                 return {
@@ -46758,8 +47800,8 @@ function requireKatex() {
                 greediness: 2,
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser, funcName = _ref.funcName;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser, funcName = _ref2.funcName;
                 var body = args[0];
                 return {
                   type: "text",
@@ -46785,8 +47827,8 @@ function requireKatex() {
                 numArgs: 1,
                 allowedInText: true
               },
-              handler: function handler(_ref, args) {
-                var parser = _ref.parser;
+              handler: function handler(_ref2, args) {
+                var parser = _ref2.parser;
                 return {
                   type: "underline",
                   mode: parser.mode,
@@ -49656,7 +50698,7 @@ ABConvert.factory({
   process_return: ABConvert_IOEnum.el,
   process: (el, header, content) => {
     list2markmap(content, el);
-    markmap_event(el);
+    ABCSetting.obsidian.markmap_event?.(el);
     return el;
   }
 });
@@ -49672,13 +50714,46 @@ function list2markmap(markdown, div) {
     svg_div.classList.add("ab-markmap-div");
     svg_div.id = "ab-markmap-div-" + id;
     const html_str = `<svg class="ab-markmap-svg" id="ab-markmap-${id}" data-json='${JSON.stringify(root2)}' style="height:${height_adapt}px"></svg>`;
-    svg_div.innerHTML = html_str;
+    svg_div.innerHTML = purify.sanitize(html_str, {
+      USE_PROFILES: { svg: true }
+    });
   } else {
     div.classList.add("ab-raw");
-    div.innerHTML = `<div class="ab-raw-data" type-data="markmap" content-data='${markdown}'></div>`;
+    div.innerHTML = purify.sanitize(`<div class="ab-raw-data" type-data="markmap" content-data='${markdown}'></div>`);
   }
   return div;
 }
+async function markmap_event(d) {
+  if (ABCSetting.env == "obsidian-min") return;
+  if (d.querySelector(".ab-markmap-svg")) {
+    console.log("  - markmap_event");
+    let script_el = document.querySelector('script[script-id="ab-markmap-script"]');
+    if (script_el) script_el.remove();
+    const divEl = d;
+    let markmapId = "";
+    if (divEl.tagName === "DIV") {
+      markmapId = divEl.querySelector(".ab-markmap-svg")?.id || "";
+    }
+    script_el = document.createElement("script");
+    document.head.appendChild(script_el);
+    script_el.type = "module";
+    script_el.setAttribute("script-id", "ab-markmap-script");
+    script_el.textContent = `
+    import { Markmap, } from 'https://jspm.dev/markmap-view';
+    const markmapId = "${markmapId || ""}";
+    let mindmaps;
+    if (markmapId) {
+      mindmaps = document.querySelectorAll('#' + markmapId);
+    } else {
+      mindmaps = document.querySelectorAll('.ab-markmap-svg'); // 注意一下这里的选择器
+    }
+    for(const mindmap of mindmaps) {
+      mindmap.innerHTML = "";
+      Markmap.create(mindmap,null,JSON.parse(mindmap.getAttribute('data-json')));
+    }`;
+  }
+}
+ABCSetting.obsidian.markmap_event = markmap_event;
 const md = new MarkdownIt({
   html: true,
   // 启用 HTML 标签解析
@@ -49735,6 +50810,166 @@ const quartz_transformer_anyblock = () => {
     }
   };
 };
+function abConvertEvent(d, isCycle = false) {
+  if (d.querySelector(".ab-super-width")) {
+    const els_note = d.querySelectorAll(".ab-note");
+    for (const el_note of els_note) {
+      if (el_note.classList.contains("ab-super-width") || el_note.querySelector(".ab-super-width")) {
+        const el_replace = el_note.parentNode;
+        if (el_replace && el_replace.classList.contains("ab-replace")) {
+          el_replace.classList.add("ab-super-width-p");
+        }
+      }
+    }
+    const els_view = document.querySelectorAll(".app-container .workspace-leaf");
+    for (const el_view of els_view) {
+      el_view.style.setProperty("--ab-width-outer", (el_view.offsetWidth - 40).toString() + "px");
+    }
+  }
+  if (d.querySelector(".ab-nodes-node")) {
+    const els_min = document.querySelectorAll(".ab-nodes.min .ab-nodes-node");
+    const list_children = d.querySelectorAll(".ab-nodes-node");
+    for (const children2 of list_children) {
+      const el_content = children2.querySelector(".ab-nodes-content");
+      if (!el_content) continue;
+      const el_child = children2.querySelector(".ab-nodes-children");
+      if (!el_child) continue;
+      const el_bracket = el_child.querySelector(".ab-nodes-bracket");
+      if (!el_bracket) continue;
+      const el_bracket2 = el_child.querySelector(".ab-nodes-bracket2");
+      if (!el_bracket2) continue;
+      const els_child = el_child.childNodes;
+      if (els_child.length < 3) {
+        el_bracket.style.setProperty("display", "none");
+        el_bracket2.style.setProperty("display", "none");
+        continue;
+      }
+      const el_child_first = els_child[2];
+      const el_child_last = els_child[els_child.length - 1];
+      const el_child_first_content = el_child_first.querySelector(".ab-nodes-content");
+      const el_child_last_content = el_child_last.querySelector(".ab-nodes-content");
+      let height = 0;
+      let heightToReduce = (el_child_first.offsetHeight + el_child_last.offsetHeight) / 2;
+      if (els_child.length == 3) {
+        height = el_child_first_content.offsetHeight - 20 > 20 ? el_child_first_content.offsetHeight - 20 : 20;
+        el_bracket2.style.cssText = `
+          height: ${height}px;
+          top: calc(50% - ${height / 2}px);
+        `;
+      } else {
+        el_bracket2.style.cssText = `
+          height: calc(100% - ${heightToReduce}px);
+          top: ${el_child_first.offsetHeight / 2}px;
+        `;
+      }
+      if (Array.prototype.includes.call(els_min, children2)) {
+        if (els_child.length == 3) {
+          el_bracket.style.cssText = `
+            display: block;
+            top: calc(50% + ${el_content.offsetHeight / 2}px - 3px);
+            clip-path: circle(40% at 50% 40%);
+          `;
+        } else {
+          el_bracket.setAttribute("display", "none");
+        }
+        if (els_child.length == 3 && el_content.offsetHeight == el_child_first_content.offsetHeight) {
+          el_bracket2.style.cssText = `
+            height: 1px;
+            top: calc(50% + ${el_content.offsetHeight / 2}px - 1px);
+            width: 18px; /* 可以溢出点 */
+            border-radius: 0;
+            border: none;
+            border-bottom: 1px solid var(--node-color);
+          `;
+        } else {
+          if (els_child.length == 3) {
+            height = el_child_last_content.offsetHeight / 2 - el_content.offsetHeight / 2;
+            el_bracket2.style.setProperty("height", `${height}px`);
+            el_bracket2.style.setProperty("top", `calc(50% + ${el_content.offsetHeight / 2}px)`);
+            el_bracket2.style.setProperty("border-radius", `0 0 0 10px`);
+            el_bracket2.style.setProperty("border-top", `0`);
+          } else {
+            heightToReduce = el_child_first.offsetHeight / 2 + el_child_first_content.offsetHeight / 2 + el_child_last.offsetHeight / 2 - el_child_last_content.offsetHeight / 2;
+            el_bracket2.style.setProperty("height", `calc(100% - ${heightToReduce}px + 1px)`);
+            el_bracket2.style.setProperty("top", `${el_child_first.offsetHeight / 2 + el_child_first_content.offsetHeight / 2 - 1}px`);
+          }
+          el_bracket2.style.setProperty("width", "20px");
+        }
+      }
+    }
+  }
+  if (d.querySelector(".ab-items.ab-lay-vfall:not(.js-waterfall):not(.ab-lay-hfall):not(.ab-lay-grid)")) {
+    const root_el_list = d.querySelectorAll(".ab-items.ab-lay-vfall:not(.js-waterfall):not(.ab-lay-hfall):not(.ab-lay-grid)");
+    for (const root_el of root_el_list) {
+      root_el.classList.add("js-waterfall");
+      const list_children = root_el.querySelectorAll(".ab-items-item");
+      const columnCountTmp = parseInt(window.getComputedStyle(root_el).getPropertyValue("column-count"));
+      let columnCount;
+      if (columnCountTmp && !isNaN(columnCountTmp) && columnCountTmp > 0) {
+        columnCount = columnCountTmp;
+      } else if (root_el.classList.contains("ab-col-auto") && list_children.length <= 4) {
+        columnCount = list_children.length;
+        root_el.classList.add("ab-col" + columnCount);
+      } else {
+        columnCount = 4;
+        root_el.classList.add("ab-col" + columnCount);
+      }
+      const height_cache = [];
+      const el_cache = [];
+      for (let i = 0; i < columnCount; i++) {
+        height_cache.push(0);
+        el_cache.push([]);
+      }
+      for (const children2 of list_children) {
+        const minValue = Math.min.apply(null, height_cache);
+        const minIndex = height_cache.indexOf(minValue);
+        const heightTmp = parseInt(window.getComputedStyle(children2).getPropertyValue("height"));
+        height_cache[minIndex] += heightTmp && !isNaN(heightTmp) && heightTmp > 0 ? heightTmp : 10;
+        el_cache[minIndex].push(children2);
+      }
+      const fillNumber = columnCount - list_children.length % columnCount;
+      if (fillNumber != 4) {
+        for (let i = 0; i < fillNumber; i++) {
+          const children2 = document.createElement("div");
+          children2.classList.add(".ab-items-item.placeholder");
+          children2.setAttribute("style", "height: 20px");
+          const minValue = Math.min.apply(null, height_cache);
+          const minIndex = height_cache.indexOf(minValue);
+          height_cache[minIndex] += 20;
+          el_cache[minIndex].push(children2);
+        }
+      }
+      root_el.innerHTML = "";
+      for (let i = 0; i < columnCount; i++) {
+        for (const j of el_cache[i]) {
+          root_el.appendChild(j);
+        }
+      }
+    }
+  }
+  if (!isCycle && d.querySelector(".ab-markmap-div")) {
+    const divEl = d;
+    let markmapId = "";
+    if (divEl.tagName === "DIV") {
+      markmapId = divEl.querySelector(".ab-markmap-div")?.id || "";
+    }
+    let mindmaps;
+    if (markmapId) {
+      mindmaps = document.querySelectorAll("#" + markmapId);
+    } else {
+      mindmaps = document.querySelectorAll(".ab-markmap-div");
+    }
+    for (const el_div of mindmaps) {
+      const el_svg = el_div.querySelector("svg");
+      const el_g = el_svg?.querySelector("g");
+      if (el_svg && el_g) {
+        const scale_new = el_g.getBBox().height / el_div.offsetWidth;
+        el_svg.setAttribute("style", `height:${el_g.getBBox().height * scale_new + 40}px`);
+        ABCSetting.obsidian.markmap_event?.(d);
+      }
+    }
+  }
+}
 exports.ABConvertManager = ABConvertManager;
 exports.ABReg = ABReg;
 exports.abConvertEvent = abConvertEvent;