@mxmweb/rtext 1.6.12 → 1.6.13

package/prism-java-DUOgyYJG.js

@@ -0,0 +1,142 @@
+import { g as u } from "./lib_enter-Dc5XyCCf.js";
+function p(t, a) {
+  for (var r = 0; r < a.length; r++) {
+    const e = a[r];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const s in e)
+        if (s !== "default" && !(s in t)) {
+          const n = Object.getOwnPropertyDescriptor(e, s);
+          n && Object.defineProperty(t, s, n.get ? n : {
+            enumerable: !0,
+            get: () => e[s]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var o = {}, i;
+function d() {
+  return i || (i = 1, (function(t) {
+    var a = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/, r = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source, e = {
+      pattern: RegExp(/(^|[^\w.])/.source + r + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+      lookbehind: !0,
+      inside: {
+        namespace: {
+          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        punctuation: /\./
+      }
+    };
+    t.languages.java = t.languages.extend("clike", {
+      string: {
+        pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      "class-name": [
+        e,
+        {
+          // variables, parameters, and constructor references
+          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+          pattern: RegExp(/(^|[^\w.])/.source + r + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source),
+          lookbehind: !0,
+          inside: e.inside
+        },
+        {
+          // class names based on keyword
+          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+          pattern: RegExp(/(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/.source + r + /[A-Z]\w*\b/.source),
+          lookbehind: !0,
+          inside: e.inside
+        }
+      ],
+      keyword: a,
+      function: [
+        t.languages.clike.function,
+        {
+          pattern: /(::\s*)[a-z_]\w*/,
+          lookbehind: !0
+        }
+      ],
+      number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+      operator: {
+        pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
+        lookbehind: !0
+      },
+      constant: /\b[A-Z][A-Z_\d]+\b/
+    }), t.languages.insertBefore("java", "string", {
+      "triple-quoted-string": {
+        // http://openjdk.java.net/jeps/355#Description
+        pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+        greedy: !0,
+        alias: "string"
+      },
+      char: {
+        pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
+        greedy: !0
+      }
+    }), t.languages.insertBefore("java", "class-name", {
+      annotation: {
+        pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+        lookbehind: !0,
+        alias: "punctuation"
+      },
+      generics: {
+        pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+        inside: {
+          "class-name": e,
+          keyword: a,
+          punctuation: /[<>(),.:]/,
+          operator: /[?&|]/
+        }
+      },
+      import: [
+        {
+          pattern: RegExp(/(\bimport\s+)/.source + r + /(?:[A-Z]\w*|\*)(?=\s*;)/.source),
+          lookbehind: !0,
+          inside: {
+            namespace: e.inside.namespace,
+            punctuation: /\./,
+            operator: /\*/,
+            "class-name": /\w+/
+          }
+        },
+        {
+          pattern: RegExp(/(\bimport\s+static\s+)/.source + r + /(?:\w+|\*)(?=\s*;)/.source),
+          lookbehind: !0,
+          alias: "static",
+          inside: {
+            namespace: e.inside.namespace,
+            static: /\b\w+$/,
+            punctuation: /\./,
+            operator: /\*/,
+            "class-name": /\w+/
+          }
+        }
+      ],
+      namespace: {
+        pattern: RegExp(
+          /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(/<keyword>/g, function() {
+            return a.source;
+          })
+        ),
+        lookbehind: !0,
+        inside: {
+          punctuation: /\./
+        }
+      }
+    });
+  })(Prism)), o;
+}
+var c = d();
+const l = /* @__PURE__ */ u(c), w = /* @__PURE__ */ p({
+  __proto__: null,
+  default: l
+}, [c]);
+export {
+  w as p
+};

package/prism-javascript-CLux6jF8.js

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,51 @@
+(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

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