@fangzhongya/vue-archive 0.0.2-7 → 0.0.2

package/dist/es/node_modules/.pnpm/highlight.js@11.7.0/node_modules/highlight.js/lib/languages/java.js

@@ -1,24 +1,28 @@
-var c, E;
-function C() {
-  if (E)
-    return c;
-  E = 1;
-  var n = "[0-9](_*[0-9])*", t = `\\.(${n})`, r = "[0-9a-fA-F](_*[0-9a-fA-F])*", o = {
+var java_1;
+var hasRequiredJava;
+function requireJava() {
+  if (hasRequiredJava)
+    return java_1;
+  hasRequiredJava = 1;
+  var decimalDigits = "[0-9](_*[0-9])*";
+  var frac = `\\.(${decimalDigits})`;
+  var hexDigits = "[0-9a-fA-F](_*[0-9a-fA-F])*";
+  var NUMERIC = {
     className: "number",
     variants: [
       // DecimalFloatingPointLiteral
       // including ExponentPart
-      { begin: `(\\b(${n})((${t})|\\.)?|(${t}))[eE][+-]?(${n})[fFdD]?\\b` },
+      { begin: `(\\b(${decimalDigits})((${frac})|\\.)?|(${frac}))[eE][+-]?(${decimalDigits})[fFdD]?\\b` },
       // excluding ExponentPart
-      { begin: `\\b(${n})((${t})[fFdD]?\\b|\\.([fFdD]\\b)?)` },
-      { begin: `(${t})[fFdD]?\\b` },
-      { begin: `\\b(${n})[fFdD]\\b` },
+      { begin: `\\b(${decimalDigits})((${frac})[fFdD]?\\b|\\.([fFdD]\\b)?)` },
+      { begin: `(${frac})[fFdD]?\\b` },
+      { begin: `\\b(${decimalDigits})[fFdD]\\b` },
       // HexadecimalFloatingPointLiteral
-      { begin: `\\b0[xX]((${r})\\.?|(${r})?\\.(${r}))[pP][+-]?(${n})[fFdD]?\\b` },
+      { begin: `\\b0[xX]((${hexDigits})\\.?|(${hexDigits})?\\.(${hexDigits}))[pP][+-]?(${decimalDigits})[fFdD]?\\b` },
       // DecimalIntegerLiteral
       { begin: "\\b(0|[1-9](_*[0-9])*)[lL]?\\b" },
       // HexIntegerLiteral
-      { begin: `\\b0[xX](${r})[lL]?\\b` },
+      { begin: `\\b0[xX](${hexDigits})[lL]?\\b` },
       // OctalIntegerLiteral
       { begin: "\\b0(_*[0-7])*[lL]?\\b" },
       // BinaryIntegerLiteral
@@ -26,77 +30,89 @@ function C() {
     ],
     relevance: 0
   };
-  function _(e, s, a) {
-    return a === -1 ? "" : e.replace(s, (b) => _(e, s, a - 1));
+  function recurRegex(re, substitution, depth) {
+    if (depth === -1)
+      return "";
+    return re.replace(substitution, (_) => {
+      return recurRegex(re, substitution, depth - 1);
+    });
   }
-  function N(e) {
-    const s = e.regex, a = "[À-ʸa-zA-Z_$][À-ʸa-zA-Z_$0-9]*", b = a + _("(?:<" + a + "~~~(?:\\s*,\\s*" + a + "~~~)*>)?", /~~~/g, 2), i = {
-      keyword: [
-        "synchronized",
-        "abstract",
-        "private",
-        "var",
-        "static",
-        "if",
-        "const ",
-        "for",
-        "while",
-        "strictfp",
-        "finally",
-        "protected",
-        "import",
-        "native",
-        "final",
-        "void",
-        "enum",
-        "else",
-        "break",
-        "transient",
-        "catch",
-        "instanceof",
-        "volatile",
-        "case",
-        "assert",
-        "package",
-        "default",
-        "public",
-        "try",
-        "switch",
-        "continue",
-        "throws",
-        "protected",
-        "public",
-        "private",
-        "module",
-        "requires",
-        "exports",
-        "do",
-        "sealed",
-        "yield",
-        "permits"
-      ],
-      literal: [
-        "false",
-        "true",
-        "null"
-      ],
-      type: [
-        "char",
-        "boolean",
-        "long",
-        "float",
-        "int",
-        "byte",
-        "short",
-        "double"
-      ],
-      built_in: [
-        "super",
-        "this"
-      ]
-    }, l = {
+  function java(hljs) {
+    const regex = hljs.regex;
+    const JAVA_IDENT_RE = "[À-ʸa-zA-Z_$][À-ʸa-zA-Z_$0-9]*";
+    const GENERIC_IDENT_RE = JAVA_IDENT_RE + recurRegex("(?:<" + JAVA_IDENT_RE + "~~~(?:\\s*,\\s*" + JAVA_IDENT_RE + "~~~)*>)?", /~~~/g, 2);
+    const MAIN_KEYWORDS = [
+      "synchronized",
+      "abstract",
+      "private",
+      "var",
+      "static",
+      "if",
+      "const ",
+      "for",
+      "while",
+      "strictfp",
+      "finally",
+      "protected",
+      "import",
+      "native",
+      "final",
+      "void",
+      "enum",
+      "else",
+      "break",
+      "transient",
+      "catch",
+      "instanceof",
+      "volatile",
+      "case",
+      "assert",
+      "package",
+      "default",
+      "public",
+      "try",
+      "switch",
+      "continue",
+      "throws",
+      "protected",
+      "public",
+      "private",
+      "module",
+      "requires",
+      "exports",
+      "do",
+      "sealed",
+      "yield",
+      "permits"
+    ];
+    const BUILT_INS = [
+      "super",
+      "this"
+    ];
+    const LITERALS = [
+      "false",
+      "true",
+      "null"
+    ];
+    const TYPES = [
+      "char",
+      "boolean",
+      "long",
+      "float",
+      "int",
+      "byte",
+      "short",
+      "double"
+    ];
+    const KEYWORDS = {
+      keyword: MAIN_KEYWORDS,
+      literal: LITERALS,
+      type: TYPES,
+      built_in: BUILT_INS
+    };
+    const ANNOTATION = {
       className: "meta",
-      begin: "@" + a,
+      begin: "@" + JAVA_IDENT_RE,
       contains: [
         {
           begin: /\(/,
@@ -105,22 +121,23 @@ function C() {
           // allow nested () inside our annotation
         }
       ]
-    }, d = {
+    };
+    const PARAMS = {
       className: "params",
       begin: /\(/,
       end: /\)/,
-      keywords: i,
+      keywords: KEYWORDS,
       relevance: 0,
-      contains: [e.C_BLOCK_COMMENT_MODE],
-      endsParent: !0
+      contains: [hljs.C_BLOCK_COMMENT_MODE],
+      endsParent: true
     };
     return {
       name: "Java",
       aliases: ["jsp"],
-      keywords: i,
+      keywords: KEYWORDS,
       illegal: /<\/|#/,
       contains: [
-        e.COMMENT(
+        hljs.COMMENT(
           "/\\*\\*",
           "\\*/",
           {
@@ -144,21 +161,21 @@ function C() {
           keywords: "import",
           relevance: 2
         },
-        e.C_LINE_COMMENT_MODE,
-        e.C_BLOCK_COMMENT_MODE,
+        hljs.C_LINE_COMMENT_MODE,
+        hljs.C_BLOCK_COMMENT_MODE,
         {
           begin: /"""/,
           end: /"""/,
           className: "string",
-          contains: [e.BACKSLASH_ESCAPE]
+          contains: [hljs.BACKSLASH_ESCAPE]
         },
-        e.APOS_STRING_MODE,
-        e.QUOTE_STRING_MODE,
+        hljs.APOS_STRING_MODE,
+        hljs.QUOTE_STRING_MODE,
         {
           match: [
             /\b(?:class|interface|enum|extends|implements|new)/,
             /\s+/,
-            a
+            JAVA_IDENT_RE
           ],
           className: {
             1: "keyword",
@@ -172,9 +189,9 @@ function C() {
         },
         {
           begin: [
-            s.concat(/(?!else)/, a),
+            regex.concat(/(?!else)/, JAVA_IDENT_RE),
             /\s+/,
-            a,
+            JAVA_IDENT_RE,
             /\s+/,
             /=(?!=)/
           ],
@@ -188,16 +205,16 @@ function C() {
           begin: [
             /record/,
             /\s+/,
-            a
+            JAVA_IDENT_RE
           ],
           className: {
             1: "keyword",
             3: "title.class"
           },
           contains: [
-            d,
-            e.C_LINE_COMMENT_MODE,
-            e.C_BLOCK_COMMENT_MODE
+            PARAMS,
+            hljs.C_LINE_COMMENT_MODE,
+            hljs.C_BLOCK_COMMENT_MODE
           ]
         },
         {
@@ -208,38 +225,39 @@ function C() {
         },
         {
           begin: [
-            "(?:" + b + "\\s+)",
-            e.UNDERSCORE_IDENT_RE,
+            "(?:" + GENERIC_IDENT_RE + "\\s+)",
+            hljs.UNDERSCORE_IDENT_RE,
             /\s*(?=\()/
           ],
           className: { 2: "title.function" },
-          keywords: i,
+          keywords: KEYWORDS,
           contains: [
             {
               className: "params",
               begin: /\(/,
               end: /\)/,
-              keywords: i,
+              keywords: KEYWORDS,
               relevance: 0,
               contains: [
-                l,
-                e.APOS_STRING_MODE,
-                e.QUOTE_STRING_MODE,
-                o,
-                e.C_BLOCK_COMMENT_MODE
+                ANNOTATION,
+                hljs.APOS_STRING_MODE,
+                hljs.QUOTE_STRING_MODE,
+                NUMERIC,
+                hljs.C_BLOCK_COMMENT_MODE
               ]
             },
-            e.C_LINE_COMMENT_MODE,
-            e.C_BLOCK_COMMENT_MODE
+            hljs.C_LINE_COMMENT_MODE,
+            hljs.C_BLOCK_COMMENT_MODE
           ]
         },
-        o,
-        l
+        NUMERIC,
+        ANNOTATION
       ]
     };
   }
-  return c = N, c;
+  java_1 = java;
+  return java_1;
 }
 export {
-  C as __require
+  requireJava as __require
 };