@mxmweb/rtext 1.6.14 → 1.6.16

package/prism-javascript-CLux6jF8.js

@@ -1,137 +0,0 @@
-Prism.languages.javascript = Prism.languages.extend("clike", {
-  "class-name": [
-    Prism.languages.clike["class-name"],
-    {
-      pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
-      lookbehind: !0
-    }
-  ],
-  keyword: [
-    {
-      pattern: /((?:^|\})\s*)catch\b/,
-      lookbehind: !0
-    },
-    {
-      pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
-      lookbehind: !0
-    }
-  ],
-  // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
-  function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
-  number: {
-    pattern: RegExp(
-      /(^|[^\w$])/.source + "(?:" + // constant
-      (/NaN|Infinity/.source + "|" + // binary integer
-      /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
-      /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
-      /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
-      /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
-      /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
-    ),
-    lookbehind: !0
-  },
-  operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
-});
-Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
-Prism.languages.insertBefore("javascript", "keyword", {
-  regex: {
-    pattern: RegExp(
-      // lookbehind
-      // eslint-disable-next-line regexp/no-dupe-characters-character-class
-      /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern:
-      // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
-      // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
-      // with the only syntax, so we have to define 2 different regex patterns.
-      /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + // `v` flag syntax. This supports 3 levels of nested character classes.
-      /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + // lookahead
-      /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
-    ),
-    lookbehind: !0,
-    greedy: !0,
-    inside: {
-      "regex-source": {
-        pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
-        lookbehind: !0,
-        alias: "language-regex",
-        inside: Prism.languages.regex
-      },
-      "regex-delimiter": /^\/|\/$/,
-      "regex-flags": /^[a-z]+$/
-    }
-  },
-  // This must be declared before keyword because we use "function" inside the look-forward
-  "function-variable": {
-    pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
-    alias: "function"
-  },
-  parameter: [
-    {
-      pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    }
-  ],
-  constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
-});
-Prism.languages.insertBefore("javascript", "string", {
-  hashbang: {
-    pattern: /^#!.*/,
-    greedy: !0,
-    alias: "comment"
-  },
-  "template-string": {
-    pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
-    greedy: !0,
-    inside: {
-      "template-punctuation": {
-        pattern: /^`|`$/,
-        alias: "string"
-      },
-      interpolation: {
-        pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-        lookbehind: !0,
-        inside: {
-          "interpolation-punctuation": {
-            pattern: /^\$\{|\}$/,
-            alias: "punctuation"
-          },
-          rest: Prism.languages.javascript
-        }
-      },
-      string: /[\s\S]+/
-    }
-  },
-  "string-property": {
-    pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
-    lookbehind: !0,
-    greedy: !0,
-    alias: "property"
-  }
-});
-Prism.languages.insertBefore("javascript", "operator", {
-  "literal-property": {
-    pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
-    lookbehind: !0,
-    alias: "property"
-  }
-});
-Prism.languages.markup && (Prism.languages.markup.tag.addInlined("script", "javascript"), Prism.languages.markup.tag.addAttribute(
-  /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
-  "javascript"
-));
-Prism.languages.js = Prism.languages.javascript;

package/prism-json-iVb7He6L.js

@@ -1,25 +0,0 @@
-Prism.languages.json = {
-  property: {
-    pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
-    lookbehind: !0,
-    greedy: !0
-  },
-  string: {
-    pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
-    lookbehind: !0,
-    greedy: !0
-  },
-  comment: {
-    pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
-    greedy: !0
-  },
-  number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
-  punctuation: /[{}[\],]/,
-  operator: /:/,
-  boolean: /\b(?:false|true)\b/,
-  null: {
-    pattern: /\bnull\b/,
-    alias: "keyword"
-  }
-};
-Prism.languages.webmanifest = Prism.languages.json;

package/prism-jsx-yfun9EDN.js

@@ -1,51 +0,0 @@
-(function(a) {
-  var l = a.util.clone(a.languages.javascript), f = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, o = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, u = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
-  function c(e, t) {
-    return e = e.replace(/<S>/g, function() {
-      return f;
-    }).replace(/<BRACES>/g, function() {
-      return o;
-    }).replace(/<SPREAD>/g, function() {
-      return u;
-    }), RegExp(e, t);
-  }
-  u = c(u).source, a.languages.jsx = a.languages.extend("markup", l), a.languages.jsx.tag.pattern = c(
-    /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
-  ), a.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, a.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, a.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, a.languages.jsx.tag.inside.comment = l.comment, a.languages.insertBefore("inside", "attr-name", {
-    spread: {
-      pattern: c(/<SPREAD>/.source),
-      inside: a.languages.jsx
-    }
-  }, a.languages.jsx.tag), a.languages.insertBefore("inside", "special-attr", {
-    script: {
-      // Allow for two levels of nesting
-      pattern: c(/=<BRACES>/.source),
-      alias: "language-javascript",
-      inside: {
-        "script-punctuation": {
-          pattern: /^=(?=\{)/,
-          alias: "punctuation"
-        },
-        rest: a.languages.jsx
-      }
-    }
-  }, a.languages.jsx.tag);
-  var s = function(e) {
-    return e ? typeof e == "string" ? e : typeof e.content == "string" ? e.content : e.content.map(s).join("") : "";
-  }, p = function(e) {
-    for (var t = [], g = 0; g < e.length; g++) {
-      var n = e[g], i = !1;
-      if (typeof n != "string" && (n.type === "tag" && n.content[0] && n.content[0].type === "tag" ? n.content[0].content[0].content === "</" ? t.length > 0 && t[t.length - 1].tagName === s(n.content[0].content[1]) && t.pop() : n.content[n.content.length - 1].content === "/>" || t.push({
-        tagName: s(n.content[0].content[1]),
-        openedBraces: 0
-      }) : t.length > 0 && n.type === "punctuation" && n.content === "{" ? t[t.length - 1].openedBraces++ : t.length > 0 && t[t.length - 1].openedBraces > 0 && n.type === "punctuation" && n.content === "}" ? t[t.length - 1].openedBraces-- : i = !0), (i || typeof n == "string") && t.length > 0 && t[t.length - 1].openedBraces === 0) {
-        var r = s(n);
-        g < e.length - 1 && (typeof e[g + 1] == "string" || e[g + 1].type === "plain-text") && (r += s(e[g + 1]), e.splice(g + 1, 1)), g > 0 && (typeof e[g - 1] == "string" || e[g - 1].type === "plain-text") && (r = s(e[g - 1]) + r, e.splice(g - 1, 1), g--), e[g] = new a.Token("plain-text", r, null, r);
-      }
-      n.content && typeof n.content != "string" && p(n.content);
-    }
-  };
-  a.hooks.add("after-tokenize", function(e) {
-    e.language !== "jsx" && e.language !== "tsx" || p(e.tokens);
-  });
-})(Prism);

package/prism-kotlin-QHMLy1lI.js

@@ -1,75 +0,0 @@
-(function(e) {
-  e.languages.kotlin = e.languages.extend("clike", {
-    keyword: {
-      // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
-      pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
-      lookbehind: !0
-    },
-    function: [
-      {
-        pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
-        greedy: !0
-      },
-      {
-        pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
-        lookbehind: !0,
-        greedy: !0
-      }
-    ],
-    number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
-    operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
-  }), delete e.languages.kotlin["class-name"];
-  var n = {
-    "interpolation-punctuation": {
-      pattern: /^\$\{?|\}$/,
-      alias: "punctuation"
-    },
-    expression: {
-      pattern: /[\s\S]+/,
-      inside: e.languages.kotlin
-    }
-  };
-  e.languages.insertBefore("kotlin", "string", {
-    // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
-    "string-literal": [
-      {
-        pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
-        alias: "multiline",
-        inside: {
-          interpolation: {
-            pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
-            inside: n
-          },
-          string: /[\s\S]+/
-        }
-      },
-      {
-        pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
-        alias: "singleline",
-        inside: {
-          interpolation: {
-            pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
-            lookbehind: !0,
-            inside: n
-          },
-          string: /[\s\S]+/
-        }
-      }
-    ],
-    char: {
-      // https://kotlinlang.org/spec/expressions.html#character-literals
-      pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
-      greedy: !0
-    }
-  }), delete e.languages.kotlin.string, e.languages.insertBefore("kotlin", "keyword", {
-    annotation: {
-      pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
-      alias: "builtin"
-    }
-  }), e.languages.insertBefore("kotlin", "function", {
-    label: {
-      pattern: /\b\w+@|@\w+\b/,
-      alias: "symbol"
-    }
-  }), e.languages.kt = e.languages.kotlin, e.languages.kts = e.languages.kotlin;
-})(Prism);

package/prism-markdown-tjNeCMi3.js

@@ -1,300 +0,0 @@
-(function(e) {
-  var f = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
-  function d(n) {
-    return n = n.replace(/<inner>/g, function() {
-      return f;
-    }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + n + ")");
-  }
-  var g = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, p = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
-    return g;
-  }), c = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
-  e.languages.markdown = e.languages.extend("markup", {}), e.languages.insertBefore("markdown", "prolog", {
-    "front-matter-block": {
-      pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        punctuation: /^---|---$/,
-        "front-matter": {
-          pattern: /\S+(?:\s+\S+)*/,
-          alias: ["yaml", "language-yaml"],
-          inside: e.languages.yaml
-        }
-      }
-    },
-    blockquote: {
-      // > ...
-      pattern: /^>(?:[\t ]*>)*/m,
-      alias: "punctuation"
-    },
-    table: {
-      pattern: RegExp("^" + p + c + "(?:" + p + ")*", "m"),
-      inside: {
-        "table-data-rows": {
-          pattern: RegExp("^(" + p + c + ")(?:" + p + ")*$"),
-          lookbehind: !0,
-          inside: {
-            "table-data": {
-              pattern: RegExp(g),
-              inside: e.languages.markdown
-            },
-            punctuation: /\|/
-          }
-        },
-        "table-line": {
-          pattern: RegExp("^(" + p + ")" + c + "$"),
-          lookbehind: !0,
-          inside: {
-            punctuation: /\||:?-{3,}:?/
-          }
-        },
-        "table-header-row": {
-          pattern: RegExp("^" + p + "$"),
-          inside: {
-            "table-header": {
-              pattern: RegExp(g),
-              alias: "important",
-              inside: e.languages.markdown
-            },
-            punctuation: /\|/
-          }
-        }
-      }
-    },
-    code: [
-      {
-        // Prefixed by 4 spaces or 1 tab and preceded by an empty line
-        pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
-        lookbehind: !0,
-        alias: "keyword"
-      },
-      {
-        // ```optional language
-        // code block
-        // ```
-        pattern: /^```[\s\S]*?^```$/m,
-        greedy: !0,
-        inside: {
-          "code-block": {
-            pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
-            lookbehind: !0
-          },
-          "code-language": {
-            pattern: /^(```).+/,
-            lookbehind: !0
-          },
-          punctuation: /```/
-        }
-      }
-    ],
-    title: [
-      {
-        // title 1
-        // =======
-        // title 2
-        // -------
-        pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
-        alias: "important",
-        inside: {
-          punctuation: /==+$|--+$/
-        }
-      },
-      {
-        // # title 1
-        // ###### title 6
-        pattern: /(^\s*)#.+/m,
-        lookbehind: !0,
-        alias: "important",
-        inside: {
-          punctuation: /^#+|#+$/
-        }
-      }
-    ],
-    hr: {
-      // ***
-      // ---
-      // * * *
-      // -----------
-      pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
-      lookbehind: !0,
-      alias: "punctuation"
-    },
-    list: {
-      // * item
-      // + item
-      // - item
-      // 1. item
-      pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
-      lookbehind: !0,
-      alias: "punctuation"
-    },
-    "url-reference": {
-      // [id]: http://example.com "Optional title"
-      // [id]: http://example.com 'Optional title'
-      // [id]: http://example.com (Optional title)
-      // [id]: <http://example.com> "Optional title"
-      pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
-      inside: {
-        variable: {
-          pattern: /^(!?\[)[^\]]+/,
-          lookbehind: !0
-        },
-        string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
-        punctuation: /^[\[\]!:]|[<>]/
-      },
-      alias: "url"
-    },
-    bold: {
-      // **strong**
-      // __strong__
-      // allow one nested instance of italic text using the same delimiter
-      pattern: d(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        content: {
-          pattern: /(^..)[\s\S]+(?=..$)/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        punctuation: /\*\*|__/
-      }
-    },
-    italic: {
-      // *em*
-      // _em_
-      // allow one nested instance of bold text using the same delimiter
-      pattern: d(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        content: {
-          pattern: /(^.)[\s\S]+(?=.$)/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        punctuation: /[*_]/
-      }
-    },
-    strike: {
-      // ~~strike through~~
-      // ~strike~
-      // eslint-disable-next-line regexp/strict
-      pattern: d(/(~~?)(?:(?!~)<inner>)+\2/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        content: {
-          pattern: /(^~~?)[\s\S]+(?=\1$)/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        punctuation: /~~?/
-      }
-    },
-    "code-snippet": {
-      // `code`
-      // ``code``
-      pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
-      lookbehind: !0,
-      greedy: !0,
-      alias: ["code", "keyword"]
-    },
-    url: {
-      // [example](http://example.com "Optional title")
-      // [example][id]
-      // [example] [id]
-      pattern: d(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source),
-      lookbehind: !0,
-      greedy: !0,
-      inside: {
-        operator: /^!/,
-        content: {
-          pattern: /(^\[)[^\]]+(?=\])/,
-          lookbehind: !0,
-          inside: {}
-          // see below
-        },
-        variable: {
-          pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
-          lookbehind: !0
-        },
-        url: {
-          pattern: /(^\]\()[^\s)]+/,
-          lookbehind: !0
-        },
-        string: {
-          pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
-          lookbehind: !0
-        }
-      }
-    }
-  }), ["url", "bold", "italic", "strike"].forEach(function(n) {
-    ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(t) {
-      n !== t && (e.languages.markdown[n].inside.content.inside[t] = e.languages.markdown[t]);
-    });
-  }), e.hooks.add("after-tokenize", function(n) {
-    if (n.language !== "markdown" && n.language !== "md")
-      return;
-    function t(i) {
-      if (!(!i || typeof i == "string"))
-        for (var r = 0, u = i.length; r < u; r++) {
-          var o = i[r];
-          if (o.type !== "code") {
-            t(o.content);
-            continue;
-          }
-          var l = o.content[1], a = o.content[3];
-          if (l && a && l.type === "code-language" && a.type === "code-block" && typeof l.content == "string") {
-            var s = l.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
-            s = (/[a-z][\w-]*/i.exec(s) || [""])[0].toLowerCase();
-            var b = "language-" + s;
-            a.alias ? typeof a.alias == "string" ? a.alias = [a.alias, b] : a.alias.push(b) : a.alias = [b];
-          }
-        }
-    }
-    t(n.tokens);
-  }), e.hooks.add("wrap", function(n) {
-    if (n.type === "code-block") {
-      for (var t = "", i = 0, r = n.classes.length; i < r; i++) {
-        var u = n.classes[i], o = /language-(.+)/.exec(u);
-        if (o) {
-          t = o[1];
-          break;
-        }
-      }
-      var l = e.languages[t];
-      if (l)
-        n.content = e.highlight(m(n.content), l, t);
-      else if (t && t !== "none" && e.plugins.autoloader) {
-        var a = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
-        n.attributes.id = a, e.plugins.autoloader.loadLanguages(t, function() {
-          var s = document.getElementById(a);
-          s && (s.innerHTML = e.highlight(s.textContent, e.languages[t], t));
-        });
-      }
-    }
-  });
-  var h = RegExp(e.languages.markup.tag.pattern.source, "gi"), k = {
-    amp: "&",
-    lt: "<",
-    gt: ">",
-    quot: '"'
-  }, _ = String.fromCodePoint || String.fromCharCode;
-  function m(n) {
-    var t = n.replace(h, "");
-    return t = t.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(i, r) {
-      if (r = r.toLowerCase(), r[0] === "#") {
-        var u;
-        return r[1] === "x" ? u = parseInt(r.slice(2), 16) : u = Number(r.slice(1)), _(u);
-      } else {
-        var o = k[r];
-        return o || i;
-      }
-    }), t;
-  }
-  e.languages.md = e.languages.markdown;
-})(Prism);