@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/python.js

@@ -1,10 +1,13 @@
-var b, g;
-function f() {
-  if (g)
-    return b;
-  g = 1;
-  function S(e) {
-    const u = e.regex, s = /[\p{XID_Start}_]\p{XID_Continue}*/u, d = [
+var python_1;
+var hasRequiredPython;
+function requirePython() {
+  if (hasRequiredPython)
+    return python_1;
+  hasRequiredPython = 1;
+  function python(hljs) {
+    const regex = hljs.regex;
+    const IDENT_RE = /[\p{XID_Start}_]\p{XID_Continue}*/u;
+    const RESERVED_WORDS = [
       "and",
       "as",
       "assert",
@@ -39,125 +42,133 @@ function f() {
       "while",
       "with",
       "yield"
-    ], r = {
+    ];
+    const BUILT_INS = [
+      "__import__",
+      "abs",
+      "all",
+      "any",
+      "ascii",
+      "bin",
+      "bool",
+      "breakpoint",
+      "bytearray",
+      "bytes",
+      "callable",
+      "chr",
+      "classmethod",
+      "compile",
+      "complex",
+      "delattr",
+      "dict",
+      "dir",
+      "divmod",
+      "enumerate",
+      "eval",
+      "exec",
+      "filter",
+      "float",
+      "format",
+      "frozenset",
+      "getattr",
+      "globals",
+      "hasattr",
+      "hash",
+      "help",
+      "hex",
+      "id",
+      "input",
+      "int",
+      "isinstance",
+      "issubclass",
+      "iter",
+      "len",
+      "list",
+      "locals",
+      "map",
+      "max",
+      "memoryview",
+      "min",
+      "next",
+      "object",
+      "oct",
+      "open",
+      "ord",
+      "pow",
+      "print",
+      "property",
+      "range",
+      "repr",
+      "reversed",
+      "round",
+      "set",
+      "setattr",
+      "slice",
+      "sorted",
+      "staticmethod",
+      "str",
+      "sum",
+      "super",
+      "tuple",
+      "type",
+      "vars",
+      "zip"
+    ];
+    const LITERALS = [
+      "__debug__",
+      "Ellipsis",
+      "False",
+      "None",
+      "NotImplemented",
+      "True"
+    ];
+    const TYPES = [
+      "Any",
+      "Callable",
+      "Coroutine",
+      "Dict",
+      "List",
+      "Literal",
+      "Generic",
+      "Optional",
+      "Sequence",
+      "Set",
+      "Tuple",
+      "Type",
+      "Union"
+    ];
+    const KEYWORDS = {
       $pattern: /[A-Za-z]\w+|__\w+__/,
-      keyword: d,
-      built_in: [
-        "__import__",
-        "abs",
-        "all",
-        "any",
-        "ascii",
-        "bin",
-        "bool",
-        "breakpoint",
-        "bytearray",
-        "bytes",
-        "callable",
-        "chr",
-        "classmethod",
-        "compile",
-        "complex",
-        "delattr",
-        "dict",
-        "dir",
-        "divmod",
-        "enumerate",
-        "eval",
-        "exec",
-        "filter",
-        "float",
-        "format",
-        "frozenset",
-        "getattr",
-        "globals",
-        "hasattr",
-        "hash",
-        "help",
-        "hex",
-        "id",
-        "input",
-        "int",
-        "isinstance",
-        "issubclass",
-        "iter",
-        "len",
-        "list",
-        "locals",
-        "map",
-        "max",
-        "memoryview",
-        "min",
-        "next",
-        "object",
-        "oct",
-        "open",
-        "ord",
-        "pow",
-        "print",
-        "property",
-        "range",
-        "repr",
-        "reversed",
-        "round",
-        "set",
-        "setattr",
-        "slice",
-        "sorted",
-        "staticmethod",
-        "str",
-        "sum",
-        "super",
-        "tuple",
-        "type",
-        "vars",
-        "zip"
-      ],
-      literal: [
-        "__debug__",
-        "Ellipsis",
-        "False",
-        "None",
-        "NotImplemented",
-        "True"
-      ],
-      type: [
-        "Any",
-        "Callable",
-        "Coroutine",
-        "Dict",
-        "List",
-        "Literal",
-        "Generic",
-        "Optional",
-        "Sequence",
-        "Set",
-        "Tuple",
-        "Type",
-        "Union"
-      ]
-    }, n = {
+      keyword: RESERVED_WORDS,
+      built_in: BUILT_INS,
+      literal: LITERALS,
+      type: TYPES
+    };
+    const PROMPT = {
       className: "meta",
       begin: /^(>>>|\.\.\.) /
-    }, i = {
+    };
+    const SUBST = {
       className: "subst",
       begin: /\{/,
       end: /\}/,
-      keywords: r,
+      keywords: KEYWORDS,
       illegal: /#/
-    }, o = {
+    };
+    const LITERAL_BRACKET = {
       begin: /\{\{/,
       relevance: 0
-    }, c = {
+    };
+    const STRING = {
       className: "string",
-      contains: [e.BACKSLASH_ESCAPE],
+      contains: [hljs.BACKSLASH_ESCAPE],
       variants: [
         {
           begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,
           end: /'''/,
           contains: [
-            e.BACKSLASH_ESCAPE,
-            n
+            hljs.BACKSLASH_ESCAPE,
+            PROMPT
           ],
           relevance: 10
         },
@@ -165,8 +176,8 @@ function f() {
           begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,
           end: /"""/,
           contains: [
-            e.BACKSLASH_ESCAPE,
-            n
+            hljs.BACKSLASH_ESCAPE,
+            PROMPT
           ],
           relevance: 10
         },
@@ -174,20 +185,20 @@ function f() {
           begin: /([fF][rR]|[rR][fF]|[fF])'''/,
           end: /'''/,
           contains: [
-            e.BACKSLASH_ESCAPE,
-            n,
-            o,
-            i
+            hljs.BACKSLASH_ESCAPE,
+            PROMPT,
+            LITERAL_BRACKET,
+            SUBST
           ]
         },
         {
           begin: /([fF][rR]|[rR][fF]|[fF])"""/,
           end: /"""/,
           contains: [
-            e.BACKSLASH_ESCAPE,
-            n,
-            o,
-            i
+            hljs.BACKSLASH_ESCAPE,
+            PROMPT,
+            LITERAL_BRACKET,
+            SUBST
           ]
         },
         {
@@ -212,24 +223,28 @@ function f() {
           begin: /([fF][rR]|[rR][fF]|[fF])'/,
           end: /'/,
           contains: [
-            e.BACKSLASH_ESCAPE,
-            o,
-            i
+            hljs.BACKSLASH_ESCAPE,
+            LITERAL_BRACKET,
+            SUBST
           ]
         },
         {
           begin: /([fF][rR]|[rR][fF]|[fF])"/,
           end: /"/,
           contains: [
-            e.BACKSLASH_ESCAPE,
-            o,
-            i
+            hljs.BACKSLASH_ESCAPE,
+            LITERAL_BRACKET,
+            SUBST
           ]
         },
-        e.APOS_STRING_MODE,
-        e.QUOTE_STRING_MODE
+        hljs.APOS_STRING_MODE,
+        hljs.QUOTE_STRING_MODE
       ]
-    }, t = "[0-9](_?[0-9])*", _ = `(\\b(${t}))?\\.(${t})|\\b(${t})\\.`, a = `\\b|${d.join("|")}`, l = {
+    };
+    const digitpart = "[0-9](_?[0-9])*";
+    const pointfloat = `(\\b(${digitpart}))?\\.(${digitpart})|\\b(${digitpart})\\.`;
+    const lookahead = `\\b|${RESERVED_WORDS.join("|")}`;
+    const NUMBER = {
       className: "number",
       relevance: 0,
       variants: [
@@ -244,10 +259,10 @@ function f() {
         // because both MUST contain a decimal point and so cannot be confused with
         // the interior part of an identifier
         {
-          begin: `(\\b(${t})|(${_}))[eE][+-]?(${t})[jJ]?(?=${a})`
+          begin: `(\\b(${digitpart})|(${pointfloat}))[eE][+-]?(${digitpart})[jJ]?(?=${lookahead})`
         },
         {
-          begin: `(${_})[jJ]?`
+          begin: `(${pointfloat})[jJ]?`
         },
         // decinteger, bininteger, octinteger, hexinteger
         // https://docs.python.org/3.9/reference/lexical_analysis.html#integer-literals
@@ -256,28 +271,29 @@ function f() {
         // decinteger is optionally imaginary
         // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
         {
-          begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${a})`
+          begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${lookahead})`
         },
         {
-          begin: `\\b0[bB](_?[01])+[lL]?(?=${a})`
+          begin: `\\b0[bB](_?[01])+[lL]?(?=${lookahead})`
         },
         {
-          begin: `\\b0[oO](_?[0-7])+[lL]?(?=${a})`
+          begin: `\\b0[oO](_?[0-7])+[lL]?(?=${lookahead})`
         },
         {
-          begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${a})`
+          begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${lookahead})`
         },
         // imagnumber (digitpart-based)
         // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
         {
-          begin: `\\b(${t})[jJ](?=${a})`
+          begin: `\\b(${digitpart})[jJ](?=${lookahead})`
         }
       ]
-    }, E = {
+    };
+    const COMMENT_TYPE = {
       className: "comment",
-      begin: u.lookahead(/# type:/),
+      begin: regex.lookahead(/# type:/),
       end: /$/,
-      keywords: r,
+      keywords: KEYWORDS,
       contains: [
         {
           // prevent keywords from coloring `type`
@@ -287,51 +303,53 @@ function f() {
         {
           begin: /#/,
           end: /\b\B/,
-          endsWithParent: !0
+          endsWithParent: true
         }
       ]
-    }, p = {
+    };
+    const PARAMS = {
       className: "params",
       variants: [
         // Exclude params in functions without params
         {
           className: "",
           begin: /\(\s*\)/,
-          skip: !0
+          skip: true
         },
         {
           begin: /\(/,
           end: /\)/,
-          excludeBegin: !0,
-          excludeEnd: !0,
-          keywords: r,
+          excludeBegin: true,
+          excludeEnd: true,
+          keywords: KEYWORDS,
           contains: [
             "self",
-            n,
-            l,
-            c,
-            e.HASH_COMMENT_MODE
+            PROMPT,
+            NUMBER,
+            STRING,
+            hljs.HASH_COMMENT_MODE
           ]
         }
       ]
     };
-    return i.contains = [
-      c,
-      l,
-      n
-    ], {
+    SUBST.contains = [
+      STRING,
+      NUMBER,
+      PROMPT
+    ];
+    return {
       name: "Python",
       aliases: [
         "py",
         "gyp",
         "ipython"
       ],
-      unicodeRegex: !0,
-      keywords: r,
+      unicodeRegex: true,
+      keywords: KEYWORDS,
       illegal: /(<\/|->|\?)|=>/,
       contains: [
-        n,
-        l,
+        PROMPT,
+        NUMBER,
         {
           // very common convention
           begin: /\bself\b/
@@ -342,20 +360,20 @@ function f() {
           beginKeywords: "if",
           relevance: 0
         },
-        c,
-        E,
-        e.HASH_COMMENT_MODE,
+        STRING,
+        COMMENT_TYPE,
+        hljs.HASH_COMMENT_MODE,
         {
           match: [
             /\bdef/,
             /\s+/,
-            s
+            IDENT_RE
           ],
           scope: {
             1: "keyword",
             3: "title.function"
           },
-          contains: [p]
+          contains: [PARAMS]
         },
         {
           variants: [
@@ -363,10 +381,10 @@ function f() {
               match: [
                 /\bclass/,
                 /\s+/,
-                s,
+                IDENT_RE,
                 /\s*/,
                 /\(\s*/,
-                s,
+                IDENT_RE,
                 /\s*\)/
               ]
             },
@@ -374,7 +392,7 @@ function f() {
               match: [
                 /\bclass/,
                 /\s+/,
-                s
+                IDENT_RE
               ]
             }
           ],
@@ -389,16 +407,17 @@ function f() {
           begin: /^[\t ]*@/,
           end: /(?=#)|$/,
           contains: [
-            l,
-            p,
-            c
+            NUMBER,
+            PARAMS,
+            STRING
           ]
         }
       ]
     };
   }
-  return b = S, b;
+  python_1 = python;
+  return python_1;
 }
 export {
-  f as __require
+  requirePython as __require
 };