@cnblogs/markdown-it-presets 1.9.5 → 1.9.6

package/dist/es2015/index.mjs

@@ -1,3 +1,893 @@
-export * from './presets';
-export * from './math';
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/presets/index.ts
+import MarkdownIt from "markdown-it";
+import hljs from "highlight.js";
+import MarkdownItContainer from "markdown-it-container";
+import MdAbbr from "markdown-it-abbr";
+import MdDefList from "markdown-it-deflist";
+import MdEmoji from "markdown-it-emoji";
+import MdFootnote from "markdown-it-footnote";
+import MdMark from "markdown-it-mark";
+import MdSub from "markdown-it-sub";
+import MdSup from "markdown-it-sup";
+import MdAnchor from "markdown-it-anchor";
+import LazyHeaders from "markdown-it-lazy-headers";
+import InlineTokensIterator from "markdown-it-for-inline";
+import MarkdownTaskLists from "markdown-it-task-lists";
+import MarkdownItAttrs from "markdown-it-attrs";
+
+// src/presets/plugins/simple-math.plugin.ts
+function isValidDelimiter(state, pos) {
+  let max = state.posMax;
+  let canOpen = true;
+  let canClose = true;
+  let prevChar = pos > 0 ? state.src.charCodeAt(pos - 1) : -1;
+  let nextChar = pos + 1 <= max ? state.src.charCodeAt(pos + 1) : -1;
+  if (prevChar === 32 || prevChar === 9 || nextChar >= 48 && nextChar <= 57) {
+    canClose = false;
+  }
+  if (nextChar === 32 || nextChar === 9) {
+    canOpen = false;
+  }
+  return {
+    canOpen,
+    canClose
+  };
+}
+var mathInTable = (state) => {
+  const { src } = state;
+  const regex = /(\|.*\|)\n(\|\s*?-+:?\s*?)+\|\n(\|.*\|\n?)*?((\|.*?\$+.*\n?)+)/g;
+  const inlineMathRegex = /\$(.*?)\$/g;
+  state.src = src.replace(
+    regex,
+    (match, sub1, sub2, sub3, sub4) => match.replace(
+      sub4,
+      sub4.replace(inlineMathRegex, (match2, sub) => `$${sub.replace(/\\*?\|/g, "\\|")}$$`)
+    )
+  );
+  return true;
+};
+var mathInline = (state, silent) => {
+  let start, match, token, res, pos;
+  if (state.src[state.pos] !== "$") {
+    return false;
+  }
+  res = isValidDelimiter(state, state.pos);
+  if (!res.canOpen) {
+    if (!silent) {
+      state.pending += "$";
+    }
+    state.pos += 1;
+    return true;
+  }
+  start = state.pos + 1;
+  match = start;
+  while ((match = state.src.indexOf("$", match)) !== -1) {
+    pos = match - 1;
+    while (state.src[pos] === "\\") {
+      pos -= 1;
+    }
+    if ((match - pos) % 2 == 1) {
+      break;
+    }
+    match += 1;
+  }
+  if (match === -1) {
+    if (!silent) {
+      state.pending += "$";
+    }
+    state.pos = start;
+    return true;
+  }
+  if (match - start === 0) {
+    if (!silent) {
+      state.pending += "$$";
+    }
+    state.pos = start + 1;
+    return true;
+  }
+  res = isValidDelimiter(state, match);
+  if (!res.canClose) {
+    if (!silent) {
+      state.pending += "$";
+    }
+    state.pos = start;
+    return true;
+  }
+  if (!silent) {
+    token = state.push("math_inline", "math", 0);
+    token.markup = "$";
+    token.content = state.src.slice(start, match);
+  }
+  state.pos = match + 1;
+  return true;
+};
+var mathBlock = (state, start, end, silent) => {
+  let lastLine;
+  let next;
+  let lastPos;
+  let found = false;
+  let token;
+  let pos = state.bMarks[start] + state.tShift[start];
+  let max = state.eMarks[start];
+  if (pos + 2 > max) {
+    return false;
+  }
+  if (state.src[pos] !== "$" || state.src[pos + 1] !== "$") {
+    return false;
+  }
+  pos += 2;
+  if (silent) {
+    return true;
+  }
+  let firstLine = state.src.slice(pos, max);
+  if (firstLine.trim().slice(-2) === "$$") {
+    firstLine = firstLine.trim().slice(0, -2);
+    found = true;
+  }
+  for (next = start; !found; ) {
+    next++;
+    if (next >= end) {
+      break;
+    }
+    pos = state.bMarks[next] + state.tShift[next];
+    max = state.eMarks[next];
+    if (pos < max && state.tShift[next] < state.blkIndent) {
+      break;
+    }
+    if (state.src.slice(pos, max).trim().slice(-2) === "$$") {
+      lastPos = state.src.slice(0, max).lastIndexOf("$$");
+      lastLine = state.src.slice(pos, lastPos);
+      found = true;
+    }
+  }
+  state.line = next + 1;
+  token = state.push("math_block", "math", 0);
+  token.block = true;
+  token.content = (firstLine && firstLine.trim() ? firstLine + "\n" : "") + state.getLines(start + 1, next, state.tShift[start], true) + (lastLine && lastLine.trim() ? lastLine : "");
+  token.map = [start, state.line];
+  token.markup = "$$";
+  return true;
+};
+var simpleMathPlugin = (md) => {
+  md.core.ruler.before("block", "math_in_table", mathInTable);
+  md.inline.ruler.after("escape", "math_inline", mathInline);
+  md.block.ruler.after("blockquote", "math_block", mathBlock, {
+    alt: ["paragraph", "reference", "blockquote", "list"]
+  });
+  const simpleInlineRenderer = (tokens, idx) => {
+    return '<span class="math inline">\\(' + md.utils.escapeHtml(tokens[idx].content) + "\\)</span>";
+  };
+  const simpleBlockRenderer = (tokens, idx) => {
+    return '<p><div class="math display">\\[' + md.utils.escapeHtml(tokens[idx].content) + "\\]</div></p>";
+  };
+  md.renderer.rules.math_inline = simpleInlineRenderer;
+  md.renderer.rules.math_block = simpleBlockRenderer;
+};
+
+// src/presets/plugins/simple-mermaid.plugin.ts
+function diagramPlugin(md, options) {
+  function getLangName(info) {
+    return info.split(/\s+/g)[0];
+  }
+  let defaultFenceRenderer = md.renderer.rules.fence;
+  function customFenceRenderer(tokens, idx, options2, env, slf) {
+    let token = tokens[idx];
+    let info = token.info.trim();
+    let langName = info ? getLangName(info) : "";
+    if (langName.toLowerCase() === "mermaid") {
+      return '<div class="mermaid">' + md.utils.escapeHtml(token.content) + "</div>";
+    }
+    return defaultFenceRenderer(tokens, idx, options2, env, slf);
+  }
+  md.renderer.rules.fence = customFenceRenderer;
+}
+
+// src/presets/plugins/html-filter.plugin.ts
+var tagFilterRules = {
+  title: { rule: "escape" },
+  head: { rule: "escape" },
+  body: { rule: "escape" },
+  img: {
+    rule: "filterAttributes",
+    disabledAttributes: ["onerror"]
+  }
+};
+var HtmlFilterPlugin = (md) => {
+  const defaultHtmlBlock = md.renderer.rules.html_block;
+  md.renderer.rules.html_block = (tokens, idx, options, env, self) => {
+    const token = tokens[idx];
+    if (token.type === "html_block" && !token.tag) {
+      let { content } = token;
+      for (let tagName in tagFilterRules) {
+        const rule = tagFilterRules[tagName];
+        const { rule: handleStrategy, disabledAttributes } = rule;
+        if (handleStrategy === "escape") {
+          const start = `<${tagName}>`;
+          const end = `</${tagName}>`;
+          const matchStart = content.replace(new RegExp("\n", "g"), "").startsWith(start);
+          const matchEnd = content.replace(new RegExp("\n", "g"), "").endsWith(end);
+          if (matchStart || matchEnd) {
+            content = md.utils.escapeHtml(content);
+            break;
+          }
+        } else if (handleStrategy === "filterAttributes" && disabledAttributes != null && disabledAttributes.length > 0) {
+          for (let attribute of disabledAttributes) {
+            content = content.replace(
+              new RegExp(`(<${tagName}.*? +)(${attribute}=)(.*?>)`, "ig"),
+              (match, p1, p2, p3) => p1 + "data-" + p2 + p3
+            );
+          }
+        }
+      }
+      if (content !== token.content)
+        return content;
+    }
+    return defaultHtmlBlock(tokens, idx, options, env, self);
+  };
+};
+
+// src/presets/plugins/multiline-blockquote/multiline-blockquote.rule.ts
+var MultilineBlockquoteRule = (state, startLine, endLine) => {
+  let nextLine, token;
+  let pos = state.bMarks[startLine] + state.tShift[startLine];
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
+  }
+  let marker = state.src.charCodeAt(pos);
+  if (marker !== 62) {
+    return false;
+  }
+  let markerLength = state.skipChars(pos, marker) - pos;
+  if (markerLength !== 3)
+    return false;
+  if (state.src.charCodeAt(state.skipChars(
+    pos + markerLength,
+    32
+    /* ' ' */
+  )) !== 10) {
+    return false;
+  }
+  nextLine = startLine + 1;
+  while (nextLine < endLine) {
+    pos = state.bMarks[nextLine] + state.tShift[nextLine];
+    marker = state.src.charCodeAt(pos);
+    if (marker === 62 && (markerLength = state.skipChars(pos, marker) - pos) === 3) {
+      pos = state.skipChars(pos + markerLength, 32);
+      if (pos >= state.src.length || state.src.charCodeAt(pos) === 10)
+        break;
+    }
+    nextLine++;
+  }
+  if (nextLine > endLine) {
+    return false;
+  }
+  token = state.push("multiline_blockquote_open", "blockquote", 1);
+  token.markup = ">>>";
+  token.map = [startLine, 0];
+  state.md.block.tokenize(state, startLine + 1, nextLine);
+  token = state.push("multiline_blockquote_close", "blockquote", -1);
+  token.map = [nextLine, 0];
+  state.line = nextLine + 1;
+  return true;
+};
+
+// src/presets/plugins/multiline-blockquote/multiline-blockquote.plugin.ts
+var MultilineBlockquotePlugin = (md, options) => {
+  options != null ? options : options = {};
+  md.block.ruler.before("blockquote", "multiline_blockquote", (...args) => {
+    if (options.enable != null && !options.enable(md))
+      return false;
+    return MultilineBlockquoteRule.apply(void 0, args);
+  });
+};
+
+// src/presets/option.ts
+import GithubSlugger from "github-slugger";
+var defaultTaskListsOption = {
+  enable: true,
+  label: true,
+  labelAfter: true
+};
+var defaultMarkdownItOption = {
+  codeHighlight: false,
+  math: false,
+  disableRules: [],
+  html: false,
+  taskListsOption: defaultTaskListsOption
+};
+var defaultLinkifyOptions = {
+  fuzzyEmail: false,
+  fuzzyLink: false,
+  fuzzyLinkUseHttps: true
+};
+var anchorOption = {
+  level: 1,
+  slugify(str) {
+    const result = new GithubSlugger().slug(str);
+    return result === "" ? "_" : result;
+  }
+};
+
+// src/presets/plugins/toc/slugify.ts
+var slugify = function(s) {
+  return encodeURIComponent(String(s).trim().toLowerCase().replace(/\s+/g, "-"));
+};
+
+// src/presets/plugins/toc/toc-option.ts
+var defaultTocOption = {
+  includeLevel: [1, 2, 3, 4, 5, 6],
+  containerClass: "toc",
+  slugify,
+  markerPattern: /\[TOC]/im,
+  listType: "ul",
+  format: (content) => content.replace(/<\/?a.*?>/g, ""),
+  forceFullToc: false,
+  containerHeaderHtml: `<div class="toc-container-header">\u76EE\u5F55</div>`,
+  containerFooterHtml: void 0,
+  transformLink: void 0
+};
+
+// src/presets/plugins/toc/index.ts
+var defaults = defaultTocOption;
+var findHeadlineElements = (levels, tokens, options, md, env) => {
+  const headings = [];
+  let currentHeading = null;
+  tokens.forEach((token) => {
+    if (token.type === "heading_open") {
+      const id = findExistingIdAttr(token);
+      const level = parseInt(token.tag.toLowerCase().replace("h", ""), 10);
+      if (levels.indexOf(level) >= 0) {
+        currentHeading = {
+          level,
+          textContent: null,
+          anchor: id || null,
+          markdownContent: null
+        };
+      }
+    } else if (currentHeading && token.type === "inline") {
+      const textContent = token.children.filter((childToken) => childToken.type === "text" || childToken.type === "code_inline").reduce((acc, t) => acc + t.content, "");
+      currentHeading.textContent = textContent;
+      currentHeading.markdownContent = md.renderer.renderInline(token.children, options, env);
+      if (!currentHeading.anchor) {
+        currentHeading.anchor = options.slugify(textContent, token.content);
+      }
+    } else if (token.type === "heading_close") {
+      if (currentHeading) {
+        headings.push(currentHeading);
+      }
+      currentHeading = null;
+    }
+  });
+  return headings;
+};
+var findExistingIdAttr = (token) => {
+  if (token && token.attrs && token.attrs.length > 0) {
+    const idAttr = token.attrs.find((attr) => {
+      if (Array.isArray(attr) && attr.length >= 2) {
+        return attr[0] === "id";
+      }
+      return false;
+    });
+    if (idAttr && Array.isArray(idAttr) && idAttr.length >= 2) {
+      const [, val] = idAttr;
+      return val;
+    }
+  }
+  return null;
+};
+function getMinLevel(headlineItems) {
+  return Math.min(...headlineItems.map((item) => item.level));
+}
+var addListItem = (level, text, anchor, rootNode) => {
+  const listItem = {
+    level,
+    text,
+    anchor,
+    children: [],
+    parent: rootNode
+  };
+  rootNode.children.push(listItem);
+  return listItem;
+};
+var flatHeadlineItemsToNestedTree = (headlineItems) => {
+  const toc = {
+    level: getMinLevel(headlineItems) - 1,
+    anchor: null,
+    text: null,
+    children: [],
+    parent: null
+  };
+  let currentRootNode = toc;
+  let prevListItem = currentRootNode;
+  headlineItems.forEach((headlineItem) => {
+    if (headlineItem.level > prevListItem.level) {
+      Array.from({ length: headlineItem.level - prevListItem.level }).forEach((_) => {
+        currentRootNode = prevListItem;
+        prevListItem = addListItem(headlineItem.level, null, null, currentRootNode);
+      });
+      prevListItem.text = headlineItem.markdownContent;
+      prevListItem.anchor = headlineItem.anchor;
+    } else if (headlineItem.level === prevListItem.level) {
+      prevListItem = addListItem(
+        headlineItem.level,
+        headlineItem.markdownContent,
+        headlineItem.anchor,
+        currentRootNode
+      );
+    } else if (headlineItem.level < prevListItem.level) {
+      for (let i = 0; i < prevListItem.level - headlineItem.level; i++) {
+        currentRootNode = currentRootNode.parent;
+      }
+      prevListItem = addListItem(
+        headlineItem.level,
+        headlineItem.markdownContent,
+        headlineItem.anchor,
+        currentRootNode
+      );
+    }
+  });
+  return toc;
+};
+var tocItemToHtml = (tocItem, options, md) => {
+  return "<" + options.listType + ">" + tocItem.children.map((childItem) => {
+    let li = "<li>";
+    let anchor = childItem.anchor;
+    if (options && options.transformLink) {
+      anchor = options.transformLink(anchor);
+    }
+    let text = childItem.text ? options.format(childItem.text, md, anchor) : null;
+    li += anchor ? `<a href="#${anchor}">${text}</a>` : text || "";
+    return li + (childItem.children.length > 0 ? tocItemToHtml(childItem, options, md) : "") + "</li>";
+  }).join("") + "</" + options.listType + ">";
+};
+var plugin = (md, o) => {
+  const options = Object.assign({}, defaults, o);
+  const tocRegexp = options.markerPattern;
+  let gState;
+  const toc = (state, silent) => {
+    let token;
+    let match;
+    if (state.src.charCodeAt(state.pos) !== 91) {
+      return false;
+    }
+    if (silent) {
+      return false;
+    }
+    match = tocRegexp.exec(state.src.substr(state.pos));
+    match = !match ? [] : match.filter(function(m) {
+      return m;
+    });
+    if (match.length < 1) {
+      return false;
+    }
+    token = state.push("toc_open", "toc", 1);
+    token.markup = "[[toc]]";
+    token = state.push("toc_body", "", 0);
+    token = state.push("toc_close", "toc", -1);
+    const newline = state.src.indexOf("\n", state.pos);
+    if (newline !== -1) {
+      state.pos = newline;
+    } else {
+      state.pos = state.pos + state.posMax + 1;
+    }
+    return true;
+  };
+  md.renderer.rules.toc_open = (tokens, index) => {
+    let tocOpenHtml = '<div class="' + options.containerClass + '">';
+    if (options.containerHeaderHtml) {
+      tocOpenHtml += options.containerHeaderHtml;
+    }
+    return tocOpenHtml;
+  };
+  md.renderer.rules.toc_close = (tokens, index) => {
+    let tocFooterHtml = "";
+    if (options.containerFooterHtml) {
+      tocFooterHtml = options.containerFooterHtml;
+    }
+    return tocFooterHtml + "</div>";
+  };
+  md.renderer.rules.toc_body = (tokens, index, opt, env) => {
+    if (options.forceFullToc) {
+      throw "forceFullToc was removed in version 0.5.0. For more information, see https://github.com/Oktavilla/markdown-it-table-of-contents/pull/41";
+    } else {
+      const headlineItems = findHeadlineElements(options.includeLevel, gState.tokens, options, md, env);
+      const toc2 = flatHeadlineItemsToNestedTree(headlineItems);
+      return tocItemToHtml(toc2, options, md);
+    }
+  };
+  md.core.ruler.push("grab_state", (state) => {
+    gState = state;
+    return true;
+  });
+  md.inline.ruler.after("emphasis", "toc", toc);
+};
+
+// src/presets/plugins/highlight-code-lines.plugin.ts
+var LineNumbersRegex = /{([\d,\s-]+)}/;
+var LineNumberAttrRegex = /^([\d,\s-]+)/;
+var highlightCodeLines = (md, { enable } = {}) => {
+  const fence = md.renderer.rules.fence;
+  md.renderer.rules.fence = (tokens, idx, options, env, self) => {
+    const token = tokens[idx];
+    if (enable != null && !enable(md) || token.attrs == null || token.attrs.some(([attr]) => LineNumberAttrRegex.test(attr)) === false) {
+      return fence(tokens, idx, options, env, self);
+    }
+    let highlightedLines = [];
+    try {
+      highlightedLines = Array.from(
+        new Set(
+          token.attrs.map(([attr]) => attr.split(",").map((x) => x.trim())).flat().filter((attr) => attr != null && attr.length > 0 && LineNumberAttrRegex.test(attr)).map((v) => {
+            let [start, end] = v.split(/\s*?-\s*?/).map((v2) => parseInt(v2.trim(), 10));
+            start = start > 0 ? start : 1;
+            end = end > start ? end : start;
+            const paddedArr = new Array((start > end ? start - end : end - start) + 1).fill(0);
+            paddedArr.forEach((_, idx2) => {
+              paddedArr[idx2] = start + idx2;
+            });
+            return paddedArr;
+          }).flat()
+        )
+      );
+    } catch (ex) {
+      console.warn(ex);
+    }
+    const langName = token.info.replace(LineNumbersRegex, "").trim();
+    let code = md.utils.escapeHtml(token.content);
+    code = options.highlight ? options.highlight(code, langName, "") : code;
+    const tmpToken = Object.assign(token, {
+      attrs: [
+        ["class", langName ? `language-${langName}` : ""],
+        highlightedLines && highlightedLines.length > 0 ? ["data-lines-highlight", `[${highlightedLines.join(",")}]`] : []
+      ]
+    });
+    const attrs = self.renderAttrs(tmpToken);
+    return `<pre${attrs}><code${attrs}>${code.trim()}</code></pre>`;
+  };
+};
+
+// src/presets/plugins/meta.ts
+var meta = (state, startLine, endLine, silent) => {
+  if (startLine !== 0 || state.blkIndent !== 0) {
+    return false;
+  }
+  if (state.tShift[startLine] < 0) {
+    return false;
+  }
+  if (!state.getLines(startLine, startLine + 1, 0, false).match(/^---$/)) {
+    return false;
+  }
+  let line = startLine;
+  let matchedEndLine = -1;
+  while (line < endLine) {
+    line++;
+    const str = state.getLines(line, line + 1, 0, false);
+    if (str.match(/^---$/)) {
+      matchedEndLine = line;
+      break;
+    }
+    if (state.tShift[line] < 0) {
+      break;
+    }
+  }
+  if (matchedEndLine > -1) {
+    state.line = matchedEndLine + 1;
+    const token = state.push("fence", "code", 0);
+    token.content = state.getLines(startLine + 1, matchedEndLine, 0, true);
+    token.map = [startLine, matchedEndLine];
+    token.info = "yml";
+    token.markup = "---";
+    token.attrPush(["data-yaml-metadata", ""]);
+    return true;
+  }
+  return false;
+};
+
+// src/presets/plugins/unique-custom-id.ts
+var attrPluginName = "curly_attributes";
+var uniqueCustomIdAttr = (state) => {
+  const { tokens } = state;
+  let map;
+  tokens.filter((x) => !!x.attrGet("id")).forEach((token) => {
+    map != null ? map : map = {};
+    const idAttrValue = token.attrGet("id");
+    if (map.hasOwnProperty(idAttrValue)) {
+      const count = map[idAttrValue];
+      token.attrSet("id", `${idAttrValue}-${count}`);
+      map[idAttrValue] = count + 1;
+    } else {
+      map[idAttrValue] = 1;
+    }
+  });
+  map = void 0;
+};
+var plugin2 = (md, opt) => {
+  if (md.core.ruler.getRules("").some((x) => x.name === attrPluginName) != null) {
+    md.core.ruler.after(attrPluginName, "unique_custom_id_attribute", uniqueCustomIdAttr, opt);
+  }
+};
+
+// src/presets/index.ts
+var mdUtils = new MarkdownIt().utils;
+var defaultCodeHighlight = (str, lang) => {
+  if (lang && hljs.getLanguage(lang)) {
+    try {
+      const result = hljs.highlight(lang, str, true);
+      return `<pre class="hljs"><code data-lang="${result.language}">${result.value}</code></pre>`;
+    } catch (e) {
+    }
+  }
+  return `<pre class="hljs"><code>${mdUtils.escapeHtml(str)}</code></pre>`;
+};
+var addLinkAttributes = [
+  InlineTokensIterator,
+  "url_new_win",
+  "link_open",
+  (tokens, idx) => {
+    const token = tokens[idx];
+    const href = token.attrGet("href");
+    if (!href) {
+      return;
+    }
+    if (!href.startsWith("#")) {
+      token.attrPush(["target", "_blank"]);
+    }
+  }
+];
+var markdownItFactory = ({
+  html,
+  codeHighlight,
+  taskListsOption,
+  math,
+  disableRules,
+  linkify: linkifyOption
+} = defaultMarkdownItOption) => {
+  const mdOpt = {
+    html,
+    breaks: true,
+    linkify: true
+  };
+  taskListsOption != null ? taskListsOption : taskListsOption = defaultTaskListsOption;
+  linkifyOption = Object.assign({}, defaultLinkifyOptions, linkifyOption != null ? linkifyOption : defaultLinkifyOptions);
+  if (codeHighlight) {
+    mdOpt.highlight = defaultCodeHighlight;
+  }
+  const md = new MarkdownIt(mdOpt).use(MarkdownItContainer).use(diagramPlugin).use(MarkdownItAttrs, { allowedAttributes: ["id", "class", LineNumberAttrRegex], disableParagraphBlock: true }).use(MdAnchor, anchorOption).use(plugin2).use(plugin).use(MdAbbr).use(MdDefList).use(MdEmoji).use(MdFootnote).use(MdMark).use(MdSub).use(MdSup).use(highlightCodeLines).use(LazyHeaders).use(MarkdownTaskLists, taskListsOption).use(HtmlFilterPlugin).use(...addLinkAttributes).use(MultilineBlockquotePlugin);
+  md.block.ruler.before("hr", "meta", meta);
+  if (math) {
+    md.use(simpleMathPlugin);
+  }
+  if (disableRules && disableRules.length > 0) {
+    md.disable(disableRules);
+  }
+  const { normalize: defaultNormalize } = md.linkify.set(linkifyOption);
+  if (linkifyOption.fuzzyLink && linkifyOption.fuzzyLinkUseHttps) {
+    md.linkify.normalize = (match) => {
+      if (!match.schema) {
+        match.url = `https://${match.url}`;
+        return;
+      }
+      defaultNormalize(match);
+    };
+  }
+  return md;
+};
+
+// src/math/model.ts
+var MathEngine = /* @__PURE__ */ ((MathEngine2) => {
+  MathEngine2[MathEngine2["MathJax2"] = 0] = "MathJax2";
+  MathEngine2[MathEngine2["MathJax3"] = 1] = "MathJax3";
+  return MathEngine2;
+})(MathEngine || {});
+var defaultConfig = {
+  [0 /* MathJax2 */]: {
+    entryScript: "https://mathjax.cnblogs.com/2_7_5/MathJax.js?config=TeX-AMS-MML_HTMLorMML&delayStartupUntil=configured&v=20200504",
+    document: window.document,
+    engine: 0 /* MathJax2 */,
+    isEnabled: true
+  },
+  [1 /* MathJax3 */]: {
+    entryScript: "https://mathjax.cnblogs.com/3_2_1/es5/tex-mml-chtml.js",
+    document: window.document,
+    engine: 1 /* MathJax3 */,
+    isEnabled: true
+  }
+};
+
+// src/math/impl.ts
+import { loadScript } from "@cnblogs/load-script-css";
+var Mathjax2Renderer = class {
+  constructor() {
+    this._defaultConfig = defaultConfig[0 /* MathJax2 */];
+    this._defaultMathJaxConfig = {
+      tex2jax: {
+        inlineMath: [
+          ["$", "$"],
+          ["\\(", "\\)"]
+        ],
+        processClass: "math",
+        processEscapes: true
+      },
+      TeX: {
+        equationNumbers: {
+          autoNumber: "AMS",
+          useLabelIds: true
+        },
+        extensions: ["extpfeil.js", "mediawiki-texvc.js"],
+        Macros: { bm: "\\boldsymbol" }
+      },
+      "HTML-CSS": { linebreaks: { automatic: true } },
+      SVG: { linebreaks: { automatic: true } },
+      skipStartupTypeset: true
+    };
+    this._config = this._defaultConfig;
+  }
+  get _global() {
+    var _a;
+    return (_a = this._config.document.defaultView) != null ? _a : window;
+  }
+  render(container, callback) {
+    if (!this._config.isEnabled)
+      return Promise.resolve();
+    return this.init().then((mathjax) => {
+      if (!mathjax)
+        return;
+      const { onRendered } = this._config;
+      mathjax.Hub.Queue(["Typeset", mathjax.Hub, container]);
+      if (onRendered != null) {
+        mathjax.Hub.Queue(() => onRendered(mathjax));
+      }
+      if (callback) {
+        mathjax.Hub.Queue(callback);
+      }
+    }).catch(console.warn);
+  }
+  config(value) {
+    this._config = Object.assign({}, this._defaultConfig, value);
+    return this;
+  }
+  init() {
+    if (this._initTask)
+      return this._initTask;
+    const { entryScript, tapMathJaxConfig, document } = this._config;
+    return this._initTask = loadScript({
+      src: entryScript,
+      id: "mathjax",
+      timeoutSeconds: 10,
+      appendTo: document.head
+    }).then(() => {
+      var _a;
+      const { MathJax } = this._global;
+      if (MathJax) {
+        MathJax.Hub.Config(
+          (_a = tapMathJaxConfig == null ? void 0 : tapMathJaxConfig.call(
+            void 0,
+            Object.assign({}, this._defaultMathJaxConfig)
+          )) != null ? _a : __spreadValues({}, this._defaultMathJaxConfig)
+        );
+        MathJax.Hub.Configured();
+        return MathJax;
+      }
+    }).catch(() => this._initTask = void 0);
+  }
+};
+var MathJax3Renderer = class {
+  constructor() {
+    this._defaultConfig = defaultConfig[1 /* MathJax3 */];
+    this._defaultMathJaxConfig = {
+      tex: {
+        inlineMath: [
+          ["$", "$"],
+          ["\\(", "\\)"]
+        ],
+        processEscapes: true,
+        tags: "ams",
+        useLabelIds: true,
+        macros: {
+          bm: "\\boldsymbol"
+        },
+        packages: { "[+]": ["noerrors", "extpfeil"] }
+      },
+      options: {
+        processHtmlClass: "math",
+        ignoreHtmlClass: "tex2jax_ignore"
+      },
+      loader: {
+        load: ["[tex]/noerrors", "[tex]/extpfeil"]
+      },
+      startup: {
+        typeset: false
+      }
+    };
+    this._config = this._defaultConfig;
+  }
+  config(value) {
+    this._config = Object.assign({}, this._defaultConfig, value);
+    return this;
+  }
+  render(container, callback) {
+    if (!this._config.isEnabled)
+      return Promise.resolve();
+    return this.init().then((mathjax) => {
+      mathjax ? mathjax.startup.promise = mathjax.startup.promise.then(
+        () => mathjax.typesetPromise([container]).then(() => {
+          var _a;
+          try {
+            (_a = this._config.onRendered) == null ? void 0 : _a.call(void 0, mathjax);
+          } catch (e) {
+            console.error(e);
+          }
+          try {
+            callback == null ? void 0 : callback.call(void 0);
+          } catch (e) {
+            console.error(e);
+          }
+        })
+      ) : void 0;
+    }).catch(console.warn);
+  }
+  init() {
+    var _a;
+    return ((_a = this._initTask) != null ? _a : this._initTask = new Promise((resolve, reject) => {
+      var _a2, _b;
+      const { entryScript, tapMathJaxConfig, document: _document } = this._config;
+      const _window = (_a2 = _document.defaultView) != null ? _a2 : window;
+      _window.MathJax = (_b = tapMathJaxConfig == null ? void 0 : tapMathJaxConfig.call(void 0, __spreadValues({}, this._defaultMathJaxConfig))) != null ? _b : __spreadValues({}, this._defaultMathJaxConfig);
+      if (!_window.MathJax.startup) {
+        _window.MathJax.startup = {};
+      }
+      _window.MathJax.startup.ready = () => {
+        var _a3, _b2;
+        (_b2 = (_a3 = _window.MathJax) == null ? void 0 : _a3.startup) == null ? void 0 : _b2.defaultReady();
+        resolve(_window.MathJax);
+      };
+      loadScript({
+        src: entryScript,
+        id: "mathjax",
+        executionStrategy: "defer",
+        appendTo: _window.document.head
+      }).catch(reject);
+    })).catch(() => this._initTask = void 0);
+  }
+};
+
+// src/math/factory.ts
+var createMathJaxRenderer = (rendererConfig) => {
+  switch (rendererConfig.engine) {
+    case 0 /* MathJax2 */:
+      return new Mathjax2Renderer().config(rendererConfig);
+    case 1 /* MathJax3 */:
+      return new MathJax3Renderer().config(rendererConfig);
+    default:
+      throw Error("Renderer unavailable");
+  }
+};
+export {
+  highlightCodeLines as HighlightCodeLinesPlugin,
+  MarkdownIt,
+  MathEngine,
+  MultilineBlockquotePlugin,
+  MultilineBlockquoteRule,
+  anchorOption,
+  createMathJaxRenderer,
+  defaultLinkifyOptions,
+  defaultMarkdownItOption,
+  defaultTaskListsOption,
+  markdownItFactory
+};