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

@@ -1,40 +1,57 @@
-var _, Y;
-function ye() {
-  if (Y)
-    return _;
-  Y = 1;
-  function C(t) {
-    return t ? typeof t == "string" ? t : t.source : null;
+var swift_1;
+var hasRequiredSwift;
+function requireSwift() {
+  if (hasRequiredSwift)
+    return swift_1;
+  hasRequiredSwift = 1;
+  function source(re) {
+    if (!re)
+      return null;
+    if (typeof re === "string")
+      return re;
+    return re.source;
   }
-  function p(t) {
-    return e("(?=", t, ")");
+  function lookahead(re) {
+    return concat("(?=", re, ")");
   }
-  function e(...t) {
-    return t.map((F) => C(F)).join("");
+  function concat(...args) {
+    const joined = args.map((x) => source(x)).join("");
+    return joined;
   }
-  function j(t) {
-    const o = t[t.length - 1];
-    return typeof o == "object" && o.constructor === Object ? (t.splice(t.length - 1, 1), o) : {};
+  function stripOptionsFromArgs(args) {
+    const opts = args[args.length - 1];
+    if (typeof opts === "object" && opts.constructor === Object) {
+      args.splice(args.length - 1, 1);
+      return opts;
+    } else {
+      return {};
+    }
   }
-  function s(...t) {
-    return "(" + (j(t).capture ? "" : "?:") + t.map((c) => C(c)).join("|") + ")";
+  function either(...args) {
+    const opts = stripOptionsFromArgs(args);
+    const joined = "(" + (opts.capture ? "" : "?:") + args.map((x) => source(x)).join("|") + ")";
+    return joined;
   }
-  const h = (t) => e(
+  const keywordWrapper = (keyword) => concat(
     /\b/,
-    t,
-    /\w$/.test(t) ? /\b/ : /\B/
-  ), q = [
+    keyword,
+    /\w$/.test(keyword) ? /\b/ : /\B/
+  );
+  const dotKeywords = [
     "Protocol",
     // contextual
     "Type"
     // contextual
-  ].map(h), O = [
+  ].map(keywordWrapper);
+  const optionalDotKeywords = [
     "init",
     "self"
-  ].map(h), z = [
+  ].map(keywordWrapper);
+  const keywordTypes = [
     "Any",
     "Self"
-  ], y = [
+  ];
+  const keywords = [
     // strings below will be fed into the regular `keywords` engine while regex
     // will result in additional modes being created to scan for those keywords to
     // avoid conflicts with other rules
@@ -159,11 +176,13 @@ function ye() {
     "while",
     "willSet"
     // contextual
-  ], S = [
+  ];
+  const literals = [
     "false",
     "nil",
     "true"
-  ], V = [
+  ];
+  const precedencegroupKeywords = [
     "assignment",
     "associativity",
     "higherThan",
@@ -171,7 +190,8 @@ function ye() {
     "lowerThan",
     "none",
     "right"
-  ], Z = [
+  ];
+  const numberSignKeywords = [
     "#colorLiteral",
     "#column",
     "#dsohandle",
@@ -192,7 +212,8 @@ function ye() {
     "#sourceLocation",
     "#warn_unqualified_access",
     "#warning"
-  ], g = [
+  ];
+  const builtIns = [
     "abs",
     "all",
     "any",
@@ -227,7 +248,8 @@ function ye() {
     "withVaList",
     "withoutActuallyEscaping",
     "zip"
-  ], D = s(
+  ];
+  const operatorHead = either(
     /[/=\-+!*%<>&|^~?]/,
     /[\u00A1-\u00A7]/,
     /[\u00A9\u00AB]/,
@@ -246,8 +268,9 @@ function ye() {
     /[\u3001-\u3003]/,
     /[\u3008-\u3020]/,
     /[\u3030]/
-  ), v = s(
-    D,
+  );
+  const operatorCharacter = either(
+    operatorHead,
     /[\u0300-\u036F]/,
     /[\u1DC0-\u1DFF]/,
     /[\u20D0-\u20FF]/,
@@ -255,7 +278,9 @@ function ye() {
     /[\uFE20-\uFE2F]/
     // TODO: The following characters are also allowed, but the regex isn't supported yet.
     // /[\u{E0100}-\u{E01EF}]/u
-  ), T = e(D, v, "*"), B = s(
+  );
+  const operator = concat(operatorHead, operatorCharacter, "*");
+  const identifierHead = either(
     /[a-zA-Z_]/,
     /[\u00A8\u00AA\u00AD\u00AF\u00B2-\u00B5\u00B7-\u00BA]/,
     /[\u00BC-\u00BE\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]/,
@@ -273,13 +298,17 @@ function ye() {
     // /[\u{50000}-\u{5FFFD}\u{60000-\u{6FFFD}\u{70000}-\u{7FFFD}\u{80000}-\u{8FFFD}]/u,
     // /[\u{90000}-\u{9FFFD}\u{A0000-\u{AFFFD}\u{B0000}-\u{BFFFD}\u{C0000}-\u{CFFFD}]/u,
     // /[\u{D0000}-\u{DFFFD}\u{E0000-\u{EFFFD}]/u
-  ), m = s(
-    B,
+  );
+  const identifierCharacter = either(
+    identifierHead,
     /\d/,
     /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/
-  ), a = e(B, m, "*"), w = e(/[A-Z]/, m, "*"), H = [
+  );
+  const identifier = concat(identifierHead, identifierCharacter, "*");
+  const typeIdentifier = concat(/[A-Z]/, identifierCharacter, "*");
+  const keywordAttributes = [
     "autoclosure",
-    e(/convention\(/, s("swift", "block", "c"), /\)/),
+    concat(/convention\(/, either("swift", "block", "c"), /\)/),
     "discardableResult",
     "dynamicCallable",
     "dynamicMemberLookup",
@@ -297,7 +326,7 @@ function ye() {
     "NSApplicationMain",
     "NSCopying",
     "NSManaged",
-    e(/objc\(/, a, /\)/),
+    concat(/objc\(/, identifier, /\)/),
     "objc",
     "objcMembers",
     "propertyWrapper",
@@ -307,7 +336,8 @@ function ye() {
     "UIApplicationMain",
     "unknown",
     "usableFromInline"
-  ], X = [
+  ];
+  const availabilityKeywords = [
     "iOS",
     "iOSApplicationExtension",
     "macOS",
@@ -320,176 +350,209 @@ function ye() {
     "tvOSApplicationExtension",
     "swift"
   ];
-  function J(t) {
-    const o = {
+  function swift(hljs) {
+    const WHITESPACE = {
       match: /\s+/,
       relevance: 0
-    }, F = t.COMMENT(
+    };
+    const BLOCK_COMMENT = hljs.COMMENT(
       "/\\*",
       "\\*/",
       { contains: ["self"] }
-    ), c = [
-      t.C_LINE_COMMENT_MODE,
-      F
-    ], Q = {
+    );
+    const COMMENTS = [
+      hljs.C_LINE_COMMENT_MODE,
+      BLOCK_COMMENT
+    ];
+    const DOT_KEYWORD = {
       match: [
         /\./,
-        s(...q, ...O)
+        either(...dotKeywords, ...optionalDotKeywords)
       ],
       className: { 2: "keyword" }
-    }, ee = {
+    };
+    const KEYWORD_GUARD = {
       // Consume .keyword to prevent highlighting properties and methods as keywords.
-      match: e(/\./, s(...y)),
+      match: concat(/\./, either(...keywords)),
       relevance: 0
-    }, te = y.filter((n) => typeof n == "string").concat(["_|0"]), ne = y.filter((n) => typeof n != "string").concat(z).map(h), se = { variants: [
+    };
+    const PLAIN_KEYWORDS = keywords.filter((kw) => typeof kw === "string").concat(["_|0"]);
+    const REGEX_KEYWORDS = keywords.filter((kw) => typeof kw !== "string").concat(keywordTypes).map(keywordWrapper);
+    const KEYWORD = { variants: [
       {
         className: "keyword",
-        match: s(...ne, ...O)
+        match: either(...REGEX_KEYWORDS, ...optionalDotKeywords)
       }
-    ] }, u = {
-      $pattern: s(
+    ] };
+    const KEYWORDS = {
+      $pattern: either(
         /\b\w+/,
         // regular keywords
         /#\w+/
         // number keywords
       ),
-      keyword: te.concat(Z),
-      literal: S
-    }, r = [
-      Q,
-      ee,
-      se
-    ], ae = {
+      keyword: PLAIN_KEYWORDS.concat(numberSignKeywords),
+      literal: literals
+    };
+    const KEYWORD_MODES = [
+      DOT_KEYWORD,
+      KEYWORD_GUARD,
+      KEYWORD
+    ];
+    const BUILT_IN_GUARD = {
       // Consume .built_in to prevent highlighting properties and methods.
-      match: e(/\./, s(...g)),
+      match: concat(/\./, either(...builtIns)),
       relevance: 0
-    }, oe = {
+    };
+    const BUILT_IN = {
       className: "built_in",
-      match: e(/\b/, s(...g), /(?=\()/)
-    }, I = [
-      ae,
-      oe
-    ], M = {
+      match: concat(/\b/, either(...builtIns), /(?=\()/)
+    };
+    const BUILT_INS = [
+      BUILT_IN_GUARD,
+      BUILT_IN
+    ];
+    const OPERATOR_GUARD = {
       // Prevent -> from being highlighting as an operator.
       match: /->/,
       relevance: 0
-    }, ce = {
+    };
+    const OPERATOR = {
       className: "operator",
       relevance: 0,
       variants: [
-        { match: T },
+        { match: operator },
         {
           // dot-operator: only operators that start with a dot are allowed to use dots as
           // characters (..., ...<, .*, etc). So there rule here is: a dot followed by one or more
           // characters that may also include dots.
-          match: `\\.(\\.|${v})+`
+          match: `\\.(\\.|${operatorCharacter})+`
         }
       ]
-    }, E = [
-      M,
-      ce
-    ], f = "([0-9]_*)+", P = "([0-9a-fA-F]_*)+", d = {
+    };
+    const OPERATORS = [
+      OPERATOR_GUARD,
+      OPERATOR
+    ];
+    const decimalDigits = "([0-9]_*)+";
+    const hexDigits = "([0-9a-fA-F]_*)+";
+    const NUMBER = {
       className: "number",
       relevance: 0,
       variants: [
         // decimal floating-point-literal (subsumes decimal-literal)
-        { match: `\\b(${f})(\\.(${f}))?([eE][+-]?(${f}))?\\b` },
+        { match: `\\b(${decimalDigits})(\\.(${decimalDigits}))?([eE][+-]?(${decimalDigits}))?\\b` },
         // hexadecimal floating-point-literal (subsumes hexadecimal-literal)
-        { match: `\\b0x(${P})(\\.(${P}))?([pP][+-]?(${f}))?\\b` },
+        { match: `\\b0x(${hexDigits})(\\.(${hexDigits}))?([pP][+-]?(${decimalDigits}))?\\b` },
         // octal-literal
         { match: /\b0o([0-7]_*)+\b/ },
         // binary-literal
         { match: /\b0b([01]_*)+\b/ }
       ]
-    }, L = (n = "") => ({
+    };
+    const ESCAPED_CHARACTER = (rawDelimiter = "") => ({
       className: "subst",
       variants: [
-        { match: e(/\\/, n, /[0\\tnr"']/) },
-        { match: e(/\\/, n, /u\{[0-9a-fA-F]{1,8}\}/) }
+        { match: concat(/\\/, rawDelimiter, /[0\\tnr"']/) },
+        { match: concat(/\\/, rawDelimiter, /u\{[0-9a-fA-F]{1,8}\}/) }
       ]
-    }), ie = (n = "") => ({
+    });
+    const ESCAPED_NEWLINE = (rawDelimiter = "") => ({
       className: "subst",
-      match: e(/\\/, n, /[\t ]*(?:[\r\n]|\r\n)/)
-    }), k = (n = "") => ({
+      match: concat(/\\/, rawDelimiter, /[\t ]*(?:[\r\n]|\r\n)/)
+    });
+    const INTERPOLATION = (rawDelimiter = "") => ({
       className: "subst",
       label: "interpol",
-      begin: e(/\\/, n, /\(/),
+      begin: concat(/\\/, rawDelimiter, /\(/),
       end: /\)/
-    }), b = (n = "") => ({
-      begin: e(n, /"""/),
-      end: e(/"""/, n),
+    });
+    const MULTILINE_STRING = (rawDelimiter = "") => ({
+      begin: concat(rawDelimiter, /"""/),
+      end: concat(/"""/, rawDelimiter),
       contains: [
-        L(n),
-        ie(n),
-        k(n)
+        ESCAPED_CHARACTER(rawDelimiter),
+        ESCAPED_NEWLINE(rawDelimiter),
+        INTERPOLATION(rawDelimiter)
       ]
-    }), A = (n = "") => ({
-      begin: e(n, /"/),
-      end: e(/"/, n),
+    });
+    const SINGLE_LINE_STRING = (rawDelimiter = "") => ({
+      begin: concat(rawDelimiter, /"/),
+      end: concat(/"/, rawDelimiter),
       contains: [
-        L(n),
-        k(n)
+        ESCAPED_CHARACTER(rawDelimiter),
+        INTERPOLATION(rawDelimiter)
       ]
-    }), l = {
+    });
+    const STRING = {
       className: "string",
       variants: [
-        b(),
-        b("#"),
-        b("##"),
-        b("###"),
-        A(),
-        A("#"),
-        A("##"),
-        A("###")
+        MULTILINE_STRING(),
+        MULTILINE_STRING("#"),
+        MULTILINE_STRING("##"),
+        MULTILINE_STRING("###"),
+        SINGLE_LINE_STRING(),
+        SINGLE_LINE_STRING("#"),
+        SINGLE_LINE_STRING("##"),
+        SINGLE_LINE_STRING("###")
       ]
-    }, U = { match: e(/`/, a, /`/) }, ue = {
+    };
+    const QUOTED_IDENTIFIER = { match: concat(/`/, identifier, /`/) };
+    const IMPLICIT_PARAMETER = {
       className: "variable",
       match: /\$\d+/
-    }, re = {
+    };
+    const PROPERTY_WRAPPER_PROJECTION = {
       className: "variable",
-      match: `\\$${m}+`
-    }, R = [
-      U,
-      ue,
-      re
-    ], le = {
+      match: `\\$${identifierCharacter}+`
+    };
+    const IDENTIFIERS = [
+      QUOTED_IDENTIFIER,
+      IMPLICIT_PARAMETER,
+      PROPERTY_WRAPPER_PROJECTION
+    ];
+    const AVAILABLE_ATTRIBUTE = {
       match: /(@|#(un)?)available/,
       className: "keyword",
       starts: { contains: [
         {
           begin: /\(/,
           end: /\)/,
-          keywords: X,
+          keywords: availabilityKeywords,
           contains: [
-            ...E,
-            d,
-            l
+            ...OPERATORS,
+            NUMBER,
+            STRING
           ]
         }
       ] }
-    }, Ee = {
+    };
+    const KEYWORD_ATTRIBUTE = {
       className: "keyword",
-      match: e(/@/, s(...H))
-    }, de = {
+      match: concat(/@/, either(...keywordAttributes))
+    };
+    const USER_DEFINED_ATTRIBUTE = {
       className: "meta",
-      match: e(/@/, a)
-    }, N = [
-      le,
-      Ee,
-      de
-    ], i = {
-      match: p(/\b[A-Z]/),
+      match: concat(/@/, identifier)
+    };
+    const ATTRIBUTES = [
+      AVAILABLE_ATTRIBUTE,
+      KEYWORD_ATTRIBUTE,
+      USER_DEFINED_ATTRIBUTE
+    ];
+    const TYPE = {
+      match: lookahead(/\b[A-Z]/),
       relevance: 0,
       contains: [
         {
           // Common Apple frameworks, for relevance boost
           className: "type",
-          match: e(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/, m, "+")
+          match: concat(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/, identifierCharacter, "+")
         },
         {
           // Type identifier
           className: "type",
-          match: w,
+          match: typeIdentifier,
           relevance: 0
         },
         {
@@ -504,56 +567,60 @@ function ye() {
         },
         {
           // Protocol composition
-          match: e(/\s+&\s+/, p(w)),
+          match: concat(/\s+&\s+/, lookahead(typeIdentifier)),
           relevance: 0
         }
       ]
-    }, pe = {
+    };
+    const GENERIC_ARGUMENTS = {
       begin: /</,
       end: />/,
-      keywords: u,
+      keywords: KEYWORDS,
       contains: [
-        ...c,
-        ...r,
-        ...N,
-        M,
-        i
+        ...COMMENTS,
+        ...KEYWORD_MODES,
+        ...ATTRIBUTES,
+        OPERATOR_GUARD,
+        TYPE
       ]
     };
-    i.contains.push(pe);
-    const me = {
-      match: e(a, /\s*:/),
+    TYPE.contains.push(GENERIC_ARGUMENTS);
+    const TUPLE_ELEMENT_NAME = {
+      match: concat(identifier, /\s*:/),
       keywords: "_|0",
       relevance: 0
-    }, K = {
+    };
+    const TUPLE = {
       begin: /\(/,
       end: /\)/,
       relevance: 0,
-      keywords: u,
+      keywords: KEYWORDS,
       contains: [
         "self",
-        me,
-        ...c,
-        ...r,
-        ...I,
-        ...E,
-        d,
-        l,
-        ...R,
-        ...N,
-        i
+        TUPLE_ELEMENT_NAME,
+        ...COMMENTS,
+        ...KEYWORD_MODES,
+        ...BUILT_INS,
+        ...OPERATORS,
+        NUMBER,
+        STRING,
+        ...IDENTIFIERS,
+        ...ATTRIBUTES,
+        TYPE
       ]
-    }, x = {
+    };
+    const GENERIC_PARAMETERS = {
       begin: /</,
       end: />/,
       contains: [
-        ...c,
-        i
+        ...COMMENTS,
+        TYPE
       ]
-    }, Fe = {
-      begin: s(
-        p(e(a, /\s*:/)),
-        p(e(a, /\s+/, a, /\s*:/))
+    };
+    const FUNCTION_PARAMETER_NAME = {
+      begin: either(
+        lookahead(concat(identifier, /\s*:/)),
+        lookahead(concat(identifier, /\s+/, identifier, /\s*:/))
       ),
       end: /:/,
       relevance: 0,
@@ -564,149 +631,155 @@ function ye() {
         },
         {
           className: "params",
-          match: a
+          match: identifier
         }
       ]
-    }, W = {
+    };
+    const FUNCTION_PARAMETERS = {
       begin: /\(/,
       end: /\)/,
-      keywords: u,
+      keywords: KEYWORDS,
       contains: [
-        Fe,
-        ...c,
-        ...r,
-        ...E,
-        d,
-        l,
-        ...N,
-        i,
-        K
+        FUNCTION_PARAMETER_NAME,
+        ...COMMENTS,
+        ...KEYWORD_MODES,
+        ...OPERATORS,
+        NUMBER,
+        STRING,
+        ...ATTRIBUTES,
+        TYPE,
+        TUPLE
       ],
-      endsParent: !0,
+      endsParent: true,
       illegal: /["']/
-    }, fe = {
+    };
+    const FUNCTION = {
       match: [
         /func/,
         /\s+/,
-        s(U.match, a, T)
+        either(QUOTED_IDENTIFIER.match, identifier, operator)
       ],
       className: {
         1: "keyword",
         3: "title.function"
       },
       contains: [
-        x,
-        W,
-        o
+        GENERIC_PARAMETERS,
+        FUNCTION_PARAMETERS,
+        WHITESPACE
       ],
       illegal: [
         /\[/,
         /%/
       ]
-    }, be = {
+    };
+    const INIT_SUBSCRIPT = {
       match: [
         /\b(?:subscript|init[?!]?)/,
         /\s*(?=[<(])/
       ],
       className: { 1: "keyword" },
       contains: [
-        x,
-        W,
-        o
+        GENERIC_PARAMETERS,
+        FUNCTION_PARAMETERS,
+        WHITESPACE
       ],
       illegal: /\[|%/
-    }, Ae = {
+    };
+    const OPERATOR_DECLARATION = {
       match: [
         /operator/,
         /\s+/,
-        T
+        operator
       ],
       className: {
         1: "keyword",
         3: "title"
       }
-    }, Ne = {
+    };
+    const PRECEDENCEGROUP = {
       begin: [
         /precedencegroup/,
         /\s+/,
-        w
+        typeIdentifier
       ],
       className: {
         1: "keyword",
         3: "title"
       },
-      contains: [i],
+      contains: [TYPE],
       keywords: [
-        ...V,
-        ...S
+        ...precedencegroupKeywords,
+        ...literals
       ],
       end: /}/
     };
-    for (const n of l.variants) {
-      const $ = n.contains.find((he) => he.label === "interpol");
-      $.keywords = u;
-      const G = [
-        ...r,
-        ...I,
-        ...E,
-        d,
-        l,
-        ...R
+    for (const variant of STRING.variants) {
+      const interpolation = variant.contains.find((mode) => mode.label === "interpol");
+      interpolation.keywords = KEYWORDS;
+      const submodes = [
+        ...KEYWORD_MODES,
+        ...BUILT_INS,
+        ...OPERATORS,
+        NUMBER,
+        STRING,
+        ...IDENTIFIERS
       ];
-      $.contains = [
-        ...G,
+      interpolation.contains = [
+        ...submodes,
         {
           begin: /\(/,
           end: /\)/,
           contains: [
             "self",
-            ...G
+            ...submodes
           ]
         }
       ];
     }
     return {
       name: "Swift",
-      keywords: u,
+      keywords: KEYWORDS,
       contains: [
-        ...c,
-        fe,
-        be,
+        ...COMMENTS,
+        FUNCTION,
+        INIT_SUBSCRIPT,
         {
           beginKeywords: "struct protocol class extension enum actor",
           end: "\\{",
-          excludeEnd: !0,
-          keywords: u,
+          excludeEnd: true,
+          keywords: KEYWORDS,
           contains: [
-            t.inherit(t.TITLE_MODE, {
+            hljs.inherit(hljs.TITLE_MODE, {
               className: "title.class",
               begin: /[A-Za-z$_][\u00C0-\u02B80-9A-Za-z$_]*/
             }),
-            ...r
+            ...KEYWORD_MODES
           ]
         },
-        Ae,
-        Ne,
+        OPERATOR_DECLARATION,
+        PRECEDENCEGROUP,
         {
           beginKeywords: "import",
           end: /$/,
-          contains: [...c],
+          contains: [...COMMENTS],
           relevance: 0
         },
-        ...r,
-        ...I,
-        ...E,
-        d,
-        l,
-        ...R,
-        ...N,
-        i,
-        K
+        ...KEYWORD_MODES,
+        ...BUILT_INS,
+        ...OPERATORS,
+        NUMBER,
+        STRING,
+        ...IDENTIFIERS,
+        ...ATTRIBUTES,
+        TYPE,
+        TUPLE
       ]
     };
   }
-  return _ = J, _;
+  swift_1 = swift;
+  return swift_1;
 }
 export {
-  ye as __require
+  requireSwift as __require
 };