@fangzhongya/vue-archive 0.0.2-8 → 0.0.2

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

@@ -1,19 +1,25 @@
-var I, v;
-function L() {
-  if (v)
-    return I;
-  v = 1;
-  function y(e) {
-    const t = e.regex, O = /(?![A-Za-z0-9])(?![$])/, n = t.concat(
+var php_1;
+var hasRequiredPhp;
+function requirePhp() {
+  if (hasRequiredPhp)
+    return php_1;
+  hasRequiredPhp = 1;
+  function php(hljs) {
+    const regex = hljs.regex;
+    const NOT_PERL_ETC = /(?![A-Za-z0-9])(?![$])/;
+    const IDENT_RE = regex.concat(
       /[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/,
-      O
-    ), a = t.concat(
+      NOT_PERL_ETC
+    );
+    const PASCAL_CASE_CLASS_NAME_RE = regex.concat(
       /(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,
-      O
-    ), l = {
+      NOT_PERL_ETC
+    );
+    const VARIABLE = {
       scope: "variable",
-      match: "\\$+" + n
-    }, N = {
+      match: "\\$+" + IDENT_RE
+    };
+    const PREPROCESSOR = {
       scope: "meta",
       variants: [
         { begin: /<\?php/, relevance: 10 },
@@ -24,7 +30,8 @@ function L() {
         { begin: /\?>/ }
         // end php tag
       ]
-    }, g = {
+    };
+    const SUBST = {
       scope: "subst",
       variants: [
         { begin: /\$\w+/ },
@@ -33,39 +40,46 @@ function L() {
           end: /\}/
         }
       ]
-    }, x = e.inherit(e.APOS_STRING_MODE, { illegal: null }), M = e.inherit(e.QUOTE_STRING_MODE, {
+    };
+    const SINGLE_QUOTED = hljs.inherit(hljs.APOS_STRING_MODE, { illegal: null });
+    const DOUBLE_QUOTED = hljs.inherit(hljs.QUOTE_STRING_MODE, {
       illegal: null,
-      contains: e.QUOTE_STRING_MODE.contains.concat(g)
-    }), h = e.END_SAME_AS_BEGIN({
+      contains: hljs.QUOTE_STRING_MODE.contains.concat(SUBST)
+    });
+    const HEREDOC = hljs.END_SAME_AS_BEGIN({
       begin: /<<<[ \t]*(\w+)\n/,
       end: /[ \t]*(\w+)\b/,
-      contains: e.QUOTE_STRING_MODE.contains.concat(g)
-    }), S = `[ 	
-]`, c = {
+      contains: hljs.QUOTE_STRING_MODE.contains.concat(SUBST)
+    });
+    const WHITESPACE = "[ 	\n]";
+    const STRING = {
       scope: "string",
       variants: [
-        M,
-        x,
-        h
+        DOUBLE_QUOTED,
+        SINGLE_QUOTED,
+        HEREDOC
       ]
-    }, i = {
+    };
+    const NUMBER = {
       scope: "number",
       variants: [
-        { begin: "\\b0[bB][01]+(?:_[01]+)*\\b" },
+        { begin: `\\b0[bB][01]+(?:_[01]+)*\\b` },
         // Binary w/ underscore support
-        { begin: "\\b0[oO][0-7]+(?:_[0-7]+)*\\b" },
+        { begin: `\\b0[oO][0-7]+(?:_[0-7]+)*\\b` },
         // Octals w/ underscore support
-        { begin: "\\b0[xX][\\da-fA-F]+(?:_[\\da-fA-F]+)*\\b" },
+        { begin: `\\b0[xX][\\da-fA-F]+(?:_[\\da-fA-F]+)*\\b` },
         // Hex w/ underscore support
         // Decimals w/ underscore support, with optional fragments and scientific exponent (e) suffix.
-        { begin: "(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?" }
+        { begin: `(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?` }
       ],
       relevance: 0
-    }, _ = [
+    };
+    const LITERALS = [
       "false",
       "null",
       "true"
-    ], T = [
+    ];
+    const KWS = [
       // Magic constants:
       // <https://www.php.net/manual/en/language.constants.predefined.php>
       "__CLASS__",
@@ -165,7 +179,8 @@ function L() {
       "while",
       "xor",
       "yield"
-    ], E = [
+    ];
+    const BUILT_INS = [
       // Standard PHP library:
       // <https://www.php.net/manual/en/book.spl.php>
       "Error|0",
@@ -260,37 +275,53 @@ function L() {
       "self",
       "static",
       "stdClass"
-    ], p = {
-      keyword: T,
-      literal: ((b) => {
-        const r = [];
-        return b.forEach((o) => {
-          r.push(o), o.toLowerCase() === o ? r.push(o.toUpperCase()) : r.push(o.toLowerCase());
-        }), r;
-      })(_),
-      built_in: E
-    }, d = (b) => b.map((r) => r.replace(/\|\d+$/, "")), u = { variants: [
+    ];
+    const dualCase = (items) => {
+      const result = [];
+      items.forEach((item) => {
+        result.push(item);
+        if (item.toLowerCase() === item) {
+          result.push(item.toUpperCase());
+        } else {
+          result.push(item.toLowerCase());
+        }
+      });
+      return result;
+    };
+    const KEYWORDS = {
+      keyword: KWS,
+      literal: dualCase(LITERALS),
+      built_in: BUILT_INS
+    };
+    const normalizeKeywords = (items) => {
+      return items.map((item) => {
+        return item.replace(/\|\d+$/, "");
+      });
+    };
+    const CONSTRUCTOR_CALL = { variants: [
       {
         match: [
           /new/,
-          t.concat(S, "+"),
+          regex.concat(WHITESPACE, "+"),
           // to prevent built ins from being confused as the class constructor call
-          t.concat("(?!", d(E).join("\\b|"), "\\b)"),
-          a
+          regex.concat("(?!", normalizeKeywords(BUILT_INS).join("\\b|"), "\\b)"),
+          PASCAL_CASE_CLASS_NAME_RE
         ],
         scope: {
           1: "keyword",
           4: "title.class"
         }
       }
-    ] }, f = t.concat(n, "\\b(?!\\()"), s = { variants: [
+    ] };
+    const CONSTANT_REFERENCE = regex.concat(IDENT_RE, "\\b(?!\\()");
+    const LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON = { variants: [
       {
         match: [
-          t.concat(
+          regex.concat(
             /::/,
-            t.lookahead(/(?!class\b)/)
+            regex.lookahead(/(?!class\b)/)
           ),
-          f
+          CONSTANT_REFERENCE
         ],
         scope: { 2: "variable.constant" }
       },
@@ -303,12 +334,12 @@ function L() {
       },
       {
         match: [
-          a,
-          t.concat(
+          PASCAL_CASE_CLASS_NAME_RE,
+          regex.concat(
             /::/,
-            t.lookahead(/(?!class\b)/)
+            regex.lookahead(/(?!class\b)/)
           ),
-          f
+          CONSTANT_REFERENCE
         ],
         scope: {
           1: "title.class",
@@ -317,17 +348,17 @@ function L() {
       },
       {
         match: [
-          a,
-          t.concat(
+          PASCAL_CASE_CLASS_NAME_RE,
+          regex.concat(
             "::",
-            t.lookahead(/(?!class\b)/)
+            regex.lookahead(/(?!class\b)/)
           )
         ],
         scope: { 1: "title.class" }
       },
       {
         match: [
-          a,
+          PASCAL_CASE_CLASS_NAME_RE,
           /::/,
           /class/
         ],
@@ -336,51 +367,55 @@ function L() {
           3: "variable.language"
         }
       }
-    ] }, R = {
+    ] };
+    const NAMED_ARGUMENT = {
       scope: "attr",
-      match: t.concat(n, t.lookahead(":"), t.lookahead(/(?!::)/))
-    }, C = {
+      match: regex.concat(IDENT_RE, regex.lookahead(":"), regex.lookahead(/(?!::)/))
+    };
+    const PARAMS_MODE = {
       relevance: 0,
       begin: /\(/,
       end: /\)/,
-      keywords: p,
+      keywords: KEYWORDS,
       contains: [
-        R,
-        l,
-        s,
-        e.C_BLOCK_COMMENT_MODE,
-        c,
-        i,
-        u
+        NAMED_ARGUMENT,
+        VARIABLE,
+        LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+        hljs.C_BLOCK_COMMENT_MODE,
+        STRING,
+        NUMBER,
+        CONSTRUCTOR_CALL
       ]
-    }, A = {
+    };
+    const FUNCTION_INVOKE = {
       relevance: 0,
       match: [
         /\b/,
         // to prevent keywords from being confused as the function title
-        t.concat("(?!fn\\b|function\\b|", d(T).join("\\b|"), "|", d(E).join("\\b|"), "\\b)"),
-        n,
-        t.concat(S, "*"),
-        t.lookahead(/(?=\()/)
+        regex.concat("(?!fn\\b|function\\b|", normalizeKeywords(KWS).join("\\b|"), "|", normalizeKeywords(BUILT_INS).join("\\b|"), "\\b)"),
+        IDENT_RE,
+        regex.concat(WHITESPACE, "*"),
+        regex.lookahead(/(?=\()/)
       ],
       scope: { 3: "title.function.invoke" },
-      contains: [C]
+      contains: [PARAMS_MODE]
     };
-    C.contains.push(A);
-    const m = [
-      R,
-      s,
-      e.C_BLOCK_COMMENT_MODE,
-      c,
-      i,
-      u
-    ], w = {
-      begin: t.concat(/#\[\s*/, a),
+    PARAMS_MODE.contains.push(FUNCTION_INVOKE);
+    const ATTRIBUTE_CONTAINS = [
+      NAMED_ARGUMENT,
+      LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+      hljs.C_BLOCK_COMMENT_MODE,
+      STRING,
+      NUMBER,
+      CONSTRUCTOR_CALL
+    ];
+    const ATTRIBUTES = {
+      begin: regex.concat(/#\[\s*/, PASCAL_CASE_CLASS_NAME_RE),
       beginScope: "meta",
       end: /]/,
       endScope: "meta",
       keywords: {
-        literal: _,
+        literal: LITERALS,
         keyword: [
           "new",
           "array"
@@ -391,7 +426,7 @@ function L() {
           begin: /\[/,
           end: /]/,
           keywords: {
-            literal: _,
+            literal: LITERALS,
             keyword: [
               "new",
               "array"
@@ -399,24 +434,24 @@ function L() {
           },
           contains: [
             "self",
-            ...m
+            ...ATTRIBUTE_CONTAINS
           ]
         },
-        ...m,
+        ...ATTRIBUTE_CONTAINS,
         {
           scope: "meta",
-          match: a
+          match: PASCAL_CASE_CLASS_NAME_RE
         }
       ]
     };
     return {
-      case_insensitive: !1,
-      keywords: p,
+      case_insensitive: false,
+      keywords: KEYWORDS,
       contains: [
-        w,
-        e.HASH_COMMENT_MODE,
-        e.COMMENT("//", "$"),
-        e.COMMENT(
+        ATTRIBUTES,
+        hljs.HASH_COMMENT_MODE,
+        hljs.COMMENT("//", "$"),
+        hljs.COMMENT(
           "/\\*",
           "\\*/",
           { contains: [
@@ -431,65 +466,65 @@ function L() {
           keywords: "__halt_compiler",
           starts: {
             scope: "comment",
-            end: e.MATCH_NOTHING_RE,
+            end: hljs.MATCH_NOTHING_RE,
             contains: [
               {
                 match: /\?>/,
                 scope: "meta",
-                endsParent: !0
+                endsParent: true
               }
             ]
           }
         },
-        N,
+        PREPROCESSOR,
         {
           scope: "variable.language",
           match: /\$this\b/
         },
-        l,
-        A,
-        s,
+        VARIABLE,
+        FUNCTION_INVOKE,
+        LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
         {
           match: [
             /const/,
             /\s/,
-            n
+            IDENT_RE
           ],
           scope: {
             1: "keyword",
             3: "variable.constant"
           }
         },
-        u,
+        CONSTRUCTOR_CALL,
         {
           scope: "function",
           relevance: 0,
           beginKeywords: "fn function",
           end: /[;{]/,
-          excludeEnd: !0,
+          excludeEnd: true,
           illegal: "[$%\\[]",
           contains: [
             { beginKeywords: "use" },
-            e.UNDERSCORE_TITLE_MODE,
+            hljs.UNDERSCORE_TITLE_MODE,
             {
               begin: "=>",
               // No markup, just a relevance booster
-              endsParent: !0
+              endsParent: true
             },
             {
               scope: "params",
               begin: "\\(",
               end: "\\)",
-              excludeBegin: !0,
-              excludeEnd: !0,
-              keywords: p,
+              excludeBegin: true,
+              excludeEnd: true,
+              keywords: KEYWORDS,
               contains: [
                 "self",
-                l,
-                s,
-                e.C_BLOCK_COMMENT_MODE,
-                c,
-                i
+                VARIABLE,
+                LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+                hljs.C_BLOCK_COMMENT_MODE,
+                STRING,
+                NUMBER
               ]
             }
           ]
@@ -508,10 +543,10 @@ function L() {
           ],
           relevance: 0,
           end: /\{/,
-          excludeEnd: !0,
+          excludeEnd: true,
           contains: [
             { beginKeywords: "extends implements" },
-            e.UNDERSCORE_TITLE_MODE
+            hljs.UNDERSCORE_TITLE_MODE
           ]
         },
         // both use and namespace still use "old style" rules (vs multi-match)
@@ -522,7 +557,7 @@ function L() {
           relevance: 0,
           end: ";",
           illegal: /[.']/,
-          contains: [e.inherit(e.UNDERSCORE_TITLE_MODE, { scope: "title.class" })]
+          contains: [hljs.inherit(hljs.UNDERSCORE_TITLE_MODE, { scope: "title.class" })]
         },
         {
           beginKeywords: "use",
@@ -535,16 +570,17 @@ function L() {
               scope: "keyword"
             },
             // TODO: could be title.class or title.function
-            e.UNDERSCORE_TITLE_MODE
+            hljs.UNDERSCORE_TITLE_MODE
           ]
         },
-        c,
-        i
+        STRING,
+        NUMBER
       ]
     };
   }
-  return I = y, I;
+  php_1 = php;
+  return php_1;
 }
 export {
-  L as __require
+  requirePhp as __require
 };

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

@@ -1,20 +1,22 @@
-var t, e;
-function i() {
-  if (e)
-    return t;
-  e = 1;
-  function r(a) {
+var plaintext_1;
+var hasRequiredPlaintext;
+function requirePlaintext() {
+  if (hasRequiredPlaintext)
+    return plaintext_1;
+  hasRequiredPlaintext = 1;
+  function plaintext(hljs) {
     return {
       name: "Plain text",
       aliases: [
         "text",
         "txt"
       ],
-      disableAutodetect: !0
+      disableAutodetect: true
     };
   }
-  return t = r, t;
+  plaintext_1 = plaintext;
+  return plaintext_1;
 }
 export {
-  i as __require
+  requirePlaintext as __require
 };

package/dist/es/node_modules/.pnpm/highlight.js@11.7.0/node_modules/highlight.js/lib/languages/python-repl.js

@@ -1,9 +1,10 @@
-var e, n;
-function a() {
-  if (n)
-    return e;
-  n = 1;
-  function t(r) {
+var pythonRepl_1;
+var hasRequiredPythonRepl;
+function requirePythonRepl() {
+  if (hasRequiredPythonRepl)
+    return pythonRepl_1;
+  hasRequiredPythonRepl = 1;
+  function pythonRepl(hljs) {
     return {
       aliases: ["pycon"],
       contains: [
@@ -26,8 +27,9 @@ function a() {
       ]
     };
   }
-  return e = t, e;
+  pythonRepl_1 = pythonRepl;
+  return pythonRepl_1;
 }
 export {
-  a as __require
+  requirePythonRepl as __require
 };