@fangzhongya/vue-archive 0.0.2 → 0.0.3-2

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

@@ -0,0 +1,519 @@
+var _, m;
+function x() {
+  if (m)
+    return _;
+  m = 1;
+  function E(e) {
+    const n = e.regex, a = e.COMMENT("//", "$", { contains: [{ begin: /\\\n/ }] }), u = "decltype\\(auto\\)", c = "[a-zA-Z_]\\w*::", g = "<[^<>]+>", f = "(?!struct)(" + u + "|" + n.optional(c) + "[a-zA-Z_]\\w*" + n.optional(g) + ")", r = {
+      className: "type",
+      begin: "\\b[a-z\\d_]*_t\\b"
+    }, b = "\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)", i = {
+      className: "string",
+      variants: [
+        {
+          begin: '(u8?|U|L)?"',
+          end: '"',
+          illegal: "\\n",
+          contains: [e.BACKSLASH_ESCAPE]
+        },
+        {
+          begin: "(u8?|U|L)?'(" + b + "|.)",
+          end: "'",
+          illegal: "."
+        },
+        e.END_SAME_AS_BEGIN({
+          begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
+          end: /\)([^()\\ ]{0,16})"/
+        })
+      ]
+    }, s = {
+      className: "number",
+      variants: [
+        { begin: "\\b(0b[01']+)" },
+        { begin: "(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)" },
+        { begin: "(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)" }
+      ],
+      relevance: 0
+    }, o = {
+      className: "meta",
+      begin: /#\s*[a-z]+\b/,
+      end: /$/,
+      keywords: { keyword: "if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include" },
+      contains: [
+        {
+          begin: /\\\n/,
+          relevance: 0
+        },
+        e.inherit(i, { className: "string" }),
+        {
+          className: "string",
+          begin: /<.*?>/
+        },
+        a,
+        e.C_BLOCK_COMMENT_MODE
+      ]
+    }, N = {
+      className: "title",
+      begin: n.optional(c) + e.IDENT_RE,
+      relevance: 0
+    }, d = n.optional(c) + e.IDENT_RE + "\\s*\\(", y = [
+      "alignas",
+      "alignof",
+      "and",
+      "and_eq",
+      "asm",
+      "atomic_cancel",
+      "atomic_commit",
+      "atomic_noexcept",
+      "auto",
+      "bitand",
+      "bitor",
+      "break",
+      "case",
+      "catch",
+      "class",
+      "co_await",
+      "co_return",
+      "co_yield",
+      "compl",
+      "concept",
+      "const_cast|10",
+      "consteval",
+      "constexpr",
+      "constinit",
+      "continue",
+      "decltype",
+      "default",
+      "delete",
+      "do",
+      "dynamic_cast|10",
+      "else",
+      "enum",
+      "explicit",
+      "export",
+      "extern",
+      "false",
+      "final",
+      "for",
+      "friend",
+      "goto",
+      "if",
+      "import",
+      "inline",
+      "module",
+      "mutable",
+      "namespace",
+      "new",
+      "noexcept",
+      "not",
+      "not_eq",
+      "nullptr",
+      "operator",
+      "or",
+      "or_eq",
+      "override",
+      "private",
+      "protected",
+      "public",
+      "reflexpr",
+      "register",
+      "reinterpret_cast|10",
+      "requires",
+      "return",
+      "sizeof",
+      "static_assert",
+      "static_cast|10",
+      "struct",
+      "switch",
+      "synchronized",
+      "template",
+      "this",
+      "thread_local",
+      "throw",
+      "transaction_safe",
+      "transaction_safe_dynamic",
+      "true",
+      "try",
+      "typedef",
+      "typeid",
+      "typename",
+      "union",
+      "using",
+      "virtual",
+      "volatile",
+      "while",
+      "xor",
+      "xor_eq"
+    ], T = [
+      "bool",
+      "char",
+      "char16_t",
+      "char32_t",
+      "char8_t",
+      "double",
+      "float",
+      "int",
+      "long",
+      "short",
+      "void",
+      "wchar_t",
+      "unsigned",
+      "signed",
+      "const",
+      "static"
+    ], v = [
+      "any",
+      "auto_ptr",
+      "barrier",
+      "binary_semaphore",
+      "bitset",
+      "complex",
+      "condition_variable",
+      "condition_variable_any",
+      "counting_semaphore",
+      "deque",
+      "false_type",
+      "future",
+      "imaginary",
+      "initializer_list",
+      "istringstream",
+      "jthread",
+      "latch",
+      "lock_guard",
+      "multimap",
+      "multiset",
+      "mutex",
+      "optional",
+      "ostringstream",
+      "packaged_task",
+      "pair",
+      "promise",
+      "priority_queue",
+      "queue",
+      "recursive_mutex",
+      "recursive_timed_mutex",
+      "scoped_lock",
+      "set",
+      "shared_future",
+      "shared_lock",
+      "shared_mutex",
+      "shared_timed_mutex",
+      "shared_ptr",
+      "stack",
+      "string_view",
+      "stringstream",
+      "timed_mutex",
+      "thread",
+      "true_type",
+      "tuple",
+      "unique_lock",
+      "unique_ptr",
+      "unordered_map",
+      "unordered_multimap",
+      "unordered_multiset",
+      "unordered_set",
+      "variant",
+      "vector",
+      "weak_ptr",
+      "wstring",
+      "wstring_view"
+    ], w = [
+      "abort",
+      "abs",
+      "acos",
+      "apply",
+      "as_const",
+      "asin",
+      "atan",
+      "atan2",
+      "calloc",
+      "ceil",
+      "cerr",
+      "cin",
+      "clog",
+      "cos",
+      "cosh",
+      "cout",
+      "declval",
+      "endl",
+      "exchange",
+      "exit",
+      "exp",
+      "fabs",
+      "floor",
+      "fmod",
+      "forward",
+      "fprintf",
+      "fputs",
+      "free",
+      "frexp",
+      "fscanf",
+      "future",
+      "invoke",
+      "isalnum",
+      "isalpha",
+      "iscntrl",
+      "isdigit",
+      "isgraph",
+      "islower",
+      "isprint",
+      "ispunct",
+      "isspace",
+      "isupper",
+      "isxdigit",
+      "labs",
+      "launder",
+      "ldexp",
+      "log",
+      "log10",
+      "make_pair",
+      "make_shared",
+      "make_shared_for_overwrite",
+      "make_tuple",
+      "make_unique",
+      "malloc",
+      "memchr",
+      "memcmp",
+      "memcpy",
+      "memset",
+      "modf",
+      "move",
+      "pow",
+      "printf",
+      "putchar",
+      "puts",
+      "realloc",
+      "scanf",
+      "sin",
+      "sinh",
+      "snprintf",
+      "sprintf",
+      "sqrt",
+      "sscanf",
+      "std",
+      "stderr",
+      "stdin",
+      "stdout",
+      "strcat",
+      "strchr",
+      "strcmp",
+      "strcpy",
+      "strcspn",
+      "strlen",
+      "strncat",
+      "strncmp",
+      "strncpy",
+      "strpbrk",
+      "strrchr",
+      "strspn",
+      "strstr",
+      "swap",
+      "tan",
+      "tanh",
+      "terminate",
+      "to_underlying",
+      "tolower",
+      "toupper",
+      "vfprintf",
+      "visit",
+      "vprintf",
+      "vsprintf"
+    ], t = {
+      type: T,
+      keyword: y,
+      literal: [
+        "NULL",
+        "false",
+        "nullopt",
+        "nullptr",
+        "true"
+      ],
+      built_in: ["_Pragma"],
+      _type_hints: v
+    }, p = {
+      className: "function.dispatch",
+      relevance: 0,
+      keywords: {
+        // Only for relevance, not highlighting.
+        _hint: w
+      },
+      begin: n.concat(
+        /\b/,
+        /(?!decltype)/,
+        /(?!if)/,
+        /(?!for)/,
+        /(?!switch)/,
+        /(?!while)/,
+        e.IDENT_RE,
+        n.lookahead(/(<[^<>]+>|)\s*\(/)
+      )
+    }, l = [
+      p,
+      o,
+      r,
+      a,
+      e.C_BLOCK_COMMENT_MODE,
+      s,
+      i
+    ], h = {
+      // This mode covers expression context where we can't expect a function
+      // definition and shouldn't highlight anything that looks like one:
+      // `return some()`, `else if()`, `(x*sum(1, 2))`
+      variants: [
+        {
+          begin: /=/,
+          end: /;/
+        },
+        {
+          begin: /\(/,
+          end: /\)/
+        },
+        {
+          beginKeywords: "new throw return else",
+          end: /;/
+        }
+      ],
+      keywords: t,
+      contains: l.concat([
+        {
+          begin: /\(/,
+          end: /\)/,
+          keywords: t,
+          contains: l.concat(["self"]),
+          relevance: 0
+        }
+      ]),
+      relevance: 0
+    }, C = {
+      className: "function",
+      begin: "(" + f + "[\\*&\\s]+)+" + d,
+      returnBegin: !0,
+      end: /[{;=]/,
+      excludeEnd: !0,
+      keywords: t,
+      illegal: /[^\w\s\*&:<>.]/,
+      contains: [
+        {
+          // to prevent it from being confused as the function title
+          begin: u,
+          keywords: t,
+          relevance: 0
+        },
+        {
+          begin: d,
+          returnBegin: !0,
+          contains: [N],
+          relevance: 0
+        },
+        // needed because we do not have look-behind on the below rule
+        // to prevent it from grabbing the final : in a :: pair
+        {
+          begin: /::/,
+          relevance: 0
+        },
+        // initializers
+        {
+          begin: /:/,
+          endsWithParent: !0,
+          contains: [
+            i,
+            s
+          ]
+        },
+        // allow for multiple declarations, e.g.:
+        // extern void f(int), g(char);
+        {
+          relevance: 0,
+          match: /,/
+        },
+        {
+          className: "params",
+          begin: /\(/,
+          end: /\)/,
+          keywords: t,
+          relevance: 0,
+          contains: [
+            a,
+            e.C_BLOCK_COMMENT_MODE,
+            i,
+            s,
+            r,
+            // Count matching parentheses.
+            {
+              begin: /\(/,
+              end: /\)/,
+              keywords: t,
+              relevance: 0,
+              contains: [
+                "self",
+                a,
+                e.C_BLOCK_COMMENT_MODE,
+                i,
+                s,
+                r
+              ]
+            }
+          ]
+        },
+        r,
+        a,
+        e.C_BLOCK_COMMENT_MODE,
+        o
+      ]
+    };
+    return {
+      name: "C++",
+      aliases: [
+        "cc",
+        "c++",
+        "h++",
+        "hpp",
+        "hh",
+        "hxx",
+        "cxx"
+      ],
+      keywords: t,
+      illegal: "</",
+      classNameAliases: { "function.dispatch": "built_in" },
+      contains: [].concat(
+        h,
+        C,
+        p,
+        l,
+        [
+          o,
+          {
+            // containers: ie, `vector <int> rooms (9);`
+            begin: "\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array|tuple|optional|variant|function)\\s*<(?!<)",
+            end: ">",
+            keywords: t,
+            contains: [
+              "self",
+              r
+            ]
+          },
+          {
+            begin: e.IDENT_RE + "::",
+            keywords: t
+          },
+          {
+            match: [
+              // extra complexity to deal with `enum class` and `enum struct`
+              /\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,
+              /\s+/,
+              /\w+/
+            ],
+            className: {
+              1: "keyword",
+              3: "title.class"
+            }
+          }
+        ]
+      )
+    };
+  }
+  return _ = E, _;
+}
+export {
+  x as __require
+};

package/dist/node_modules/.pnpm/highlight.js@11.7.0/node_modules/highlight.js/lib/languages/csharp.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var _,l;function R(){if(l)return _;l=1;function g(e){const O=["bool","byte","char","decimal","delegate","double","dynamic","enum","float","int","long","nint","nuint","object","sbyte","short","string","ulong","uint","ushort"],u=["public","private","protected","static","internal","protected","abstract","async","extern","override","unsafe","virtual","new","sealed","partial"],N=["default","false","null","true"],T=["abstract","as","base","break","case","catch","class","const","continue","do","else","event","explicit","extern","finally","fixed","for","foreach","goto","if","implicit","in","interface","internal","is","lock","namespace","new","operator","out","override","params","private","protected","public","readonly","record","ref","return","scoped","sealed","sizeof","stackalloc","static","struct","switch","this","throw","try","typeof","unchecked","unsafe","using","virtual","void","volatile","while"],b=["add","alias","and","ascending","async","await","by","descending","equals","from","get","global","group","init","into","join","let","nameof","not","notnull","on","or","orderby","partial","remove","select","set","unmanaged","value|0","var","when","where","with","yield"],n={keyword:T.concat(b),built_in:O,literal:N},i=e.inherit(e.TITLE_MODE,{begin:"[a-zA-Z](\\.?\\w)*"}),a={className:"number",variants:[{begin:"\\b(0b[01']+)"},{begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)"},{begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"}],relevance:0},t={className:"string",begin:'@"',end:'"',contains:[{begin:'""'}]},M=e.inherit(t,{illegal:/\n/}),r={className:"subst",begin:/\{/,end:/\}/,keywords:n},c=e.inherit(r,{illegal:/\n/}),s={className:"string",begin:/\$"/,end:'"',illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},e.BACKSLASH_ESCAPE,c]},o={className:"string",begin:/\$@"/,end:'"',contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},r]},I=e.inherit(o,{illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},c]});r.contains=[o,s,t,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,a,e.C_BLOCK_COMMENT_MODE],c.contains=[I,s,M,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,a,e.inherit(e.C_BLOCK_COMMENT_MODE,{illegal:/\n/})];const d={variants:[o,s,t,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},E={begin:"<",end:">",contains:[{beginKeywords:"in out"},i]},C=e.IDENT_RE+"(<"+e.IDENT_RE+"(\\s*,\\s*"+e.IDENT_RE+")*>)?(\\[\\])?",D={begin:"@"+e.IDENT_RE,relevance:0};return{name:"C#",aliases:["cs","c#"],keywords:n,illegal:/::/,contains:[e.COMMENT("///","$",{returnBegin:!0,contains:[{className:"doctag",variants:[{begin:"///",relevance:0},{begin:"<!--|-->"},{begin:"</?",end:">"}]}]}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"meta",begin:"#",end:"$",keywords:{keyword:"if else elif endif define undef warning error line region endregion pragma checksum"}},d,a,{beginKeywords:"class interface",relevance:0,end:/[{;=]/,illegal:/[^\s:,]/,contains:[{beginKeywords:"where class"},i,E,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"namespace",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[i,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"record",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[i,E,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"meta",begin:"^\\s*\\[(?=[\\w])",excludeBegin:!0,end:"\\]",excludeEnd:!0,contains:[{className:"string",begin:/"/,end:/"/}]},{beginKeywords:"new return throw await else",relevance:0},{className:"function",begin:"("+C+"\\s+)+"+e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,end:/\s*[{;=]/,excludeEnd:!0,keywords:n,contains:[{beginKeywords:u.join(" "),relevance:0},{begin:e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,contains:[e.TITLE_MODE,E],relevance:0},{match:/\(\)/},{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:n,relevance:0,contains:[d,a,e.C_BLOCK_COMMENT_MODE]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},D]}}return _=g,_}exports.__require=R;