@fangzhongya/vue-archive 0.0.2 → 0.0.3-2

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

@@ -1,785 +0,0 @@
-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 lookahead(re) {
-    return concat("(?=", re, ")");
-  }
-  function concat(...args) {
-    const joined = args.map((x) => source(x)).join("");
-    return joined;
-  }
-  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 either(...args) {
-    const opts = stripOptionsFromArgs(args);
-    const joined = "(" + (opts.capture ? "" : "?:") + args.map((x) => source(x)).join("|") + ")";
-    return joined;
-  }
-  const keywordWrapper = (keyword) => concat(
-    /\b/,
-    keyword,
-    /\w$/.test(keyword) ? /\b/ : /\B/
-  );
-  const dotKeywords = [
-    "Protocol",
-    // contextual
-    "Type"
-    // contextual
-  ].map(keywordWrapper);
-  const optionalDotKeywords = [
-    "init",
-    "self"
-  ].map(keywordWrapper);
-  const keywordTypes = [
-    "Any",
-    "Self"
-  ];
-  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
-    "actor",
-    "any",
-    // contextual
-    "associatedtype",
-    "async",
-    "await",
-    /as\?/,
-    // operator
-    /as!/,
-    // operator
-    "as",
-    // operator
-    "break",
-    "case",
-    "catch",
-    "class",
-    "continue",
-    "convenience",
-    // contextual
-    "default",
-    "defer",
-    "deinit",
-    "didSet",
-    // contextual
-    "distributed",
-    "do",
-    "dynamic",
-    // contextual
-    "else",
-    "enum",
-    "extension",
-    "fallthrough",
-    /fileprivate\(set\)/,
-    "fileprivate",
-    "final",
-    // contextual
-    "for",
-    "func",
-    "get",
-    // contextual
-    "guard",
-    "if",
-    "import",
-    "indirect",
-    // contextual
-    "infix",
-    // contextual
-    /init\?/,
-    /init!/,
-    "inout",
-    /internal\(set\)/,
-    "internal",
-    "in",
-    "is",
-    // operator
-    "isolated",
-    // contextual
-    "nonisolated",
-    // contextual
-    "lazy",
-    // contextual
-    "let",
-    "mutating",
-    // contextual
-    "nonmutating",
-    // contextual
-    /open\(set\)/,
-    // contextual
-    "open",
-    // contextual
-    "operator",
-    "optional",
-    // contextual
-    "override",
-    // contextual
-    "postfix",
-    // contextual
-    "precedencegroup",
-    "prefix",
-    // contextual
-    /private\(set\)/,
-    "private",
-    "protocol",
-    /public\(set\)/,
-    "public",
-    "repeat",
-    "required",
-    // contextual
-    "rethrows",
-    "return",
-    "set",
-    // contextual
-    "some",
-    // contextual
-    "static",
-    "struct",
-    "subscript",
-    "super",
-    "switch",
-    "throws",
-    "throw",
-    /try\?/,
-    // operator
-    /try!/,
-    // operator
-    "try",
-    // operator
-    "typealias",
-    /unowned\(safe\)/,
-    // contextual
-    /unowned\(unsafe\)/,
-    // contextual
-    "unowned",
-    // contextual
-    "var",
-    "weak",
-    // contextual
-    "where",
-    "while",
-    "willSet"
-    // contextual
-  ];
-  const literals = [
-    "false",
-    "nil",
-    "true"
-  ];
-  const precedencegroupKeywords = [
-    "assignment",
-    "associativity",
-    "higherThan",
-    "left",
-    "lowerThan",
-    "none",
-    "right"
-  ];
-  const numberSignKeywords = [
-    "#colorLiteral",
-    "#column",
-    "#dsohandle",
-    "#else",
-    "#elseif",
-    "#endif",
-    "#error",
-    "#file",
-    "#fileID",
-    "#fileLiteral",
-    "#filePath",
-    "#function",
-    "#if",
-    "#imageLiteral",
-    "#keyPath",
-    "#line",
-    "#selector",
-    "#sourceLocation",
-    "#warn_unqualified_access",
-    "#warning"
-  ];
-  const builtIns = [
-    "abs",
-    "all",
-    "any",
-    "assert",
-    "assertionFailure",
-    "debugPrint",
-    "dump",
-    "fatalError",
-    "getVaList",
-    "isKnownUniquelyReferenced",
-    "max",
-    "min",
-    "numericCast",
-    "pointwiseMax",
-    "pointwiseMin",
-    "precondition",
-    "preconditionFailure",
-    "print",
-    "readLine",
-    "repeatElement",
-    "sequence",
-    "stride",
-    "swap",
-    "swift_unboxFromSwiftValueWithType",
-    "transcode",
-    "type",
-    "unsafeBitCast",
-    "unsafeDowncast",
-    "withExtendedLifetime",
-    "withUnsafeMutablePointer",
-    "withUnsafePointer",
-    "withVaList",
-    "withoutActuallyEscaping",
-    "zip"
-  ];
-  const operatorHead = either(
-    /[/=\-+!*%<>&|^~?]/,
-    /[\u00A1-\u00A7]/,
-    /[\u00A9\u00AB]/,
-    /[\u00AC\u00AE]/,
-    /[\u00B0\u00B1]/,
-    /[\u00B6\u00BB\u00BF\u00D7\u00F7]/,
-    /[\u2016-\u2017]/,
-    /[\u2020-\u2027]/,
-    /[\u2030-\u203E]/,
-    /[\u2041-\u2053]/,
-    /[\u2055-\u205E]/,
-    /[\u2190-\u23FF]/,
-    /[\u2500-\u2775]/,
-    /[\u2794-\u2BFF]/,
-    /[\u2E00-\u2E7F]/,
-    /[\u3001-\u3003]/,
-    /[\u3008-\u3020]/,
-    /[\u3030]/
-  );
-  const operatorCharacter = either(
-    operatorHead,
-    /[\u0300-\u036F]/,
-    /[\u1DC0-\u1DFF]/,
-    /[\u20D0-\u20FF]/,
-    /[\uFE00-\uFE0F]/,
-    /[\uFE20-\uFE2F]/
-    // TODO: The following characters are also allowed, but the regex isn't supported yet.
-    // /[\u{E0100}-\u{E01EF}]/u
-  );
-  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]/,
-    /[\u0100-\u02FF\u0370-\u167F\u1681-\u180D\u180F-\u1DBF]/,
-    /[\u1E00-\u1FFF]/,
-    /[\u200B-\u200D\u202A-\u202E\u203F-\u2040\u2054\u2060-\u206F]/,
-    /[\u2070-\u20CF\u2100-\u218F\u2460-\u24FF\u2776-\u2793]/,
-    /[\u2C00-\u2DFF\u2E80-\u2FFF]/,
-    /[\u3004-\u3007\u3021-\u302F\u3031-\u303F\u3040-\uD7FF]/,
-    /[\uF900-\uFD3D\uFD40-\uFDCF\uFDF0-\uFE1F\uFE30-\uFE44]/,
-    /[\uFE47-\uFEFE\uFF00-\uFFFD]/
-    // Should be /[\uFE47-\uFFFD]/, but we have to exclude FEFF.
-    // The following characters are also allowed, but the regexes aren't supported yet.
-    // /[\u{10000}-\u{1FFFD}\u{20000-\u{2FFFD}\u{30000}-\u{3FFFD}\u{40000}-\u{4FFFD}]/u,
-    // /[\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
-  );
-  const identifierCharacter = either(
-    identifierHead,
-    /\d/,
-    /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/
-  );
-  const identifier = concat(identifierHead, identifierCharacter, "*");
-  const typeIdentifier = concat(/[A-Z]/, identifierCharacter, "*");
-  const keywordAttributes = [
-    "autoclosure",
-    concat(/convention\(/, either("swift", "block", "c"), /\)/),
-    "discardableResult",
-    "dynamicCallable",
-    "dynamicMemberLookup",
-    "escaping",
-    "frozen",
-    "GKInspectable",
-    "IBAction",
-    "IBDesignable",
-    "IBInspectable",
-    "IBOutlet",
-    "IBSegueAction",
-    "inlinable",
-    "main",
-    "nonobjc",
-    "NSApplicationMain",
-    "NSCopying",
-    "NSManaged",
-    concat(/objc\(/, identifier, /\)/),
-    "objc",
-    "objcMembers",
-    "propertyWrapper",
-    "requires_stored_property_inits",
-    "resultBuilder",
-    "testable",
-    "UIApplicationMain",
-    "unknown",
-    "usableFromInline"
-  ];
-  const availabilityKeywords = [
-    "iOS",
-    "iOSApplicationExtension",
-    "macOS",
-    "macOSApplicationExtension",
-    "macCatalyst",
-    "macCatalystApplicationExtension",
-    "watchOS",
-    "watchOSApplicationExtension",
-    "tvOS",
-    "tvOSApplicationExtension",
-    "swift"
-  ];
-  function swift(hljs) {
-    const WHITESPACE = {
-      match: /\s+/,
-      relevance: 0
-    };
-    const BLOCK_COMMENT = hljs.COMMENT(
-      "/\\*",
-      "\\*/",
-      { contains: ["self"] }
-    );
-    const COMMENTS = [
-      hljs.C_LINE_COMMENT_MODE,
-      BLOCK_COMMENT
-    ];
-    const DOT_KEYWORD = {
-      match: [
-        /\./,
-        either(...dotKeywords, ...optionalDotKeywords)
-      ],
-      className: { 2: "keyword" }
-    };
-    const KEYWORD_GUARD = {
-      // Consume .keyword to prevent highlighting properties and methods as keywords.
-      match: concat(/\./, either(...keywords)),
-      relevance: 0
-    };
-    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: either(...REGEX_KEYWORDS, ...optionalDotKeywords)
-      }
-    ] };
-    const KEYWORDS = {
-      $pattern: either(
-        /\b\w+/,
-        // regular keywords
-        /#\w+/
-        // number keywords
-      ),
-      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: concat(/\./, either(...builtIns)),
-      relevance: 0
-    };
-    const BUILT_IN = {
-      className: "built_in",
-      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
-    };
-    const OPERATOR = {
-      className: "operator",
-      relevance: 0,
-      variants: [
-        { 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: `\\.(\\.|${operatorCharacter})+`
-        }
-      ]
-    };
-    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(${decimalDigits})(\\.(${decimalDigits}))?([eE][+-]?(${decimalDigits}))?\\b` },
-        // hexadecimal floating-point-literal (subsumes hexadecimal-literal)
-        { match: `\\b0x(${hexDigits})(\\.(${hexDigits}))?([pP][+-]?(${decimalDigits}))?\\b` },
-        // octal-literal
-        { match: /\b0o([0-7]_*)+\b/ },
-        // binary-literal
-        { match: /\b0b([01]_*)+\b/ }
-      ]
-    };
-    const ESCAPED_CHARACTER = (rawDelimiter = "") => ({
-      className: "subst",
-      variants: [
-        { match: concat(/\\/, rawDelimiter, /[0\\tnr"']/) },
-        { match: concat(/\\/, rawDelimiter, /u\{[0-9a-fA-F]{1,8}\}/) }
-      ]
-    });
-    const ESCAPED_NEWLINE = (rawDelimiter = "") => ({
-      className: "subst",
-      match: concat(/\\/, rawDelimiter, /[\t ]*(?:[\r\n]|\r\n)/)
-    });
-    const INTERPOLATION = (rawDelimiter = "") => ({
-      className: "subst",
-      label: "interpol",
-      begin: concat(/\\/, rawDelimiter, /\(/),
-      end: /\)/
-    });
-    const MULTILINE_STRING = (rawDelimiter = "") => ({
-      begin: concat(rawDelimiter, /"""/),
-      end: concat(/"""/, rawDelimiter),
-      contains: [
-        ESCAPED_CHARACTER(rawDelimiter),
-        ESCAPED_NEWLINE(rawDelimiter),
-        INTERPOLATION(rawDelimiter)
-      ]
-    });
-    const SINGLE_LINE_STRING = (rawDelimiter = "") => ({
-      begin: concat(rawDelimiter, /"/),
-      end: concat(/"/, rawDelimiter),
-      contains: [
-        ESCAPED_CHARACTER(rawDelimiter),
-        INTERPOLATION(rawDelimiter)
-      ]
-    });
-    const STRING = {
-      className: "string",
-      variants: [
-        MULTILINE_STRING(),
-        MULTILINE_STRING("#"),
-        MULTILINE_STRING("##"),
-        MULTILINE_STRING("###"),
-        SINGLE_LINE_STRING(),
-        SINGLE_LINE_STRING("#"),
-        SINGLE_LINE_STRING("##"),
-        SINGLE_LINE_STRING("###")
-      ]
-    };
-    const QUOTED_IDENTIFIER = { match: concat(/`/, identifier, /`/) };
-    const IMPLICIT_PARAMETER = {
-      className: "variable",
-      match: /\$\d+/
-    };
-    const PROPERTY_WRAPPER_PROJECTION = {
-      className: "variable",
-      match: `\\$${identifierCharacter}+`
-    };
-    const IDENTIFIERS = [
-      QUOTED_IDENTIFIER,
-      IMPLICIT_PARAMETER,
-      PROPERTY_WRAPPER_PROJECTION
-    ];
-    const AVAILABLE_ATTRIBUTE = {
-      match: /(@|#(un)?)available/,
-      className: "keyword",
-      starts: { contains: [
-        {
-          begin: /\(/,
-          end: /\)/,
-          keywords: availabilityKeywords,
-          contains: [
-            ...OPERATORS,
-            NUMBER,
-            STRING
-          ]
-        }
-      ] }
-    };
-    const KEYWORD_ATTRIBUTE = {
-      className: "keyword",
-      match: concat(/@/, either(...keywordAttributes))
-    };
-    const USER_DEFINED_ATTRIBUTE = {
-      className: "meta",
-      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: 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: typeIdentifier,
-          relevance: 0
-        },
-        {
-          // Optional type
-          match: /[?!]+/,
-          relevance: 0
-        },
-        {
-          // Variadic parameter
-          match: /\.\.\./,
-          relevance: 0
-        },
-        {
-          // Protocol composition
-          match: concat(/\s+&\s+/, lookahead(typeIdentifier)),
-          relevance: 0
-        }
-      ]
-    };
-    const GENERIC_ARGUMENTS = {
-      begin: /</,
-      end: />/,
-      keywords: KEYWORDS,
-      contains: [
-        ...COMMENTS,
-        ...KEYWORD_MODES,
-        ...ATTRIBUTES,
-        OPERATOR_GUARD,
-        TYPE
-      ]
-    };
-    TYPE.contains.push(GENERIC_ARGUMENTS);
-    const TUPLE_ELEMENT_NAME = {
-      match: concat(identifier, /\s*:/),
-      keywords: "_|0",
-      relevance: 0
-    };
-    const TUPLE = {
-      begin: /\(/,
-      end: /\)/,
-      relevance: 0,
-      keywords: KEYWORDS,
-      contains: [
-        "self",
-        TUPLE_ELEMENT_NAME,
-        ...COMMENTS,
-        ...KEYWORD_MODES,
-        ...BUILT_INS,
-        ...OPERATORS,
-        NUMBER,
-        STRING,
-        ...IDENTIFIERS,
-        ...ATTRIBUTES,
-        TYPE
-      ]
-    };
-    const GENERIC_PARAMETERS = {
-      begin: /</,
-      end: />/,
-      contains: [
-        ...COMMENTS,
-        TYPE
-      ]
-    };
-    const FUNCTION_PARAMETER_NAME = {
-      begin: either(
-        lookahead(concat(identifier, /\s*:/)),
-        lookahead(concat(identifier, /\s+/, identifier, /\s*:/))
-      ),
-      end: /:/,
-      relevance: 0,
-      contains: [
-        {
-          className: "keyword",
-          match: /\b_\b/
-        },
-        {
-          className: "params",
-          match: identifier
-        }
-      ]
-    };
-    const FUNCTION_PARAMETERS = {
-      begin: /\(/,
-      end: /\)/,
-      keywords: KEYWORDS,
-      contains: [
-        FUNCTION_PARAMETER_NAME,
-        ...COMMENTS,
-        ...KEYWORD_MODES,
-        ...OPERATORS,
-        NUMBER,
-        STRING,
-        ...ATTRIBUTES,
-        TYPE,
-        TUPLE
-      ],
-      endsParent: true,
-      illegal: /["']/
-    };
-    const FUNCTION = {
-      match: [
-        /func/,
-        /\s+/,
-        either(QUOTED_IDENTIFIER.match, identifier, operator)
-      ],
-      className: {
-        1: "keyword",
-        3: "title.function"
-      },
-      contains: [
-        GENERIC_PARAMETERS,
-        FUNCTION_PARAMETERS,
-        WHITESPACE
-      ],
-      illegal: [
-        /\[/,
-        /%/
-      ]
-    };
-    const INIT_SUBSCRIPT = {
-      match: [
-        /\b(?:subscript|init[?!]?)/,
-        /\s*(?=[<(])/
-      ],
-      className: { 1: "keyword" },
-      contains: [
-        GENERIC_PARAMETERS,
-        FUNCTION_PARAMETERS,
-        WHITESPACE
-      ],
-      illegal: /\[|%/
-    };
-    const OPERATOR_DECLARATION = {
-      match: [
-        /operator/,
-        /\s+/,
-        operator
-      ],
-      className: {
-        1: "keyword",
-        3: "title"
-      }
-    };
-    const PRECEDENCEGROUP = {
-      begin: [
-        /precedencegroup/,
-        /\s+/,
-        typeIdentifier
-      ],
-      className: {
-        1: "keyword",
-        3: "title"
-      },
-      contains: [TYPE],
-      keywords: [
-        ...precedencegroupKeywords,
-        ...literals
-      ],
-      end: /}/
-    };
-    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
-      ];
-      interpolation.contains = [
-        ...submodes,
-        {
-          begin: /\(/,
-          end: /\)/,
-          contains: [
-            "self",
-            ...submodes
-          ]
-        }
-      ];
-    }
-    return {
-      name: "Swift",
-      keywords: KEYWORDS,
-      contains: [
-        ...COMMENTS,
-        FUNCTION,
-        INIT_SUBSCRIPT,
-        {
-          beginKeywords: "struct protocol class extension enum actor",
-          end: "\\{",
-          excludeEnd: true,
-          keywords: KEYWORDS,
-          contains: [
-            hljs.inherit(hljs.TITLE_MODE, {
-              className: "title.class",
-              begin: /[A-Za-z$_][\u00C0-\u02B80-9A-Za-z$_]*/
-            }),
-            ...KEYWORD_MODES
-          ]
-        },
-        OPERATOR_DECLARATION,
-        PRECEDENCEGROUP,
-        {
-          beginKeywords: "import",
-          end: /$/,
-          contains: [...COMMENTS],
-          relevance: 0
-        },
-        ...KEYWORD_MODES,
-        ...BUILT_INS,
-        ...OPERATORS,
-        NUMBER,
-        STRING,
-        ...IDENTIFIERS,
-        ...ATTRIBUTES,
-        TYPE,
-        TUPLE
-      ]
-    };
-  }
-  swift_1 = swift;
-  return swift_1;
-}
-export {
-  requireSwift as __require
-};