@fangzhongya/vue-archive 0.1.21 → 0.1.23

package/dist/node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/lib/languages/typescript.js

@@ -0,0 +1,759 @@
+var C, F;
+function V() {
+  if (F) return C;
+  F = 1;
+  const N = "[A-Za-z$_][0-9A-Za-z$_]*", M = [
+    "as",
+    // for exports
+    "in",
+    "of",
+    "if",
+    "for",
+    "while",
+    "finally",
+    "var",
+    "new",
+    "function",
+    "do",
+    "return",
+    "void",
+    "else",
+    "break",
+    "catch",
+    "instanceof",
+    "with",
+    "throw",
+    "case",
+    "default",
+    "try",
+    "switch",
+    "continue",
+    "typeof",
+    "delete",
+    "let",
+    "yield",
+    "const",
+    "class",
+    // JS handles these with a special rule
+    // "get",
+    // "set",
+    "debugger",
+    "async",
+    "await",
+    "static",
+    "import",
+    "from",
+    "export",
+    "extends",
+    // It's reached stage 3, which is "recommended for implementation":
+    "using"
+  ], v = [
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "NaN",
+    "Infinity"
+  ], w = [
+    // Fundamental objects
+    "Object",
+    "Function",
+    "Boolean",
+    "Symbol",
+    // numbers and dates
+    "Math",
+    "Date",
+    "Number",
+    "BigInt",
+    // text
+    "String",
+    "RegExp",
+    // Indexed collections
+    "Array",
+    "Float32Array",
+    "Float64Array",
+    "Int8Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int16Array",
+    "Int32Array",
+    "Uint16Array",
+    "Uint32Array",
+    "BigInt64Array",
+    "BigUint64Array",
+    // Keyed collections
+    "Set",
+    "Map",
+    "WeakSet",
+    "WeakMap",
+    // Structured data
+    "ArrayBuffer",
+    "SharedArrayBuffer",
+    "Atomics",
+    "DataView",
+    "JSON",
+    // Control abstraction objects
+    "Promise",
+    "Generator",
+    "GeneratorFunction",
+    "AsyncFunction",
+    // Reflection
+    "Reflect",
+    "Proxy",
+    // Internationalization
+    "Intl",
+    // WebAssembly
+    "WebAssembly"
+  ], L = [
+    "Error",
+    "EvalError",
+    "InternalError",
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+    "TypeError",
+    "URIError"
+  ], x = [
+    "setInterval",
+    "setTimeout",
+    "clearInterval",
+    "clearTimeout",
+    "require",
+    "exports",
+    "eval",
+    "isFinite",
+    "isNaN",
+    "parseFloat",
+    "parseInt",
+    "decodeURI",
+    "decodeURIComponent",
+    "encodeURI",
+    "encodeURIComponent",
+    "escape",
+    "unescape"
+  ], k = [
+    "arguments",
+    "this",
+    "super",
+    "console",
+    "window",
+    "document",
+    "localStorage",
+    "sessionStorage",
+    "module",
+    "global"
+    // Node.js
+  ], D = [].concat(
+    x,
+    w,
+    L
+  );
+  function G(e) {
+    const a = e.regex, t = (s, { after: d }) => {
+      const S = "</" + s[0].slice(1);
+      return s.input.indexOf(S, d) !== -1;
+    }, n = N, u = {
+      begin: "<>",
+      end: "</>"
+    }, y = /<[A-Za-z0-9\\._:-]+\s*\/>/, i = {
+      begin: /<[A-Za-z0-9\\._:-]+/,
+      end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+      /**
+       * @param {RegExpMatchArray} match
+       * @param {CallbackResponse} response
+       */
+      isTrulyOpeningTag: (s, d) => {
+        const S = s[0].length + s.index, p = s.input[S];
+        if (
+          // HTML should not include another raw `<` inside a tag
+          // nested type?
+          // `<Array<Array<number>>`, etc.
+          p === "<" || // the , gives away that this is not HTML
+          // `<T, A extends keyof T, V>`
+          p === ","
+        ) {
+          d.ignoreMatch();
+          return;
+        }
+        p === ">" && (t(s, { after: S }) || d.ignoreMatch());
+        let O;
+        const $ = s.input.substring(S);
+        if (O = $.match(/^\s*=/)) {
+          d.ignoreMatch();
+          return;
+        }
+        if ((O = $.match(/^\s+extends\s+/)) && O.index === 0) {
+          d.ignoreMatch();
+          return;
+        }
+      }
+    }, o = {
+      $pattern: N,
+      keyword: M,
+      literal: v,
+      built_in: D,
+      "variable.language": k
+    }, T = "[0-9](_?[0-9])*", l = `\\.(${T})`, b = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", g = {
+      className: "number",
+      variants: [
+        // DecimalLiteral
+        { begin: `(\\b(${b})((${l})|\\.)?|(${l}))[eE][+-]?(${T})\\b` },
+        { begin: `\\b(${b})\\b((${l})\\b|\\.)?|(${l})\\b` },
+        // DecimalBigIntegerLiteral
+        { begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
+        // NonDecimalIntegerLiteral
+        { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+        { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+        { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+        // LegacyOctalIntegerLiteral (does not include underscore separators)
+        // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+        { begin: "\\b0[0-7]+n?\\b" }
+      ],
+      relevance: 0
+    }, c = {
+      className: "subst",
+      begin: "\\$\\{",
+      end: "\\}",
+      keywords: o,
+      contains: []
+      // defined later
+    }, _ = {
+      begin: ".?html`",
+      end: "",
+      starts: {
+        end: "`",
+        returnEnd: !1,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          c
+        ],
+        subLanguage: "xml"
+      }
+    }, m = {
+      begin: ".?css`",
+      end: "",
+      starts: {
+        end: "`",
+        returnEnd: !1,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          c
+        ],
+        subLanguage: "css"
+      }
+    }, r = {
+      begin: ".?gql`",
+      end: "",
+      starts: {
+        end: "`",
+        returnEnd: !1,
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          c
+        ],
+        subLanguage: "graphql"
+      }
+    }, R = {
+      className: "string",
+      begin: "`",
+      end: "`",
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        c
+      ]
+    }, E = {
+      className: "comment",
+      variants: [
+        e.COMMENT(
+          /\/\*\*(?!\/)/,
+          "\\*/",
+          {
+            relevance: 0,
+            contains: [
+              {
+                begin: "(?=@[A-Za-z]+)",
+                relevance: 0,
+                contains: [
+                  {
+                    className: "doctag",
+                    begin: "@[A-Za-z]+"
+                  },
+                  {
+                    className: "type",
+                    begin: "\\{",
+                    end: "\\}",
+                    excludeEnd: !0,
+                    excludeBegin: !0,
+                    relevance: 0
+                  },
+                  {
+                    className: "variable",
+                    begin: n + "(?=\\s*(-)|$)",
+                    endsParent: !0,
+                    relevance: 0
+                  },
+                  // eat spaces (not newlines) so we can find
+                  // types or variables
+                  {
+                    begin: /(?=[^\n])\s/,
+                    relevance: 0
+                  }
+                ]
+              }
+            ]
+          }
+        ),
+        e.C_BLOCK_COMMENT_MODE,
+        e.C_LINE_COMMENT_MODE
+      ]
+    }, f = [
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE,
+      _,
+      m,
+      r,
+      R,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      g
+      // This is intentional:
+      // See https://github.com/highlightjs/highlight.js/issues/3288
+      // hljs.REGEXP_MODE
+    ];
+    c.contains = f.concat({
+      // we need to pair up {} inside our subst to prevent
+      // it from ending too early by matching another }
+      begin: /\{/,
+      end: /\}/,
+      keywords: o,
+      contains: [
+        "self"
+      ].concat(f)
+    });
+    const B = [].concat(E, c.contains), I = B.concat([
+      // eat recursive parens in sub expressions
+      {
+        begin: /(\s*)\(/,
+        end: /\)/,
+        keywords: o,
+        contains: ["self"].concat(B)
+      }
+    ]), A = {
+      className: "params",
+      // convert this to negative lookbehind in v12
+      begin: /(\s*)\(/,
+      // to match the parms with
+      end: /\)/,
+      excludeBegin: !0,
+      excludeEnd: !0,
+      keywords: o,
+      contains: I
+    }, z = {
+      variants: [
+        // class Car extends vehicle
+        {
+          match: [
+            /class/,
+            /\s+/,
+            n,
+            /\s+/,
+            /extends/,
+            /\s+/,
+            a.concat(n, "(", a.concat(/\./, n), ")*")
+          ],
+          scope: {
+            1: "keyword",
+            3: "title.class",
+            5: "keyword",
+            7: "title.class.inherited"
+          }
+        },
+        // class Car
+        {
+          match: [
+            /class/,
+            /\s+/,
+            n
+          ],
+          scope: {
+            1: "keyword",
+            3: "title.class"
+          }
+        }
+      ]
+    }, U = {
+      relevance: 0,
+      match: a.either(
+        // Hard coded exceptions
+        /\bJSON/,
+        // Float32Array, OutT
+        /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,
+        // CSSFactory, CSSFactoryT
+        /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,
+        // FPs, FPsT
+        /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/
+        // P
+        // single letters are not highlighted
+        // BLAH
+        // this will be flagged as a UPPER_CASE_CONSTANT instead
+      ),
+      className: "title.class",
+      keywords: {
+        _: [
+          // se we still get relevance credit for JS library classes
+          ...w,
+          ...L
+        ]
+      }
+    }, K = {
+      label: "use_strict",
+      className: "meta",
+      relevance: 10,
+      begin: /^\s*['"]use (strict|asm)['"]/
+    }, H = {
+      variants: [
+        {
+          match: [
+            /function/,
+            /\s+/,
+            n,
+            /(?=\s*\()/
+          ]
+        },
+        // anonymous function
+        {
+          match: [
+            /function/,
+            /\s*(?=\()/
+          ]
+        }
+      ],
+      className: {
+        1: "keyword",
+        3: "title.function"
+      },
+      label: "func.def",
+      contains: [A],
+      illegal: /%/
+    }, Y = {
+      relevance: 0,
+      match: /\b[A-Z][A-Z_0-9]+\b/,
+      className: "variable.constant"
+    };
+    function W(s) {
+      return a.concat("(?!", s.join("|"), ")");
+    }
+    const q = {
+      match: a.concat(
+        /\b/,
+        W([
+          ...x,
+          "super",
+          "import"
+        ].map((s) => `${s}\\s*\\(`)),
+        n,
+        a.lookahead(/\s*\(/)
+      ),
+      className: "title.function",
+      relevance: 0
+    }, J = {
+      begin: a.concat(/\./, a.lookahead(
+        a.concat(n, /(?![0-9A-Za-z$_(])/)
+      )),
+      end: n,
+      excludeBegin: !0,
+      keywords: "prototype",
+      className: "property",
+      relevance: 0
+    }, X = {
+      match: [
+        /get|set/,
+        /\s+/,
+        n,
+        /(?=\()/
+      ],
+      className: {
+        1: "keyword",
+        3: "title.function"
+      },
+      contains: [
+        {
+          // eat to avoid empty params
+          begin: /\(\)/
+        },
+        A
+      ]
+    }, P = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>", Q = {
+      match: [
+        /const|var|let/,
+        /\s+/,
+        n,
+        /\s*/,
+        /=\s*/,
+        /(async\s*)?/,
+        // async is optional
+        a.lookahead(P)
+      ],
+      keywords: "async",
+      className: {
+        1: "keyword",
+        3: "title.function"
+      },
+      contains: [
+        A
+      ]
+    };
+    return {
+      name: "JavaScript",
+      aliases: ["js", "jsx", "mjs", "cjs"],
+      keywords: o,
+      // this will be extended by TypeScript
+      exports: { PARAMS_CONTAINS: I, CLASS_REFERENCE: U },
+      illegal: /#(?![$_A-z])/,
+      contains: [
+        e.SHEBANG({
+          label: "shebang",
+          binary: "node",
+          relevance: 5
+        }),
+        K,
+        e.APOS_STRING_MODE,
+        e.QUOTE_STRING_MODE,
+        _,
+        m,
+        r,
+        R,
+        E,
+        // Skip numbers when they are part of a variable name
+        { match: /\$\d+/ },
+        g,
+        U,
+        {
+          scope: "attr",
+          match: n + a.lookahead(":"),
+          relevance: 0
+        },
+        Q,
+        {
+          // "value" container
+          begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+          keywords: "return throw case",
+          relevance: 0,
+          contains: [
+            E,
+            e.REGEXP_MODE,
+            {
+              className: "function",
+              // we have to count the parens to make sure we actually have the
+              // correct bounding ( ) before the =>.  There could be any number of
+              // sub-expressions inside also surrounded by parens.
+              begin: P,
+              returnBegin: !0,
+              end: "\\s*=>",
+              contains: [
+                {
+                  className: "params",
+                  variants: [
+                    {
+                      begin: e.UNDERSCORE_IDENT_RE,
+                      relevance: 0
+                    },
+                    {
+                      className: null,
+                      begin: /\(\s*\)/,
+                      skip: !0
+                    },
+                    {
+                      begin: /(\s*)\(/,
+                      end: /\)/,
+                      excludeBegin: !0,
+                      excludeEnd: !0,
+                      keywords: o,
+                      contains: I
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              // could be a comma delimited list of params to a function call
+              begin: /,/,
+              relevance: 0
+            },
+            {
+              match: /\s+/,
+              relevance: 0
+            },
+            {
+              // JSX
+              variants: [
+                { begin: u.begin, end: u.end },
+                { match: y },
+                {
+                  begin: i.begin,
+                  // we carefully check the opening tag to see if it truly
+                  // is a tag and not a false positive
+                  "on:begin": i.isTrulyOpeningTag,
+                  end: i.end
+                }
+              ],
+              subLanguage: "xml",
+              contains: [
+                {
+                  begin: i.begin,
+                  end: i.end,
+                  skip: !0,
+                  contains: ["self"]
+                }
+              ]
+            }
+          ]
+        },
+        H,
+        {
+          // prevent this from getting swallowed up by function
+          // since they appear "function like"
+          beginKeywords: "while if switch catch for"
+        },
+        {
+          // we have to count the parens to make sure we actually have the correct
+          // bounding ( ).  There could be any number of sub-expressions inside
+          // also surrounded by parens.
+          begin: "\\b(?!function)" + e.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+          // end parens
+          returnBegin: !0,
+          label: "func.def",
+          contains: [
+            A,
+            e.inherit(e.TITLE_MODE, { begin: n, className: "title.function" })
+          ]
+        },
+        // catch ... so it won't trigger the property rule below
+        {
+          match: /\.\.\./,
+          relevance: 0
+        },
+        J,
+        // hack: prevents detection of keywords in some circumstances
+        // .keyword()
+        // $keyword = x
+        {
+          match: "\\$" + n,
+          relevance: 0
+        },
+        {
+          match: [/\bconstructor(?=\s*\()/],
+          className: { 1: "title.function" },
+          contains: [A]
+        },
+        q,
+        Y,
+        z,
+        X,
+        {
+          match: /\$[(.]/
+          // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+        }
+      ]
+    };
+  }
+  function Z(e) {
+    const a = e.regex, t = G(e), n = N, u = [
+      "any",
+      "void",
+      "number",
+      "boolean",
+      "string",
+      "object",
+      "never",
+      "symbol",
+      "bigint",
+      "unknown"
+    ], y = {
+      begin: [
+        /namespace/,
+        /\s+/,
+        e.IDENT_RE
+      ],
+      beginScope: {
+        1: "keyword",
+        3: "title.class"
+      }
+    }, i = {
+      beginKeywords: "interface",
+      end: /\{/,
+      excludeEnd: !0,
+      keywords: {
+        keyword: "interface extends",
+        built_in: u
+      },
+      contains: [t.exports.CLASS_REFERENCE]
+    }, o = {
+      className: "meta",
+      relevance: 10,
+      begin: /^\s*['"]use strict['"]/
+    }, T = [
+      "type",
+      // "namespace",
+      "interface",
+      "public",
+      "private",
+      "protected",
+      "implements",
+      "declare",
+      "abstract",
+      "readonly",
+      "enum",
+      "override",
+      "satisfies"
+    ], l = {
+      $pattern: N,
+      keyword: M.concat(T),
+      literal: v,
+      built_in: D.concat(u),
+      "variable.language": k
+    }, b = {
+      className: "meta",
+      begin: "@" + n
+    }, g = (r, R, h) => {
+      const E = r.contains.findIndex((f) => f.label === R);
+      if (E === -1)
+        throw new Error("can not find mode to replace");
+      r.contains.splice(E, 1, h);
+    };
+    Object.assign(t.keywords, l), t.exports.PARAMS_CONTAINS.push(b);
+    const c = t.contains.find((r) => r.scope === "attr"), _ = Object.assign(
+      {},
+      c,
+      { match: a.concat(n, a.lookahead(/\s*\?:/)) }
+    );
+    t.exports.PARAMS_CONTAINS.push([
+      t.exports.CLASS_REFERENCE,
+      // class reference for highlighting the params types
+      c,
+      // highlight the params key
+      _
+      // Added for optional property assignment highlighting
+    ]), t.contains = t.contains.concat([
+      b,
+      y,
+      i,
+      _
+      // Added for optional property assignment highlighting
+    ]), g(t, "shebang", e.SHEBANG()), g(t, "use_strict", o);
+    const m = t.contains.find((r) => r.label === "func.def");
+    return m.relevance = 0, Object.assign(t, {
+      name: "TypeScript",
+      aliases: [
+        "ts",
+        "tsx",
+        "mts",
+        "cts"
+      ]
+    }), t;
+  }
+  return C = Z, C;
+}
+export {
+  V as __require
+};