@fewangsit/wangsvue 1.5.219-alpha.0 → 1.5.219-alpha.2

package/vendor/highlight.js/es/languages/typescript.es.js

@@ -1,4 +1,5 @@
-const m = "[A-Za-z$_][0-9A-Za-z$_]*", x = [
+const IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*";
+const KEYWORDS = [
   "as",
   // for exports
   "in",
@@ -41,14 +42,16 @@ const m = "[A-Za-z$_][0-9A-Za-z$_]*", x = [
   "from",
   "export",
   "extends"
-], D = [
+];
+const LITERALS = [
   "true",
   "false",
   "null",
   "undefined",
   "NaN",
   "Infinity"
-], k = [
+];
+const TYPES = [
   // Fundamental objects
   "Object",
   "Function",
@@ -98,7 +101,8 @@ const m = "[A-Za-z$_][0-9A-Za-z$_]*", x = [
   "Intl",
   // WebAssembly
   "WebAssembly"
-], B = [
+];
+const ERROR_TYPES = [
   "Error",
   "EvalError",
   "InternalError",
@@ -107,7 +111,8 @@ const m = "[A-Za-z$_][0-9A-Za-z$_]*", x = [
   "SyntaxError",
   "TypeError",
   "URIError"
-], U = [
+];
+const BUILT_IN_GLOBALS = [
   "setInterval",
   "setTimeout",
   "clearInterval",
@@ -125,7 +130,8 @@ const m = "[A-Za-z$_][0-9A-Za-z$_]*", x = [
   "encodeURIComponent",
   "escape",
   "unescape"
-], h = [
+];
+const BUILT_IN_VARIABLES = [
   "arguments",
   "this",
   "super",
@@ -137,64 +143,83 @@ const m = "[A-Za-z$_][0-9A-Za-z$_]*", x = [
   "module",
   "global"
   // Node.js
-], P = [].concat(
-  U,
-  k,
-  B
+];
+const BUILT_INS = [].concat(
+  BUILT_IN_GLOBALS,
+  TYPES,
+  ERROR_TYPES
 );
-function J(n) {
-  const e = n.regex, R = (a, { after: l }) => {
-    const g = "</" + a[0].slice(1);
-    return a.input.indexOf(g, l) !== -1;
-  }, t = m, u = {
+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*\/>/, o = {
+  };
+  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: (a, l) => {
-      const g = a[0].length + a.index, T = a.input[g];
+    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.
-        T === "<" || // the , gives away that this is not HTML
+        nextChar === "<" || // the , gives away that this is not HTML
         // `<T, A extends keyof T, V>`
-        T === ","
+        nextChar === ","
       ) {
-        l.ignoreMatch();
+        response.ignoreMatch();
         return;
       }
-      T === ">" && (R(a, { after: g }) || l.ignoreMatch());
-      let p;
-      const L = a.input.substring(g);
-      if (p = L.match(/^\s*=/)) {
-        l.ignoreMatch();
-        return;
+      if (nextChar === ">") {
+        if (!hasClosingTag(match, { after: afterMatchIndex })) {
+          response.ignoreMatch();
+        }
       }
-      if ((p = L.match(/^\s+extends\s+/)) && p.index === 0) {
-        l.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: m,
-    keyword: x,
-    literal: D,
-    built_in: P,
-    "variable.language": h
-  }, A = "[0-9](_?[0-9])*", i = `\\.(${A})`, E = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", _ = {
+  };
+  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(${E})((${i})|\\.)?|(${i}))[eE][+-]?(${A})\\b` },
-      { begin: `\\b(${E})\\b((${i})\\b|\\.)?|(${i})\\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" },
@@ -204,156 +229,167 @@ function J(n) {
       { begin: "\\b0[0-7]+n?\\b" }
     ],
     relevance: 0
-  }, r = {
+  };
+  const SUBST = {
     className: "subst",
     begin: "\\$\\{",
     end: "\\}",
-    keywords: c,
+    keywords: KEYWORDS$1,
     contains: []
     // defined later
-  }, s = {
+  };
+  const HTML_TEMPLATE = {
     begin: ".?html`",
     end: "",
     starts: {
       end: "`",
-      returnEnd: !1,
+      returnEnd: false,
       contains: [
-        n.BACKSLASH_ESCAPE,
-        r
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
       ],
       subLanguage: "xml"
     }
-  }, S = {
+  };
+  const CSS_TEMPLATE = {
     begin: ".?css`",
     end: "",
     starts: {
       end: "`",
-      returnEnd: !1,
+      returnEnd: false,
       contains: [
-        n.BACKSLASH_ESCAPE,
-        r
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
       ],
       subLanguage: "css"
     }
-  }, N = {
+  };
+  const GRAPHQL_TEMPLATE = {
     begin: ".?gql`",
     end: "",
     starts: {
       end: "`",
-      returnEnd: !1,
+      returnEnd: false,
       contains: [
-        n.BACKSLASH_ESCAPE,
-        r
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
       ],
       subLanguage: "graphql"
     }
-  }, d = {
+  };
+  const TEMPLATE_STRING = {
     className: "string",
     begin: "`",
     end: "`",
     contains: [
-      n.BACKSLASH_ESCAPE,
-      r
+      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
     ]
-  }, O = [
-    n.APOS_STRING_MODE,
-    n.QUOTE_STRING_MODE,
-    s,
-    S,
-    N,
-    d,
+  };
+  const SUBST_INTERNALS = [
+    hljs.APOS_STRING_MODE,
+    hljs.QUOTE_STRING_MODE,
+    HTML_TEMPLATE,
+    CSS_TEMPLATE,
+    GRAPHQL_TEMPLATE,
+    TEMPLATE_STRING,
     // Skip numbers when they are part of a variable name
     { match: /\$\d+/ },
-    _
+    NUMBER
     // This is intentional:
     // See https://github.com/highlightjs/highlight.js/issues/3288
     // hljs.REGEXP_MODE
   ];
-  r.contains = O.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(O)
+    ].concat(SUBST_INTERNALS)
   });
-  const M = [].concat(y, r.contains), I = M.concat([
+  const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+  const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([
     // eat recursive parens in sub expressions
     {
       begin: /(\s*)\(/,
       end: /\)/,
-      keywords: c,
-      contains: ["self"].concat(M)
+      keywords: KEYWORDS$1,
+      contains: ["self"].concat(SUBST_AND_COMMENTS)
     }
-  ]), b = {
+  ]);
+  const PARAMS = {
     className: "params",
     // convert this to negative lookbehind in v12
     begin: /(\s*)\(/,
     // to match the parms with 
     end: /\)/,
-    excludeBegin: !0,
-    excludeEnd: !0,
-    keywords: c,
-    contains: I
-  }, $ = {
+    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",
@@ -367,7 +403,7 @@ function J(n) {
         match: [
           /class/,
           /\s+/,
-          t
+          IDENT_RE$1
         ],
         scope: {
           1: "keyword",
@@ -375,9 +411,10 @@ function J(n) {
         }
       }
     ]
-  }, v = {
+  };
+  const CLASS_REFERENCE = {
     relevance: 0,
-    match: e.either(
+    match: regex.either(
       // Hard coded exceptions
       /\bJSON/,
       // Float32Array, OutT
@@ -395,22 +432,24 @@ function J(n) {
     keywords: {
       _: [
         // se we still get relevance credit for JS library classes
-        ...k,
-        ...B
+        ...TYPES,
+        ...ERROR_TYPES
       ]
     }
-  }, F = {
+  };
+  const USE_STRICT = {
     label: "use_strict",
     className: "meta",
     relevance: 10,
     begin: /^\s*['"]use (strict|asm)['"]/
-  }, G = {
+  };
+  const FUNCTION_DEFINITION = {
     variants: [
       {
         match: [
           /function/,
           /\s+/,
-          t,
+          IDENT_RE$1,
           /(?=\s*\()/
         ]
       },
@@ -427,43 +466,46 @@ function J(n) {
       3: "title.function"
     },
     label: "func.def",
-    contains: [b],
+    contains: [PARAMS],
     illegal: /%/
-  }, Z = {
+  };
+  const UPPER_CASE_CONSTANT = {
     relevance: 0,
     match: /\b[A-Z][A-Z_0-9]+\b/,
     className: "variable.constant"
   };
-  function z(a) {
-    return e.concat("(?!", a.join("|"), ")");
+  function noneOf(list) {
+    return regex.concat("(?!", list.join("|"), ")");
   }
-  const H = {
-    match: e.concat(
+  const FUNCTION_CALL = {
+    match: regex.concat(
       /\b/,
-      z([
-        ...U,
+      noneOf([
+        ...BUILT_IN_GLOBALS,
         "super",
         "import"
-      ].map((a) => `${a}\\s*\\(`)),
-      t,
-      e.lookahead(/\s*\(/)
+      ].map((x) => `${x}\\s*\\(`)),
+      IDENT_RE$1,
+      regex.lookahead(/\s*\(/)
     ),
     className: "title.function",
     relevance: 0
-  }, K = {
-    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
-  }, Y = {
+  };
+  const GETTER_OR_SETTER = {
     match: [
       /get|set/,
       /\s+/,
-      t,
+      IDENT_RE$1,
       /(?=\()/
     ],
     className: {
@@ -475,18 +517,20 @@ function J(n) {
         // eat to avoid empty params
         begin: /\(\)/
       },
-      b
+      PARAMS
     ]
-  }, w = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + n.UNDERSCORE_IDENT_RE + ")\\s*=>", W = {
+  };
+  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(w)
+      regex.lookahead(FUNC_LEAD_IN_RE)
     ],
     keywords: "async",
     className: {
@@ -494,76 +538,76 @@ function J(n) {
       3: "title.function"
     },
     contains: [
-      b
+      PARAMS
     ]
   };
   return {
     name: "JavaScript",
     aliases: ["js", "jsx", "mjs", "cjs"],
-    keywords: c,
+    keywords: KEYWORDS$1,
     // this will be extended by TypeScript
-    exports: { PARAMS_CONTAINS: I, CLASS_REFERENCE: v },
+    exports: { PARAMS_CONTAINS, CLASS_REFERENCE },
     illegal: /#(?![$_A-z])/,
     contains: [
-      n.SHEBANG({
+      hljs.SHEBANG({
         label: "shebang",
         binary: "node",
         relevance: 5
       }),
-      F,
-      n.APOS_STRING_MODE,
-      n.QUOTE_STRING_MODE,
-      s,
-      S,
-      N,
-      d,
-      y,
+      USE_STRICT,
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      HTML_TEMPLATE,
+      CSS_TEMPLATE,
+      GRAPHQL_TEMPLATE,
+      TEMPLATE_STRING,
+      COMMENT,
       // Skip numbers when they are part of a variable name
       { match: /\$\d+/ },
-      _,
-      v,
+      NUMBER,
+      CLASS_REFERENCE,
       {
         className: "attr",
-        begin: t + e.lookahead(":"),
+        begin: IDENT_RE$1 + regex.lookahead(":"),
         relevance: 0
       },
-      W,
+      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: w,
-            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: /(\s*)\(/,
                     end: /\)/,
-                    excludeBegin: !0,
-                    excludeEnd: !0,
-                    keywords: c,
-                    contains: I
+                    excludeBegin: true,
+                    excludeEnd: true,
+                    keywords: KEYWORDS$1,
+                    contains: PARAMS_CONTAINS
                   }
                 ]
               }
@@ -581,29 +625,29 @@ function J(n) {
           {
             // JSX
             variants: [
-              { begin: u.begin, end: u.end },
-              { match: f },
+              { begin: FRAGMENT.begin, end: FRAGMENT.end },
+              { match: XML_SELF_CLOSING },
               {
-                begin: o.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": o.isTrulyOpeningTag,
-                end: o.end
+                "on:begin": XML_TAG.isTrulyOpeningTag,
+                end: XML_TAG.end
               }
             ],
             subLanguage: "xml",
             contains: [
               {
-                begin: o.begin,
-                end: o.end,
-                skip: !0,
+                begin: XML_TAG.begin,
+                end: XML_TAG.end,
+                skip: true,
                 contains: ["self"]
               }
             ]
           }
         ]
       },
-      G,
+      FUNCTION_DEFINITION,
       {
         // prevent this from getting swallowed up by function
         // since they appear "function like"
@@ -613,13 +657,13 @@ function J(n) {
         // 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: [
-          b,
-          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
@@ -627,23 +671,23 @@ function J(n) {
         match: /\.\.\./,
         relevance: 0
       },
-      K,
+      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: [b]
+        contains: [PARAMS]
       },
-      H,
-      Z,
-      $,
-      Y,
+      FUNCTION_CALL,
+      UPPER_CASE_CONSTANT,
+      CLASS_OR_EXTENDS,
+      GETTER_OR_SETTER,
       {
         match: /\$[(.]/
         // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
@@ -651,8 +695,10 @@ function J(n) {
     ]
   };
 }
-function X(n) {
-  const e = J(n), R = m, t = [
+function typescript(hljs) {
+  const tsLanguage = javascript(hljs);
+  const IDENT_RE$1 = IDENT_RE;
+  const TYPES2 = [
     "any",
     "void",
     "number",
@@ -663,30 +709,34 @@ function X(n) {
     "symbol",
     "bigint",
     "unknown"
-  ], u = {
+  ];
+  const NAMESPACE = {
     begin: [
       /namespace/,
       /\s+/,
-      n.IDENT_RE
+      hljs.IDENT_RE
     ],
     beginScope: {
       1: "keyword",
       3: "title.class"
     }
-  }, f = {
+  };
+  const INTERFACE = {
     beginKeywords: "interface",
     end: /\{/,
-    excludeEnd: !0,
+    excludeEnd: true,
     keywords: {
       keyword: "interface extends",
-      built_in: t
+      built_in: TYPES2
     },
-    contains: [e.exports.CLASS_REFERENCE]
-  }, o = {
+    contains: [tsLanguage.exports.CLASS_REFERENCE]
+  };
+  const USE_STRICT = {
     className: "meta",
     relevance: 10,
     begin: /^\s*['"]use strict['"]/
-  }, c = [
+  };
+  const TS_SPECIFIC_KEYWORDS = [
     "type",
     // "namespace",
     "interface",
@@ -700,35 +750,44 @@ function X(n) {
     "enum",
     "override",
     "satisfies"
-  ], A = {
-    $pattern: m,
-    keyword: x.concat(c),
-    literal: D,
-    built_in: P.concat(t),
-    "variable.language": h
-  }, i = {
+  ];
+  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: "@" + R
-  }, E = (s, S, N) => {
-    const d = s.contains.findIndex((C) => C.label === S);
-    if (d === -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");
-    s.contains.splice(d, 1, N);
+    }
+    mode.contains.splice(indx, 1, replacement);
   };
-  Object.assign(e.keywords, A), e.exports.PARAMS_CONTAINS.push(i);
-  const _ = e.contains.find((s) => s.className === "attr");
-  e.exports.PARAMS_CONTAINS.push([
-    e.exports.CLASS_REFERENCE,
+  Object.assign(tsLanguage.keywords, KEYWORDS$1);
+  tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR);
+  const ATTRIBUTE_HIGHLIGHT = tsLanguage.contains.find((c) => c.className === "attr");
+  tsLanguage.exports.PARAMS_CONTAINS.push([
+    tsLanguage.exports.CLASS_REFERENCE,
     // class reference for highlighting the params types
-    _
+    ATTRIBUTE_HIGHLIGHT
     // highlight the params key
-  ]), e.contains = e.contains.concat([
-    i,
-    u,
-    f
-  ]), E(e, "shebang", n.SHEBANG()), E(e, "use_strict", o);
-  const r = e.contains.find((s) => s.label === "func.def");
-  return r.relevance = 0, Object.assign(e, {
+  ]);
+  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",
@@ -736,8 +795,9 @@ function X(n) {
       "mts",
       "cts"
     ]
-  }), e;
+  });
+  return tsLanguage;
 }
 export {
-  X as t
+  typescript as t
 };