@fangzhongya/vue-archive 0.0.2-8 → 0.0.2

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

@@ -1,9 +1,11 @@
-var I, $;
-function V() {
-  if ($)
-    return I;
-  $ = 1;
-  const b = "[A-Za-z$_][0-9A-Za-z$_]*", O = [
+var typescript_1;
+var hasRequiredTypescript;
+function requireTypescript() {
+  if (hasRequiredTypescript)
+    return typescript_1;
+  hasRequiredTypescript = 1;
+  const IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*";
+  const KEYWORDS = [
     "as",
     // for exports
     "in",
@@ -46,14 +48,16 @@ function V() {
     "from",
     "export",
     "extends"
-  ], C = [
+  ];
+  const LITERALS = [
     "true",
     "false",
     "null",
     "undefined",
     "NaN",
     "Infinity"
-  ], v = [
+  ];
+  const TYPES = [
     // Fundamental objects
     "Object",
     "Function",
@@ -103,7 +107,8 @@ function V() {
     "Intl",
     // WebAssembly
     "WebAssembly"
-  ], M = [
+  ];
+  const ERROR_TYPES = [
     "Error",
     "EvalError",
     "InternalError",
@@ -112,7 +117,8 @@ function V() {
     "SyntaxError",
     "TypeError",
     "URIError"
-  ], w = [
+  ];
+  const BUILT_IN_GLOBALS = [
     "setInterval",
     "setTimeout",
     "clearInterval",
@@ -130,7 +136,8 @@ function V() {
     "encodeURIComponent",
     "escape",
     "unescape"
-  ], x = [
+  ];
+  const BUILT_IN_VARIABLES = [
     "arguments",
     "this",
     "super",
@@ -141,64 +148,83 @@ function V() {
     "module",
     "global"
     // Node.js
-  ], L = [].concat(
-    w,
-    v,
-    M
+  ];
+  const BUILT_INS = [].concat(
+    BUILT_IN_GLOBALS,
+    TYPES,
+    ERROR_TYPES
   );
-  function F(n) {
-    const e = n.regex, T = (s, { after: i }) => {
-      const u = "</" + s[0].slice(1);
-      return s.input.indexOf(u, i) !== -1;
-    }, t = b, g = {
+  function javascript(hljs) {
+    const regex = hljs.regex;
+    const hasClosingTag = (match, { after }) => {
+      const tag = "</" + match[0].slice(1);
+      const pos = match.input.indexOf(tag, after);
+      return pos !== -1;
+    };
+    const IDENT_RE$1 = IDENT_RE;
+    const FRAGMENT = {
       begin: "<>",
       end: "</>"
-    }, f = /<[A-Za-z0-9\\._:-]+\s*\/>/, r = {
+    };
+    const XML_SELF_CLOSING = /<[A-Za-z0-9\\._:-]+\s*\/>/;
+    const XML_TAG = {
       begin: /<[A-Za-z0-9\\._:-]+/,
       end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
       /**
        * @param {RegExpMatchArray} match
        * @param {CallbackResponse} response
        */
-      isTrulyOpeningTag: (s, i) => {
-        const u = s[0].length + s.index, m = s.input[u];
+      isTrulyOpeningTag: (match, response) => {
+        const afterMatchIndex = match[0].length + match.index;
+        const nextChar = match.input[afterMatchIndex];
         if (
           // HTML should not include another raw `<` inside a tag
           // nested type?
           // `<Array<Array<number>>`, etc.
-          m === "<" || // the , gives away that this is not HTML
+          nextChar === "<" || // the , gives away that this is not HTML
           // `<T, A extends keyof T, V>`
-          m === ","
+          nextChar === ","
         ) {
-          i.ignoreMatch();
+          response.ignoreMatch();
           return;
         }
-        m === ">" && (T(s, { after: u }) || i.ignoreMatch());
-        let p;
-        const P = s.input.substring(u);
-        if (p = P.match(/^\s*=/)) {
-          i.ignoreMatch();
-          return;
+        if (nextChar === ">") {
+          if (!hasClosingTag(match, { after: afterMatchIndex })) {
+            response.ignoreMatch();
+          }
         }
-        if ((p = P.match(/^\s+extends\s+/)) && p.index === 0) {
-          i.ignoreMatch();
+        let m;
+        const afterMatch = match.input.substring(afterMatchIndex);
+        if (m = afterMatch.match(/^\s*=/)) {
+          response.ignoreMatch();
           return;
         }
+        if (m = afterMatch.match(/^\s+extends\s+/)) {
+          if (m.index === 0) {
+            response.ignoreMatch();
+            return;
+          }
+        }
       }
-    }, c = {
-      $pattern: b,
-      keyword: O,
-      literal: C,
-      built_in: L,
-      "variable.language": x
-    }, _ = "[0-9](_?[0-9])*", o = `\\.(${_})`, l = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", A = {
+    };
+    const KEYWORDS$1 = {
+      $pattern: IDENT_RE,
+      keyword: KEYWORDS,
+      literal: LITERALS,
+      built_in: BUILT_INS,
+      "variable.language": BUILT_IN_VARIABLES
+    };
+    const decimalDigits = "[0-9](_?[0-9])*";
+    const frac = `\\.(${decimalDigits})`;
+    const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+    const NUMBER = {
       className: "number",
       variants: [
         // DecimalLiteral
-        { begin: `(\\b(${l})((${o})|\\.)?|(${o}))[eE][+-]?(${_})\\b` },
-        { begin: `\\b(${l})\\b((${o})\\b|\\.)?|(${o})\\b` },
+        { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))[eE][+-]?(${decimalDigits})\\b` },
+        { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` },
         // DecimalBigIntegerLiteral
-        { begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
+        { 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" },
@@ -208,141 +234,151 @@ function V() {
         { begin: "\\b0[0-7]+n?\\b" }
       ],
       relevance: 0
-    }, a = {
+    };
+    const SUBST = {
       className: "subst",
       begin: "\\$\\{",
       end: "\\}",
-      keywords: c,
+      keywords: KEYWORDS$1,
       contains: []
       // defined later
-    }, N = {
+    };
+    const HTML_TEMPLATE = {
       begin: "html`",
       end: "",
       starts: {
         end: "`",
-        returnEnd: !1,
+        returnEnd: false,
         contains: [
-          n.BACKSLASH_ESCAPE,
-          a
+          hljs.BACKSLASH_ESCAPE,
+          SUBST
         ],
         subLanguage: "xml"
       }
-    }, S = {
+    };
+    const CSS_TEMPLATE = {
       begin: "css`",
       end: "",
       starts: {
         end: "`",
-        returnEnd: !1,
+        returnEnd: false,
         contains: [
-          n.BACKSLASH_ESCAPE,
-          a
+          hljs.BACKSLASH_ESCAPE,
+          SUBST
         ],
         subLanguage: "css"
       }
-    }, E = {
+    };
+    const TEMPLATE_STRING = {
       className: "string",
       begin: "`",
       end: "`",
       contains: [
-        n.BACKSLASH_ESCAPE,
-        a
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
       ]
-    }, y = {
-      className: "comment",
-      variants: [
-        n.COMMENT(
-          /\/\*\*(?!\/)/,
-          "\\*/",
+    };
+    const JSDOC_COMMENT = hljs.COMMENT(
+      /\/\*\*(?!\/)/,
+      "\\*/",
+      {
+        relevance: 0,
+        contains: [
           {
+            begin: "(?=@[A-Za-z]+)",
             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: t + "(?=\\s*(-)|$)",
-                    endsParent: !0,
-                    relevance: 0
-                  },
-                  // eat spaces (not newlines) so we can find
-                  // types or variables
-                  {
-                    begin: /(?=[^\n])\s/,
-                    relevance: 0
-                  }
-                ]
+                className: "doctag",
+                begin: "@[A-Za-z]+"
+              },
+              {
+                className: "type",
+                begin: "\\{",
+                end: "\\}",
+                excludeEnd: true,
+                excludeBegin: true,
+                relevance: 0
+              },
+              {
+                className: "variable",
+                begin: IDENT_RE$1 + "(?=\\s*(-)|$)",
+                endsParent: true,
+                relevance: 0
+              },
+              // eat spaces (not newlines) so we can find
+              // types or variables
+              {
+                begin: /(?=[^\n])\s/,
+                relevance: 0
               }
             ]
           }
-        ),
-        n.C_BLOCK_COMMENT_MODE,
-        n.C_LINE_COMMENT_MODE
+        ]
+      }
+    );
+    const COMMENT = {
+      className: "comment",
+      variants: [
+        JSDOC_COMMENT,
+        hljs.C_BLOCK_COMMENT_MODE,
+        hljs.C_LINE_COMMENT_MODE
       ]
-    }, k = [
-      n.APOS_STRING_MODE,
-      n.QUOTE_STRING_MODE,
-      N,
-      S,
-      E,
+    };
+    const SUBST_INTERNALS = [
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      HTML_TEMPLATE,
+      CSS_TEMPLATE,
+      TEMPLATE_STRING,
       // Skip numbers when they are part of a variable name
       { match: /\$\d+/ },
-      A
+      NUMBER
       // This is intentional:
       // See https://github.com/highlightjs/highlight.js/issues/3288
       // hljs.REGEXP_MODE
     ];
-    a.contains = k.concat({
+    SUBST.contains = SUBST_INTERNALS.concat({
       // we need to pair up {} inside our subst to prevent
       // it from ending too early by matching another }
       begin: /\{/,
       end: /\}/,
-      keywords: c,
+      keywords: KEYWORDS$1,
       contains: [
         "self"
-      ].concat(k)
+      ].concat(SUBST_INTERNALS)
     });
-    const h = [].concat(y, a.contains), R = h.concat([
+    const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+    const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([
       // eat recursive parens in sub expressions
       {
         begin: /\(/,
         end: /\)/,
-        keywords: c,
-        contains: ["self"].concat(h)
+        keywords: KEYWORDS$1,
+        contains: ["self"].concat(SUBST_AND_COMMENTS)
       }
-    ]), d = {
+    ]);
+    const PARAMS = {
       className: "params",
       begin: /\(/,
       end: /\)/,
-      excludeBegin: !0,
-      excludeEnd: !0,
-      keywords: c,
-      contains: R
-    }, z = {
+      excludeBegin: true,
+      excludeEnd: true,
+      keywords: KEYWORDS$1,
+      contains: PARAMS_CONTAINS
+    };
+    const CLASS_OR_EXTENDS = {
       variants: [
         // class Car extends vehicle
         {
           match: [
             /class/,
             /\s+/,
-            t,
+            IDENT_RE$1,
             /\s+/,
             /extends/,
             /\s+/,
-            e.concat(t, "(", e.concat(/\./, t), ")*")
+            regex.concat(IDENT_RE$1, "(", regex.concat(/\./, IDENT_RE$1), ")*")
           ],
           scope: {
             1: "keyword",
@@ -356,7 +392,7 @@ function V() {
           match: [
             /class/,
             /\s+/,
-            t
+            IDENT_RE$1
           ],
           scope: {
             1: "keyword",
@@ -364,9 +400,10 @@ function V() {
           }
         }
       ]
-    }, B = {
+    };
+    const CLASS_REFERENCE = {
       relevance: 0,
-      match: e.either(
+      match: regex.either(
         // Hard coded exceptions
         /\bJSON/,
         // Float32Array, OutT
@@ -384,22 +421,24 @@ function V() {
       keywords: {
         _: [
           // se we still get relevance credit for JS library classes
-          ...v,
-          ...M
+          ...TYPES,
+          ...ERROR_TYPES
         ]
       }
-    }, G = {
+    };
+    const USE_STRICT = {
       label: "use_strict",
       className: "meta",
       relevance: 10,
       begin: /^\s*['"]use (strict|asm)['"]/
-    }, K = {
+    };
+    const FUNCTION_DEFINITION = {
       variants: [
         {
           match: [
             /function/,
             /\s+/,
-            t,
+            IDENT_RE$1,
             /(?=\s*\()/
           ]
         },
@@ -416,43 +455,46 @@ function V() {
         3: "title.function"
       },
       label: "func.def",
-      contains: [d],
+      contains: [PARAMS],
       illegal: /%/
-    }, Y = {
+    };
+    const UPPER_CASE_CONSTANT = {
       relevance: 0,
       match: /\b[A-Z][A-Z_0-9]+\b/,
       className: "variable.constant"
     };
-    function W(s) {
-      return e.concat("(?!", s.join("|"), ")");
+    function noneOf(list) {
+      return regex.concat("(?!", list.join("|"), ")");
     }
-    const H = {
-      match: e.concat(
+    const FUNCTION_CALL = {
+      match: regex.concat(
         /\b/,
-        W([
-          ...w,
+        noneOf([
+          ...BUILT_IN_GLOBALS,
           "super",
           "import"
         ]),
-        t,
-        e.lookahead(/\(/)
+        IDENT_RE$1,
+        regex.lookahead(/\(/)
       ),
       className: "title.function",
       relevance: 0
-    }, J = {
-      begin: e.concat(/\./, e.lookahead(
-        e.concat(t, /(?![0-9A-Za-z$_(])/)
+    };
+    const PROPERTY_ACCESS = {
+      begin: regex.concat(/\./, regex.lookahead(
+        regex.concat(IDENT_RE$1, /(?![0-9A-Za-z$_(])/)
       )),
-      end: t,
-      excludeBegin: !0,
+      end: IDENT_RE$1,
+      excludeBegin: true,
       keywords: "prototype",
       className: "property",
       relevance: 0
-    }, X = {
+    };
+    const GETTER_OR_SETTER = {
       match: [
         /get|set/,
         /\s+/,
-        t,
+        IDENT_RE$1,
         /(?=\()/
       ],
       className: {
@@ -464,18 +506,20 @@ function V() {
           // eat to avoid empty params
           begin: /\(\)/
         },
-        d
+        PARAMS
       ]
-    }, U = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + n.UNDERSCORE_IDENT_RE + ")\\s*=>", q = {
+    };
+    const FUNC_LEAD_IN_RE = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>";
+    const FUNCTION_VARIABLE = {
       match: [
         /const|var|let/,
         /\s+/,
-        t,
+        IDENT_RE$1,
         /\s*/,
         /=\s*/,
         /(async\s*)?/,
         // async is optional
-        e.lookahead(U)
+        regex.lookahead(FUNC_LEAD_IN_RE)
       ],
       keywords: "async",
       className: {
@@ -483,75 +527,75 @@ function V() {
         3: "title.function"
       },
       contains: [
-        d
+        PARAMS
       ]
     };
     return {
       name: "Javascript",
       aliases: ["js", "jsx", "mjs", "cjs"],
-      keywords: c,
+      keywords: KEYWORDS$1,
       // this will be extended by TypeScript
-      exports: { PARAMS_CONTAINS: R, CLASS_REFERENCE: B },
+      exports: { PARAMS_CONTAINS, CLASS_REFERENCE },
       illegal: /#(?![$_A-z])/,
       contains: [
-        n.SHEBANG({
+        hljs.SHEBANG({
           label: "shebang",
           binary: "node",
           relevance: 5
         }),
-        G,
-        n.APOS_STRING_MODE,
-        n.QUOTE_STRING_MODE,
-        N,
-        S,
-        E,
-        y,
+        USE_STRICT,
+        hljs.APOS_STRING_MODE,
+        hljs.QUOTE_STRING_MODE,
+        HTML_TEMPLATE,
+        CSS_TEMPLATE,
+        TEMPLATE_STRING,
+        COMMENT,
         // Skip numbers when they are part of a variable name
         { match: /\$\d+/ },
-        A,
-        B,
+        NUMBER,
+        CLASS_REFERENCE,
         {
           className: "attr",
-          begin: t + e.lookahead(":"),
+          begin: IDENT_RE$1 + regex.lookahead(":"),
           relevance: 0
         },
-        q,
+        FUNCTION_VARIABLE,
         {
           // "value" container
-          begin: "(" + n.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+          begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
           keywords: "return throw case",
           relevance: 0,
           contains: [
-            y,
-            n.REGEXP_MODE,
+            COMMENT,
+            hljs.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: U,
-              returnBegin: !0,
+              begin: FUNC_LEAD_IN_RE,
+              returnBegin: true,
               end: "\\s*=>",
               contains: [
                 {
                   className: "params",
                   variants: [
                     {
-                      begin: n.UNDERSCORE_IDENT_RE,
+                      begin: hljs.UNDERSCORE_IDENT_RE,
                       relevance: 0
                     },
                     {
                       className: null,
                       begin: /\(\s*\)/,
-                      skip: !0
+                      skip: true
                     },
                     {
                       begin: /\(/,
                       end: /\)/,
-                      excludeBegin: !0,
-                      excludeEnd: !0,
-                      keywords: c,
-                      contains: R
+                      excludeBegin: true,
+                      excludeEnd: true,
+                      keywords: KEYWORDS$1,
+                      contains: PARAMS_CONTAINS
                     }
                   ]
                 }
@@ -569,29 +613,29 @@ function V() {
             {
               // JSX
               variants: [
-                { begin: g.begin, end: g.end },
-                { match: f },
+                { begin: FRAGMENT.begin, end: FRAGMENT.end },
+                { match: XML_SELF_CLOSING },
                 {
-                  begin: r.begin,
+                  begin: XML_TAG.begin,
                   // we carefully check the opening tag to see if it truly
                   // is a tag and not a false positive
-                  "on:begin": r.isTrulyOpeningTag,
-                  end: r.end
+                  "on:begin": XML_TAG.isTrulyOpeningTag,
+                  end: XML_TAG.end
                 }
               ],
               subLanguage: "xml",
               contains: [
                 {
-                  begin: r.begin,
-                  end: r.end,
-                  skip: !0,
+                  begin: XML_TAG.begin,
+                  end: XML_TAG.end,
+                  skip: true,
                   contains: ["self"]
                 }
               ]
             }
           ]
         },
-        K,
+        FUNCTION_DEFINITION,
         {
           // prevent this from getting swallowed up by function
           // since they appear "function like"
@@ -601,13 +645,13 @@ function V() {
           // 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)" + n.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+          begin: "\\b(?!function)" + hljs.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
           // end parens
-          returnBegin: !0,
+          returnBegin: true,
           label: "func.def",
           contains: [
-            d,
-            n.inherit(n.TITLE_MODE, { begin: t, className: "title.function" })
+            PARAMS,
+            hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1, className: "title.function" })
           ]
         },
         // catch ... so it won't trigger the property rule below
@@ -615,23 +659,23 @@ function V() {
           match: /\.\.\./,
           relevance: 0
         },
-        J,
+        PROPERTY_ACCESS,
         // hack: prevents detection of keywords in some circumstances
         // .keyword()
         // $keyword = x
         {
-          match: "\\$" + t,
+          match: "\\$" + IDENT_RE$1,
           relevance: 0
         },
         {
           match: [/\bconstructor(?=\s*\()/],
           className: { 1: "title.function" },
-          contains: [d]
+          contains: [PARAMS]
         },
-        H,
-        Y,
-        z,
-        X,
+        FUNCTION_CALL,
+        UPPER_CASE_CONSTANT,
+        CLASS_OR_EXTENDS,
+        GETTER_OR_SETTER,
         {
           match: /\$[(.]/
           // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
@@ -639,8 +683,10 @@ function V() {
       ]
     };
   }
-  function Z(n) {
-    const e = F(n), T = b, t = [
+  function typescript(hljs) {
+    const tsLanguage = javascript(hljs);
+    const IDENT_RE$1 = IDENT_RE;
+    const TYPES2 = [
       "any",
       "void",
       "number",
@@ -651,25 +697,29 @@ function V() {
       "symbol",
       "bigint",
       "unknown"
-    ], g = {
+    ];
+    const NAMESPACE = {
       beginKeywords: "namespace",
       end: /\{/,
-      excludeEnd: !0,
-      contains: [e.exports.CLASS_REFERENCE]
-    }, f = {
+      excludeEnd: true,
+      contains: [tsLanguage.exports.CLASS_REFERENCE]
+    };
+    const INTERFACE = {
       beginKeywords: "interface",
       end: /\{/,
-      excludeEnd: !0,
+      excludeEnd: true,
       keywords: {
         keyword: "interface extends",
-        built_in: t
+        built_in: TYPES2
       },
-      contains: [e.exports.CLASS_REFERENCE]
-    }, r = {
+      contains: [tsLanguage.exports.CLASS_REFERENCE]
+    };
+    const USE_STRICT = {
       className: "meta",
       relevance: 10,
       begin: /^\s*['"]use strict['"]/
-    }, c = [
+    };
+    const TS_SPECIFIC_KEYWORDS = [
       "type",
       "namespace",
       "interface",
@@ -682,37 +732,48 @@ function V() {
       "readonly",
       "enum",
       "override"
-    ], _ = {
-      $pattern: b,
-      keyword: O.concat(c),
-      literal: C,
-      built_in: L.concat(t),
-      "variable.language": x
-    }, o = {
+    ];
+    const KEYWORDS$1 = {
+      $pattern: IDENT_RE,
+      keyword: KEYWORDS.concat(TS_SPECIFIC_KEYWORDS),
+      literal: LITERALS,
+      built_in: BUILT_INS.concat(TYPES2),
+      "variable.language": BUILT_IN_VARIABLES
+    };
+    const DECORATOR = {
       className: "meta",
-      begin: "@" + T
-    }, l = (a, N, S) => {
-      const E = a.contains.findIndex((D) => D.label === N);
-      if (E === -1)
+      begin: "@" + IDENT_RE$1
+    };
+    const swapMode = (mode, label, replacement) => {
+      const indx = mode.contains.findIndex((m) => m.label === label);
+      if (indx === -1) {
         throw new Error("can not find mode to replace");
-      a.contains.splice(E, 1, S);
+      }
+      mode.contains.splice(indx, 1, replacement);
     };
-    Object.assign(e.keywords, _), e.exports.PARAMS_CONTAINS.push(o), e.contains = e.contains.concat([
-      o,
-      g,
-      f
-    ]), l(e, "shebang", n.SHEBANG()), l(e, "use_strict", r);
-    const A = e.contains.find((a) => a.label === "func.def");
-    return A.relevance = 0, Object.assign(e, {
+    Object.assign(tsLanguage.keywords, KEYWORDS$1);
+    tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR);
+    tsLanguage.contains = tsLanguage.contains.concat([
+      DECORATOR,
+      NAMESPACE,
+      INTERFACE
+    ]);
+    swapMode(tsLanguage, "shebang", hljs.SHEBANG());
+    swapMode(tsLanguage, "use_strict", USE_STRICT);
+    const functionDeclaration = tsLanguage.contains.find((m) => m.label === "func.def");
+    functionDeclaration.relevance = 0;
+    Object.assign(tsLanguage, {
       name: "TypeScript",
       aliases: [
         "ts",
         "tsx"
       ]
-    }), e;
+    });
+    return tsLanguage;
   }
-  return I = Z, I;
+  typescript_1 = typescript;
+  return typescript_1;
 }
 export {
-  V as __require
+  requireTypescript as __require
 };