@cnblogs/markdown-it-presets 1.9.4 → 1.9.6

package/dist/commonjs/presets/index.cjs

@@ -1,127 +1,726 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HighlightCodeLinesPlugin = exports.MarkdownIt = exports.markdownItFactory = exports.MultilineBlockquoteRule = exports.MultilineBlockquotePlugin = void 0;
-const markdown_it_1 = __importDefault(require("markdown-it"));
-exports.MarkdownIt = markdown_it_1.default;
-const highlight_js_1 = __importDefault(require("highlight.js"));
-const markdown_it_container_1 = __importDefault(require("markdown-it-container"));
-const markdown_it_abbr_1 = __importDefault(require("markdown-it-abbr"));
-const markdown_it_deflist_1 = __importDefault(require("markdown-it-deflist"));
-const markdown_it_emoji_1 = __importDefault(require("markdown-it-emoji"));
-const markdown_it_footnote_1 = __importDefault(require("markdown-it-footnote"));
-const markdown_it_mark_1 = __importDefault(require("markdown-it-mark"));
-const markdown_it_sub_1 = __importDefault(require("markdown-it-sub"));
-const markdown_it_sup_1 = __importDefault(require("markdown-it-sup"));
-const markdown_it_anchor_1 = __importDefault(require("markdown-it-anchor"));
-const markdown_it_lazy_headers_1 = __importDefault(require("markdown-it-lazy-headers"));
-const markdown_it_for_inline_1 = __importDefault(require("markdown-it-for-inline"));
-const markdown_it_task_lists_1 = __importDefault(require("markdown-it-task-lists"));
-const markdown_it_attrs_1 = __importDefault(require("markdown-it-attrs"));
-const simple_math_plugin_1 = require("./plugins/simple-math.plugin");
-const simple_mermaid_plugin_1 = require("./plugins/simple-mermaid.plugin");
-const html_filter_plugin_1 = require("./plugins/html-filter.plugin");
-const multiline_blockquote_plugin_1 = require("./plugins/multiline-blockquote/multiline-blockquote.plugin");
-Object.defineProperty(exports, "MultilineBlockquotePlugin", { enumerable: true, get: function () { return multiline_blockquote_plugin_1.MultilineBlockquotePlugin; } });
-Object.defineProperty(exports, "MultilineBlockquoteRule", { enumerable: true, get: function () { return multiline_blockquote_plugin_1.MultilineBlockquoteRule; } });
-const option_1 = require("./option");
-const toc_1 = require("./plugins/toc");
-const highlight_code_lines_plugin_1 = require("./plugins/highlight-code-lines.plugin");
-Object.defineProperty(exports, "HighlightCodeLinesPlugin", { enumerable: true, get: function () { return highlight_code_lines_plugin_1.HighlightCodeLinesPlugin; } });
-const meta_1 = require("./plugins/meta");
-const unique_custom_id_1 = require("./plugins/unique-custom-id");
-const mdUtils = new markdown_it_1.default().utils;
-const defaultCodeHighlight = (str, lang) => {
-    if (lang && highlight_js_1.default.getLanguage(lang)) {
-        try {
-            const result = highlight_js_1.default.highlight(lang, str, true);
-            return `<pre class="hljs"><code data-lang="${result.language}">${result.value}</code></pre>`;
-        }
-        catch (_a) { }
-    }
-    return `<pre class="hljs"><code>${mdUtils.escapeHtml(str)}</code></pre>`;
-};
-const addLinkAttributes = [
-    markdown_it_for_inline_1.default,
-    '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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/presets/index.ts
+var presets_exports = {};
+__export(presets_exports, {
+  HighlightCodeLinesPlugin: () => highlightCodeLines,
+  MarkdownIt: () => import_markdown_it.default,
+  MultilineBlockquotePlugin: () => MultilineBlockquotePlugin,
+  MultilineBlockquoteRule: () => MultilineBlockquoteRule,
+  anchorOption: () => anchorOption,
+  defaultLinkifyOptions: () => defaultLinkifyOptions,
+  defaultMarkdownItOption: () => defaultMarkdownItOption,
+  defaultTaskListsOption: () => defaultTaskListsOption,
+  markdownItFactory: () => markdownItFactory
+});
+module.exports = __toCommonJS(presets_exports);
+var import_markdown_it = __toESM(require("markdown-it"), 1);
+var import_highlight = __toESM(require("highlight.js"), 1);
+var import_markdown_it_container = __toESM(require("markdown-it-container"), 1);
+var import_markdown_it_abbr = __toESM(require("markdown-it-abbr"), 1);
+var import_markdown_it_deflist = __toESM(require("markdown-it-deflist"), 1);
+var import_markdown_it_emoji = __toESM(require("markdown-it-emoji"), 1);
+var import_markdown_it_footnote = __toESM(require("markdown-it-footnote"), 1);
+var import_markdown_it_mark = __toESM(require("markdown-it-mark"), 1);
+var import_markdown_it_sub = __toESM(require("markdown-it-sub"), 1);
+var import_markdown_it_sup = __toESM(require("markdown-it-sup"), 1);
+var import_markdown_it_anchor = __toESM(require("markdown-it-anchor"), 1);
+var import_markdown_it_lazy_headers = __toESM(require("markdown-it-lazy-headers"), 1);
+var import_markdown_it_for_inline = __toESM(require("markdown-it-for-inline"), 1);
+var import_markdown_it_task_lists = __toESM(require("markdown-it-task-lists"), 1);
+var import_markdown_it_attrs = __toESM(require("markdown-it-attrs"), 1);
+
+// 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
+var import_github_slugger = __toESM(require("github-slugger"), 1);
+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 import_github_slugger.default().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 import_markdown_it.default().utils;
+var defaultCodeHighlight = (str, lang) => {
+  if (lang && import_highlight.default.getLanguage(lang)) {
+    try {
+      const result = import_highlight.default.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 = [
+  import_markdown_it_for_inline.default,
+  "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"]);
+    }
+  }
 ];
-const markdownItFactory = ({ html, codeHighlight, taskListsOption, math, disableRules, linkify: linkifyOption, } = option_1.defaultMarkdownItOption) => {
-    const mdOpt = {
-        html: html,
-        breaks: true,
-        linkify: true,
+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 import_markdown_it.default(mdOpt).use(import_markdown_it_container.default).use(diagramPlugin).use(import_markdown_it_attrs.default, { allowedAttributes: ["id", "class", LineNumberAttrRegex], disableParagraphBlock: true }).use(import_markdown_it_anchor.default, anchorOption).use(plugin2).use(plugin).use(import_markdown_it_abbr.default).use(import_markdown_it_deflist.default).use(import_markdown_it_emoji.default).use(import_markdown_it_footnote.default).use(import_markdown_it_mark.default).use(import_markdown_it_sub.default).use(import_markdown_it_sup.default).use(highlightCodeLines).use(import_markdown_it_lazy_headers.default).use(import_markdown_it_task_lists.default, 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);
     };
-    taskListsOption !== null && taskListsOption !== void 0 ? taskListsOption : (taskListsOption = option_1.defaultTaskListsOption);
-    linkifyOption = Object.assign({}, option_1.defaultLinkifyOptions, linkifyOption !== null && linkifyOption !== void 0 ? linkifyOption : option_1.defaultLinkifyOptions);
-    if (codeHighlight) {
-        mdOpt.highlight = defaultCodeHighlight;
-    }
-    const md = new markdown_it_1.default(mdOpt)
-        .use(markdown_it_container_1.default)
-        .use(simple_mermaid_plugin_1.diagramPlugin)
-        .use(markdown_it_attrs_1.default, { allowedAttributes: ['id', 'class', highlight_code_lines_plugin_1.LineNumberAttrRegex], disableParagraphBlock: true })
-        .use(markdown_it_anchor_1.default, option_1.anchorOption)
-        .use(unique_custom_id_1.UniqueCustomIdAttrs)
-        .use(toc_1.TocPlugin)
-        .use(markdown_it_abbr_1.default)
-        .use(markdown_it_deflist_1.default)
-        .use(markdown_it_emoji_1.default)
-        .use(markdown_it_footnote_1.default)
-        .use(markdown_it_mark_1.default)
-        .use(markdown_it_sub_1.default)
-        .use(markdown_it_sup_1.default)
-        .use(highlight_code_lines_plugin_1.HighlightCodeLinesPlugin)
-        .use(markdown_it_lazy_headers_1.default)
-        .use(markdown_it_task_lists_1.default, taskListsOption)
-        .use(html_filter_plugin_1.HtmlFilterPlugin)
-        .use(...addLinkAttributes)
-        .use(multiline_blockquote_plugin_1.MultilineBlockquotePlugin);
-    md.block.ruler.before('hr', 'meta', meta_1.meta);
-    if (math) {
-        md.use(simple_math_plugin_1.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;
-};
-exports.markdownItFactory = markdownItFactory;
-__exportStar(require("./option"), exports);
-//# sourceMappingURL=index.js.map
+  }
+  return md;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HighlightCodeLinesPlugin,
+  MarkdownIt,
+  MultilineBlockquotePlugin,
+  MultilineBlockquoteRule,
+  anchorOption,
+  defaultLinkifyOptions,
+  defaultMarkdownItOption,
+  defaultTaskListsOption,
+  markdownItFactory
+});