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

@@ -1,17 +1,22 @@
-var s, c;
-function m() {
-  if (c)
-    return s;
-  c = 1;
-  function o(e) {
-    const a = e.regex, i = /(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/, n = a.either(
+var r_1;
+var hasRequiredR;
+function requireR() {
+  if (hasRequiredR)
+    return r_1;
+  hasRequiredR = 1;
+  function r(hljs) {
+    const regex = hljs.regex;
+    const IDENT_RE = /(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/;
+    const NUMBER_TYPES_RE = regex.either(
       // Special case: only hexadecimal binary powers can contain fractions
       /0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/,
       // Hexadecimal numbers without fraction and optional binary power
       /0[xX][0-9a-fA-F]+(?:[pP][+-]?\d+)?[Li]?/,
       // Decimal numbers
       /(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[Li]?/
-    ), t = /[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!$&|:<=>@^~]|\*\*/, r = a.either(
+    );
+    const OPERATORS_RE = /[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!$&|:<=>@^~]|\*\*/;
+    const PUNCTUATION_RE = regex.either(
       /[()]/,
       /[{}]/,
       /\[\[/,
@@ -22,7 +27,7 @@ function m() {
     return {
       name: "R",
       keywords: {
-        $pattern: i,
+        $pattern: IDENT_RE,
         keyword: "function if in break next repeat else for while",
         literal: "NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 NA_character_|10 NA_complex_|10",
         built_in: (
@@ -32,7 +37,7 @@ function m() {
       },
       contains: [
         // Roxygen comments
-        e.COMMENT(
+        hljs.COMMENT(
           /#'/,
           /$/,
           { contains: [
@@ -45,13 +50,13 @@ function m() {
               scope: "doctag",
               match: /@examples/,
               starts: {
-                end: a.lookahead(a.either(
+                end: regex.lookahead(regex.either(
                   // end if another doc comment
                   /\n^#'\s*(?=@[a-zA-Z]+)/,
                   // or a line with no comment
                   /\n^(?!#')/
                 )),
-                endsParent: !0
+                endsParent: true
               }
             },
             {
@@ -64,10 +69,10 @@ function m() {
                 {
                   scope: "variable",
                   variants: [
-                    { match: i },
+                    { match: IDENT_RE },
                     { match: /`(?:\\.|[^`\\])+`/ }
                   ],
-                  endsParent: !0
+                  endsParent: true
                 }
               ]
             },
@@ -81,32 +86,32 @@ function m() {
             }
           ] }
         ),
-        e.HASH_COMMENT_MODE,
+        hljs.HASH_COMMENT_MODE,
         {
           scope: "string",
-          contains: [e.BACKSLASH_ESCAPE],
+          contains: [hljs.BACKSLASH_ESCAPE],
           variants: [
-            e.END_SAME_AS_BEGIN({
+            hljs.END_SAME_AS_BEGIN({
               begin: /[rR]"(-*)\(/,
               end: /\)(-*)"/
             }),
-            e.END_SAME_AS_BEGIN({
+            hljs.END_SAME_AS_BEGIN({
               begin: /[rR]"(-*)\{/,
               end: /\}(-*)"/
             }),
-            e.END_SAME_AS_BEGIN({
+            hljs.END_SAME_AS_BEGIN({
               begin: /[rR]"(-*)\[/,
               end: /\](-*)"/
             }),
-            e.END_SAME_AS_BEGIN({
+            hljs.END_SAME_AS_BEGIN({
               begin: /[rR]'(-*)\(/,
               end: /\)(-*)'/
             }),
-            e.END_SAME_AS_BEGIN({
+            hljs.END_SAME_AS_BEGIN({
               begin: /[rR]'(-*)\{/,
               end: /\}(-*)'/
             }),
-            e.END_SAME_AS_BEGIN({
+            hljs.END_SAME_AS_BEGIN({
               begin: /[rR]'(-*)\[/,
               end: /\](-*)'/
             }),
@@ -140,8 +145,8 @@ function m() {
                 2: "number"
               },
               match: [
-                t,
-                n
+                OPERATORS_RE,
+                NUMBER_TYPES_RE
               ]
             },
             {
@@ -151,7 +156,7 @@ function m() {
               },
               match: [
                 /%[^%]*%/,
-                n
+                NUMBER_TYPES_RE
               ]
             },
             {
@@ -160,8 +165,8 @@ function m() {
                 2: "number"
               },
               match: [
-                r,
-                n
+                PUNCTUATION_RE,
+                NUMBER_TYPES_RE
               ]
             },
             {
@@ -169,7 +174,7 @@ function m() {
               match: [
                 /[^a-zA-Z0-9._]|^/,
                 // not part of an identifier, or start of document
-                n
+                NUMBER_TYPES_RE
               ]
             }
           ]
@@ -179,7 +184,7 @@ function m() {
           // Relevance boost for the most common assignment form.
           scope: { 3: "operator" },
           match: [
-            i,
+            IDENT_RE,
             /\s+/,
             /<-/,
             /\s+/
@@ -189,14 +194,14 @@ function m() {
           scope: "operator",
           relevance: 0,
           variants: [
-            { match: t },
+            { match: OPERATORS_RE },
             { match: /%[^%]*%/ }
           ]
         },
         {
           scope: "punctuation",
           relevance: 0,
-          match: r
+          match: PUNCTUATION_RE
         },
         {
           // Escaped identifier
@@ -207,8 +212,9 @@ function m() {
       ]
     };
   }
-  return s = o, s;
+  r_1 = r;
+  return r_1;
 }
 export {
-  m as __require
+  requireR as __require
 };

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

@@ -1,14 +1,29 @@
-var o, N;
-function p() {
-  if (N)
-    return o;
-  N = 1;
-  function A(e) {
-    const t = e.regex, b = "([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)", _ = t.either(
+var ruby_1;
+var hasRequiredRuby;
+function requireRuby() {
+  if (hasRequiredRuby)
+    return ruby_1;
+  hasRequiredRuby = 1;
+  function ruby(hljs) {
+    const regex = hljs.regex;
+    const RUBY_METHOD_RE = "([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)";
+    const CLASS_NAME_RE = regex.either(
       /\b([A-Z]+[a-z0-9]+)+/,
       // ends in caps
       /\b([A-Z]+[a-z0-9]+)+[A-Z]+/
-    ), a = t.concat(_, /(::\w+)*/), n = {
+    );
+    const CLASS_NAME_WITH_NAMESPACE_RE = regex.concat(CLASS_NAME_RE, /(::\w+)*/);
+    const PSEUDO_KWS = [
+      "include",
+      "extend",
+      "prepend",
+      "public",
+      "private",
+      "protected",
+      "raise",
+      "throw"
+    ];
+    const RUBY_KEYWORDS = {
       "variable.constant": [
         "__FILE__",
         "__LINE__",
@@ -52,16 +67,7 @@ function p() {
         "when",
         "while",
         "yield",
-        ...[
-          "include",
-          "extend",
-          "prepend",
-          "public",
-          "private",
-          "protected",
-          "raise",
-          "throw"
-        ]
+        ...PSEUDO_KWS
       ],
       built_in: [
         "proc",
@@ -78,37 +84,42 @@ function p() {
         "false",
         "nil"
       ]
-    }, E = {
+    };
+    const YARDOCTAG = {
       className: "doctag",
       begin: "@[A-Za-z]+"
-    }, r = {
+    };
+    const IRB_OBJECT = {
       begin: "#<",
       end: ">"
-    }, i = [
-      e.COMMENT(
+    };
+    const COMMENT_MODES = [
+      hljs.COMMENT(
         "#",
         "$",
-        { contains: [E] }
+        { contains: [YARDOCTAG] }
       ),
-      e.COMMENT(
+      hljs.COMMENT(
         "^=begin",
         "^=end",
         {
-          contains: [E],
+          contains: [YARDOCTAG],
           relevance: 10
         }
       ),
-      e.COMMENT("^__END__", e.MATCH_NOTHING_RE)
-    ], c = {
+      hljs.COMMENT("^__END__", hljs.MATCH_NOTHING_RE)
+    ];
+    const SUBST = {
       className: "subst",
       begin: /#\{/,
       end: /\}/,
-      keywords: n
-    }, d = {
+      keywords: RUBY_KEYWORDS
+    };
+    const STRING = {
       className: "string",
       contains: [
-        e.BACKSLASH_ESCAPE,
-        c
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
       ],
       variants: [
         {
@@ -167,28 +178,31 @@ function p() {
         {
           // this guard makes sure that we have an entire heredoc and not a false
           // positive (auto-detect, etc.)
-          begin: t.concat(
+          begin: regex.concat(
             /<<[-~]?'?/,
-            t.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/)
+            regex.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/)
           ),
           contains: [
-            e.END_SAME_AS_BEGIN({
+            hljs.END_SAME_AS_BEGIN({
               begin: /(\w+)/,
               end: /(\w+)/,
               contains: [
-                e.BACKSLASH_ESCAPE,
-                c
+                hljs.BACKSLASH_ESCAPE,
+                SUBST
               ]
             })
           ]
         }
       ]
-    }, u = "[1-9](_?[0-9])*|0", l = "[0-9](_?[0-9])*", S = {
+    };
+    const decimal = "[1-9](_?[0-9])*|0";
+    const digits = "[0-9](_?[0-9])*";
+    const NUMBER = {
       className: "number",
       relevance: 0,
       variants: [
         // decimal integer/float, optionally exponential or rational, optionally imaginary
-        { begin: `\\b(${u})(\\.(${l}))?([eE][+-]?(${l})|r)?i?\\b` },
+        { begin: `\\b(${decimal})(\\.(${digits}))?([eE][+-]?(${digits})|r)?i?\\b` },
         // explicit decimal/binary/octal/hexadecimal integer,
         // optionally rational and/or imaginary
         { begin: "\\b0[dD][0-9](_?[0-9])*r?i?\\b" },
@@ -198,7 +212,8 @@ function p() {
         // 0-prefixed implicit octal integer, optionally rational and/or imaginary
         { begin: "\\b0(_?[0-7])+r?i?\\b" }
       ]
-    }, g = {
+    };
+    const PARAMS = {
       variants: [
         {
           match: /\(\)/
@@ -207,125 +222,132 @@ function p() {
           className: "params",
           begin: /\(/,
           end: /(?=\))/,
-          excludeBegin: !0,
-          endsParent: !0,
-          keywords: n
+          excludeBegin: true,
+          endsParent: true,
+          keywords: RUBY_KEYWORDS
         }
       ]
-    }, s = [
-      d,
-      {
-        variants: [
-          {
-            match: [
-              /class\s+/,
-              a,
-              /\s+<\s+/,
-              a
-            ]
-          },
-          {
-            match: [
-              /\b(class|module)\s+/,
-              a
-            ]
-          }
-        ],
-        scope: {
-          2: "title.class",
-          4: "title.class.inherited"
-        },
-        keywords: n
+    };
+    const INCLUDE_EXTEND = {
+      match: [
+        /(include|extend)\s+/,
+        CLASS_NAME_WITH_NAMESPACE_RE
+      ],
+      scope: {
+        2: "title.class"
       },
-      {
-        match: [
-          /(include|extend)\s+/,
-          a
-        ],
-        scope: {
-          2: "title.class"
+      keywords: RUBY_KEYWORDS
+    };
+    const CLASS_DEFINITION = {
+      variants: [
+        {
+          match: [
+            /class\s+/,
+            CLASS_NAME_WITH_NAMESPACE_RE,
+            /\s+<\s+/,
+            CLASS_NAME_WITH_NAMESPACE_RE
+          ]
         },
-        keywords: n
-      },
-      {
-        relevance: 0,
-        match: [
-          a,
-          /\.new[. (]/
-        ],
-        scope: {
-          1: "title.class"
+        {
+          match: [
+            /\b(class|module)\s+/,
+            CLASS_NAME_WITH_NAMESPACE_RE
+          ]
         }
+      ],
+      scope: {
+        2: "title.class",
+        4: "title.class.inherited"
       },
-      {
-        relevance: 0,
-        match: /\b[A-Z][A-Z_0-9]+\b/,
-        className: "variable.constant"
-      },
-      {
-        relevance: 0,
-        match: _,
-        scope: "title.class"
-      },
-      {
-        match: [
-          /def/,
-          /\s+/,
-          b
-        ],
-        scope: {
-          1: "keyword",
-          3: "title.function"
-        },
-        contains: [
-          g
-        ]
+      keywords: RUBY_KEYWORDS
+    };
+    const UPPER_CASE_CONSTANT = {
+      relevance: 0,
+      match: /\b[A-Z][A-Z_0-9]+\b/,
+      className: "variable.constant"
+    };
+    const METHOD_DEFINITION = {
+      match: [
+        /def/,
+        /\s+/,
+        RUBY_METHOD_RE
+      ],
+      scope: {
+        1: "keyword",
+        3: "title.function"
       },
+      contains: [
+        PARAMS
+      ]
+    };
+    const OBJECT_CREATION = {
+      relevance: 0,
+      match: [
+        CLASS_NAME_WITH_NAMESPACE_RE,
+        /\.new[. (]/
+      ],
+      scope: {
+        1: "title.class"
+      }
+    };
+    const CLASS_REFERENCE = {
+      relevance: 0,
+      match: CLASS_NAME_RE,
+      scope: "title.class"
+    };
+    const RUBY_DEFAULT_CONTAINS = [
+      STRING,
+      CLASS_DEFINITION,
+      INCLUDE_EXTEND,
+      OBJECT_CREATION,
+      UPPER_CASE_CONSTANT,
+      CLASS_REFERENCE,
+      METHOD_DEFINITION,
       {
         // swallow namespace qualifiers before symbols
-        begin: e.IDENT_RE + "::"
+        begin: hljs.IDENT_RE + "::"
       },
       {
         className: "symbol",
-        begin: e.UNDERSCORE_IDENT_RE + "(!|\\?)?:",
+        begin: hljs.UNDERSCORE_IDENT_RE + "(!|\\?)?:",
         relevance: 0
       },
       {
         className: "symbol",
         begin: ":(?!\\s)",
         contains: [
-          d,
-          { begin: b }
+          STRING,
+          { begin: RUBY_METHOD_RE }
         ],
         relevance: 0
       },
-      S,
+      NUMBER,
       {
         // negative-look forward attempts to prevent false matches like:
         // @ident@ or $ident$ that might indicate this is not ruby at all
         className: "variable",
-        begin: "(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"
+        begin: `(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])`
       },
       {
         className: "params",
         begin: /\|/,
         end: /\|/,
-        excludeBegin: !0,
-        excludeEnd: !0,
+        excludeBegin: true,
+        excludeEnd: true,
         relevance: 0,
         // this could be a lot of things (in other languages) other than params
-        keywords: n
+        keywords: RUBY_KEYWORDS
       },
       {
         // regexp container
-        begin: "(" + e.RE_STARTERS_RE + "|unless)\\s*",
+        begin: "(" + hljs.RE_STARTERS_RE + "|unless)\\s*",
         keywords: "unless",
         contains: [
           {
             className: "regexp",
             contains: [
-              e.BACKSLASH_ESCAPE,
-              c
+              hljs.BACKSLASH_ESCAPE,
+              SUBST
             ],
             illegal: /\n/,
             variants: [
@@ -351,30 +373,35 @@ function p() {
               }
             ]
           }
-        ].concat(r, i),
+        ].concat(IRB_OBJECT, COMMENT_MODES),
         relevance: 0
       }
-    ].concat(r, i);
-    c.contains = s, g.contains = s;
-    const T = "[>?]>", C = "[\\w#]+\\(\\w+\\):\\d+:\\d+[>*]", R = "(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>", m = [
+    ].concat(IRB_OBJECT, COMMENT_MODES);
+    SUBST.contains = RUBY_DEFAULT_CONTAINS;
+    PARAMS.contains = RUBY_DEFAULT_CONTAINS;
+    const SIMPLE_PROMPT = "[>?]>";
+    const DEFAULT_PROMPT = "[\\w#]+\\(\\w+\\):\\d+:\\d+[>*]";
+    const RVM_PROMPT = "(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>";
+    const IRB_DEFAULT = [
       {
         begin: /^\s*=>/,
         starts: {
           end: "$",
-          contains: s
+          contains: RUBY_DEFAULT_CONTAINS
         }
       },
       {
         className: "meta.prompt",
-        begin: "^(" + T + "|" + C + "|" + R + ")(?=[ ])",
+        begin: "^(" + SIMPLE_PROMPT + "|" + DEFAULT_PROMPT + "|" + RVM_PROMPT + ")(?=[ ])",
         starts: {
           end: "$",
-          keywords: n,
-          contains: s
+          keywords: RUBY_KEYWORDS,
+          contains: RUBY_DEFAULT_CONTAINS
         }
       }
     ];
-    return i.unshift(r), {
+    COMMENT_MODES.unshift(IRB_OBJECT);
+    return {
       name: "Ruby",
       aliases: [
         "rb",
@@ -383,13 +410,14 @@ function p() {
         "thor",
         "irb"
       ],
-      keywords: n,
+      keywords: RUBY_KEYWORDS,
       illegal: /\/\*/,
-      contains: [e.SHEBANG({ binary: "ruby" })].concat(m).concat(i).concat(s)
+      contains: [hljs.SHEBANG({ binary: "ruby" })].concat(IRB_DEFAULT).concat(COMMENT_MODES).concat(RUBY_DEFAULT_CONTAINS)
     };
   }
-  return o = A, o;
+  ruby_1 = ruby;
+  return ruby_1;
 }
 export {
-  p as __require
+  requireRuby as __require
 };