@mxmweb/rtext 1.6.12 → 1.6.14

package/prism-markdown-tjNeCMi3.js

@@ -0,0 +1,300 @@
+(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);

package/prism-markup-BNGj0Tvm.js

@@ -0,0 +1,173 @@
+Prism.languages.markup = {
+  comment: {
+    pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+    greedy: !0
+  },
+  prolog: {
+    pattern: /<\?[\s\S]+?\?>/,
+    greedy: !0
+  },
+  doctype: {
+    // https://www.w3.org/TR/xml/#NT-doctypedecl
+    pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+    greedy: !0,
+    inside: {
+      "internal-subset": {
+        pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: null
+        // see below
+      },
+      string: {
+        pattern: /"[^"]*"|'[^']*'/,
+        greedy: !0
+      },
+      punctuation: /^<!|>$|[[\]]/,
+      "doctype-tag": /^DOCTYPE/i,
+      name: /[^\s<>'"]+/
+    }
+  },
+  cdata: {
+    pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+    greedy: !0
+  },
+  tag: {
+    pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+    greedy: !0,
+    inside: {
+      tag: {
+        pattern: /^<\/?[^\s>\/]+/,
+        inside: {
+          punctuation: /^<\/?/,
+          namespace: /^[^\s>\/:]+:/
+        }
+      },
+      "special-attr": [],
+      "attr-value": {
+        pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+        inside: {
+          punctuation: [
+            {
+              pattern: /^=/,
+              alias: "attr-equals"
+            },
+            {
+              pattern: /^(\s*)["']|["']$/,
+              lookbehind: !0
+            }
+          ]
+        }
+      },
+      punctuation: /\/?>/,
+      "attr-name": {
+        pattern: /[^\s>\/]+/,
+        inside: {
+          namespace: /^[^\s>\/:]+:/
+        }
+      }
+    }
+  },
+  entity: [
+    {
+      pattern: /&[\da-z]{1,8};/i,
+      alias: "named-entity"
+    },
+    /&#x?[\da-f]{1,8};/i
+  ]
+};
+Prism.languages.markup.tag.inside["attr-value"].inside.entity = Prism.languages.markup.entity;
+Prism.languages.markup.doctype.inside["internal-subset"].inside = Prism.languages.markup;
+Prism.hooks.add("wrap", function(e) {
+  e.type === "entity" && (e.attributes.title = e.content.replace(/&amp;/, "&"));
+});
+Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
+  /**
+   * Adds an inlined language to markup.
+   *
+   * An example of an inlined language is CSS with `<style>` tags.
+   *
+   * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+   * case insensitive.
+   * @param {string} lang The language key.
+   * @example
+   * addInlined('style', 'css');
+   */
+  value: function(a, t) {
+    var s = {};
+    s["language-" + t] = {
+      pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+      lookbehind: !0,
+      inside: Prism.languages[t]
+    }, s.cdata = /^<!\[CDATA\[|\]\]>$/i;
+    var n = {
+      "included-cdata": {
+        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+        inside: s
+      }
+    };
+    n["language-" + t] = {
+      pattern: /[\s\S]+/,
+      inside: Prism.languages[t]
+    };
+    var i = {};
+    i[a] = {
+      pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
+        return a;
+      }), "i"),
+      lookbehind: !0,
+      greedy: !0,
+      inside: n
+    }, Prism.languages.insertBefore("markup", "cdata", i);
+  }
+});
+Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
+  /**
+   * Adds an pattern to highlight languages embedded in HTML attributes.
+   *
+   * An example of an inlined language is CSS with `style` attributes.
+   *
+   * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+   * case insensitive.
+   * @param {string} lang The language key.
+   * @example
+   * addAttribute('style', 'css');
+   */
+  value: function(e, a) {
+    Prism.languages.markup.tag.inside["special-attr"].push({
+      pattern: RegExp(
+        /(^|["'\s])/.source + "(?:" + e + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+        "i"
+      ),
+      lookbehind: !0,
+      inside: {
+        "attr-name": /^[^\s=]+/,
+        "attr-value": {
+          pattern: /=[\s\S]+/,
+          inside: {
+            value: {
+              pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+              lookbehind: !0,
+              alias: [a, "language-" + a],
+              inside: Prism.languages[a]
+            },
+            punctuation: [
+              {
+                pattern: /^=/,
+                alias: "attr-equals"
+              },
+              /"|'/
+            ]
+          }
+        }
+      }
+    });
+  }
+});
+Prism.languages.html = Prism.languages.markup;
+Prism.languages.mathml = Prism.languages.markup;
+Prism.languages.svg = Prism.languages.markup;
+Prism.languages.xml = Prism.languages.extend("markup", {});
+Prism.languages.ssml = Prism.languages.xml;
+Prism.languages.atom = Prism.languages.xml;
+Prism.languages.rss = Prism.languages.xml;