typescript 5.0.0-dev.20230208 → 5.0.0-dev.20230210

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230208`;
+var version = `${versionMajorMinor}.0-dev.20230210`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -614,6 +614,12 @@ function first(array) {
   Debug.assert(array.length !== 0);
   return array[0];
 }
+function firstIterator(iter) {
+  for (const value of iter) {
+    return value;
+  }
+  Debug.fail("iterator is empty");
+}
 function lastOrUndefined(array) {
   return array === void 0 || array.length === 0 ? void 0 : array[array.length - 1];
 }
@@ -6174,6 +6180,7 @@ var Diagnostics = {
   To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module: diag(1483, 3 /* Message */, "To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module_1483", 'To convert this file to an ECMAScript module, create a local package.json file with `{ "type": "module" }`.'),
   _0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled: diag(1484, 1 /* Error */, "_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled_1484", "'{0}' is a type and must be imported using a type-only import when 'verbatimModuleSyntax' is enabled."),
   _0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled: diag(1485, 1 /* Error */, "_0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimMo_1485", "'{0}' resolves to a type-only declaration and must be imported using a type-only import when 'verbatimModuleSyntax' is enabled."),
+  Decorator_used_before_export_here: diag(1486, 1 /* Error */, "Decorator_used_before_export_here_1486", "Decorator used before 'export' here."),
   The_types_of_0_are_incompatible_between_these_types: diag(2200, 1 /* Error */, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
   The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, 1 /* Error */, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
   Call_signature_return_types_0_and_1_are_incompatible: diag(
@@ -7530,7 +7537,7 @@ var Diagnostics = {
   You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder: diag(8035, 1 /* Error */, "You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder_8035", "You cannot rename elements that are defined in a 'node_modules' folder."),
   You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder: diag(8036, 1 /* Error */, "You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder_8036", "You cannot rename elements that are defined in another 'node_modules' folder."),
   Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files: diag(8037, 1 /* Error */, "Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files_8037", "Type satisfaction expressions can only be used in TypeScript files."),
-  Decorators_must_come_after_export_or_export_default_in_JavaScript_files: diag(8038, 1 /* Error */, "Decorators_must_come_after_export_or_export_default_in_JavaScript_files_8038", "Decorators must come after 'export' or 'export default' in JavaScript files."),
+  Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export: diag(8038, 1 /* Error */, "Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export_8038", "Decorators may not appear after 'export' or 'export default' if they also appear before 'export'."),
   Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9005, 1 /* Error */, "Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_9005", "Declaration emit for this file requires using private name '{0}'. An explicit type annotation may unblock declaration emit."),
   Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, 1 /* Error */, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."),
   JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17e3, 1 /* Error */, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."),
@@ -11650,101 +11657,400 @@ function getInternalEmitFlags(node) {
   return emitNode && emitNode.internalFlags || 0;
 }
 function getScriptTargetFeatures() {
-  return {
-    es2015: {
-      Array: ["find", "findIndex", "fill", "copyWithin", "entries", "keys", "values"],
-      RegExp: ["flags", "sticky", "unicode"],
-      Reflect: ["apply", "construct", "defineProperty", "deleteProperty", "get", " getOwnPropertyDescriptor", "getPrototypeOf", "has", "isExtensible", "ownKeys", "preventExtensions", "set", "setPrototypeOf"],
-      ArrayConstructor: ["from", "of"],
-      ObjectConstructor: ["assign", "getOwnPropertySymbols", "keys", "is", "setPrototypeOf"],
-      NumberConstructor: ["isFinite", "isInteger", "isNaN", "isSafeInteger", "parseFloat", "parseInt"],
-      Math: ["clz32", "imul", "sign", "log10", "log2", "log1p", "expm1", "cosh", "sinh", "tanh", "acosh", "asinh", "atanh", "hypot", "trunc", "fround", "cbrt"],
-      Map: ["entries", "keys", "values"],
-      Set: ["entries", "keys", "values"],
-      Promise: emptyArray,
-      PromiseConstructor: ["all", "race", "reject", "resolve"],
-      Symbol: ["for", "keyFor"],
-      WeakMap: ["entries", "keys", "values"],
-      WeakSet: ["entries", "keys", "values"],
-      Iterator: emptyArray,
-      AsyncIterator: emptyArray,
-      String: ["codePointAt", "includes", "endsWith", "normalize", "repeat", "startsWith", "anchor", "big", "blink", "bold", "fixed", "fontcolor", "fontsize", "italics", "link", "small", "strike", "sub", "sup"],
-      StringConstructor: ["fromCodePoint", "raw"]
-    },
-    es2016: {
-      Array: ["includes"]
-    },
-    es2017: {
-      Atomics: emptyArray,
-      SharedArrayBuffer: emptyArray,
-      String: ["padStart", "padEnd"],
-      ObjectConstructor: ["values", "entries", "getOwnPropertyDescriptors"],
-      DateTimeFormat: ["formatToParts"]
-    },
-    es2018: {
-      Promise: ["finally"],
-      RegExpMatchArray: ["groups"],
-      RegExpExecArray: ["groups"],
-      RegExp: ["dotAll"],
-      Intl: ["PluralRules"],
-      AsyncIterable: emptyArray,
-      AsyncIterableIterator: emptyArray,
-      AsyncGenerator: emptyArray,
-      AsyncGeneratorFunction: emptyArray,
-      NumberFormat: ["formatToParts"]
-    },
-    es2019: {
-      Array: ["flat", "flatMap"],
-      ObjectConstructor: ["fromEntries"],
-      String: ["trimStart", "trimEnd", "trimLeft", "trimRight"],
-      Symbol: ["description"]
-    },
-    es2020: {
-      BigInt: emptyArray,
-      BigInt64Array: emptyArray,
-      BigUint64Array: emptyArray,
-      PromiseConstructor: ["allSettled"],
-      SymbolConstructor: ["matchAll"],
-      String: ["matchAll"],
-      DataView: ["setBigInt64", "setBigUint64", "getBigInt64", "getBigUint64"],
-      RelativeTimeFormat: ["format", "formatToParts", "resolvedOptions"]
-    },
-    es2021: {
-      PromiseConstructor: ["any"],
-      String: ["replaceAll"]
-    },
-    es2022: {
-      Array: ["at"],
-      String: ["at"],
-      Int8Array: ["at"],
-      Uint8Array: ["at"],
-      Uint8ClampedArray: ["at"],
-      Int16Array: ["at"],
-      Uint16Array: ["at"],
-      Int32Array: ["at"],
-      Uint32Array: ["at"],
-      Float32Array: ["at"],
-      Float64Array: ["at"],
-      BigInt64Array: ["at"],
-      BigUint64Array: ["at"],
-      ObjectConstructor: ["hasOwn"],
-      Error: ["cause"]
-    },
-    es2023: {
-      Array: ["findLastIndex", "findLast"],
-      Int8Array: ["findLastIndex", "findLast"],
-      Uint8Array: ["findLastIndex", "findLast"],
-      Uint8ClampedArray: ["findLastIndex", "findLast"],
-      Int16Array: ["findLastIndex", "findLast"],
-      Uint16Array: ["findLastIndex", "findLast"],
-      Int32Array: ["findLastIndex", "findLast"],
-      Uint32Array: ["findLastIndex", "findLast"],
-      Float32Array: ["findLastIndex", "findLast"],
-      Float64Array: ["findLastIndex", "findLast"],
-      BigInt64Array: ["findLastIndex", "findLast"],
-      BigUint64Array: ["findLastIndex", "findLast"]
-    }
-  };
+  return new Map(Object.entries({
+    Array: new Map(Object.entries({
+      es2015: [
+        "find",
+        "findIndex",
+        "fill",
+        "copyWithin",
+        "entries",
+        "keys",
+        "values"
+      ],
+      es2016: [
+        "includes"
+      ],
+      es2019: [
+        "flat",
+        "flatMap"
+      ],
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Iterator: new Map(Object.entries({
+      es2015: emptyArray
+    })),
+    AsyncIterator: new Map(Object.entries({
+      es2015: emptyArray
+    })),
+    Atomics: new Map(Object.entries({
+      es2017: emptyArray
+    })),
+    SharedArrayBuffer: new Map(Object.entries({
+      es2017: emptyArray
+    })),
+    AsyncIterable: new Map(Object.entries({
+      es2018: emptyArray
+    })),
+    AsyncIterableIterator: new Map(Object.entries({
+      es2018: emptyArray
+    })),
+    AsyncGenerator: new Map(Object.entries({
+      es2018: emptyArray
+    })),
+    AsyncGeneratorFunction: new Map(Object.entries({
+      es2018: emptyArray
+    })),
+    RegExp: new Map(Object.entries({
+      es2015: [
+        "flags",
+        "sticky",
+        "unicode"
+      ],
+      es2018: [
+        "dotAll"
+      ]
+    })),
+    Reflect: new Map(Object.entries({
+      es2015: [
+        "apply",
+        "construct",
+        "defineProperty",
+        "deleteProperty",
+        "get",
+        " getOwnPropertyDescriptor",
+        "getPrototypeOf",
+        "has",
+        "isExtensible",
+        "ownKeys",
+        "preventExtensions",
+        "set",
+        "setPrototypeOf"
+      ]
+    })),
+    ArrayConstructor: new Map(Object.entries({
+      es2015: [
+        "from",
+        "of"
+      ]
+    })),
+    ObjectConstructor: new Map(Object.entries({
+      es2015: [
+        "assign",
+        "getOwnPropertySymbols",
+        "keys",
+        "is",
+        "setPrototypeOf"
+      ],
+      es2017: [
+        "values",
+        "entries",
+        "getOwnPropertyDescriptors"
+      ],
+      es2019: [
+        "fromEntries"
+      ],
+      es2022: [
+        "hasOwn"
+      ]
+    })),
+    NumberConstructor: new Map(Object.entries({
+      es2015: [
+        "isFinite",
+        "isInteger",
+        "isNaN",
+        "isSafeInteger",
+        "parseFloat",
+        "parseInt"
+      ]
+    })),
+    Math: new Map(Object.entries({
+      es2015: [
+        "clz32",
+        "imul",
+        "sign",
+        "log10",
+        "log2",
+        "log1p",
+        "expm1",
+        "cosh",
+        "sinh",
+        "tanh",
+        "acosh",
+        "asinh",
+        "atanh",
+        "hypot",
+        "trunc",
+        "fround",
+        "cbrt"
+      ]
+    })),
+    Map: new Map(Object.entries({
+      es2015: [
+        "entries",
+        "keys",
+        "values"
+      ]
+    })),
+    Set: new Map(Object.entries({
+      es2015: [
+        "entries",
+        "keys",
+        "values"
+      ]
+    })),
+    PromiseConstructor: new Map(Object.entries({
+      es2015: [
+        "all",
+        "race",
+        "reject",
+        "resolve"
+      ],
+      es2020: [
+        "allSettled"
+      ],
+      es2021: [
+        "any"
+      ]
+    })),
+    Symbol: new Map(Object.entries({
+      es2015: [
+        "for",
+        "keyFor"
+      ],
+      es2019: [
+        "description"
+      ]
+    })),
+    WeakMap: new Map(Object.entries({
+      es2015: [
+        "entries",
+        "keys",
+        "values"
+      ]
+    })),
+    WeakSet: new Map(Object.entries({
+      es2015: [
+        "entries",
+        "keys",
+        "values"
+      ]
+    })),
+    String: new Map(Object.entries({
+      es2015: [
+        "codePointAt",
+        "includes",
+        "endsWith",
+        "normalize",
+        "repeat",
+        "startsWith",
+        "anchor",
+        "big",
+        "blink",
+        "bold",
+        "fixed",
+        "fontcolor",
+        "fontsize",
+        "italics",
+        "link",
+        "small",
+        "strike",
+        "sub",
+        "sup"
+      ],
+      es2017: [
+        "padStart",
+        "padEnd"
+      ],
+      es2019: [
+        "trimStart",
+        "trimEnd",
+        "trimLeft",
+        "trimRight"
+      ],
+      es2020: [
+        "matchAll"
+      ],
+      es2021: [
+        "replaceAll"
+      ],
+      es2022: [
+        "at"
+      ]
+    })),
+    StringConstructor: new Map(Object.entries({
+      es2015: [
+        "fromCodePoint",
+        "raw"
+      ]
+    })),
+    DateTimeFormat: new Map(Object.entries({
+      es2017: [
+        "formatToParts"
+      ]
+    })),
+    Promise: new Map(Object.entries({
+      es2015: emptyArray,
+      es2018: [
+        "finally"
+      ]
+    })),
+    RegExpMatchArray: new Map(Object.entries({
+      es2018: [
+        "groups"
+      ]
+    })),
+    RegExpExecArray: new Map(Object.entries({
+      es2018: [
+        "groups"
+      ]
+    })),
+    Intl: new Map(Object.entries({
+      es2018: [
+        "PluralRules"
+      ]
+    })),
+    NumberFormat: new Map(Object.entries({
+      es2018: [
+        "formatToParts"
+      ]
+    })),
+    SymbolConstructor: new Map(Object.entries({
+      es2020: [
+        "matchAll"
+      ]
+    })),
+    DataView: new Map(Object.entries({
+      es2020: [
+        "setBigInt64",
+        "setBigUint64",
+        "getBigInt64",
+        "getBigUint64"
+      ]
+    })),
+    BigInt: new Map(Object.entries({
+      es2020: emptyArray
+    })),
+    RelativeTimeFormat: new Map(Object.entries({
+      es2020: [
+        "format",
+        "formatToParts",
+        "resolvedOptions"
+      ]
+    })),
+    Int8Array: new Map(Object.entries({
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Uint8Array: new Map(Object.entries({
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Uint8ClampedArray: new Map(Object.entries({
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Int16Array: new Map(Object.entries({
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Uint16Array: new Map(Object.entries({
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Int32Array: new Map(Object.entries({
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Uint32Array: new Map(Object.entries({
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Float32Array: new Map(Object.entries({
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Float64Array: new Map(Object.entries({
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    BigInt64Array: new Map(Object.entries({
+      es2020: emptyArray,
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    BigUint64Array: new Map(Object.entries({
+      es2020: emptyArray,
+      es2022: [
+        "at"
+      ],
+      es2023: [
+        "findLastIndex",
+        "findLast"
+      ]
+    })),
+    Error: new Map(Object.entries({
+      es2022: [
+        "cause"
+      ]
+    }))
+  }));
 }
 function getLiteralText(node, sourceFile, flags) {
   var _a2;
@@ -22501,14 +22807,114 @@ function createEmitHelperFactory(context) {
       factory2.createPropertyAssignment(factory2.createIdentifier("name"), contextIn.name)
     ]);
   }
+  function createESDecorateClassElementAccessGetMethod(elementName) {
+    const accessor = elementName.computed ? factory2.createElementAccessExpression(factory2.createIdentifier("obj"), elementName.name) : factory2.createPropertyAccessExpression(factory2.createIdentifier("obj"), elementName.name);
+    return factory2.createPropertyAssignment(
+      "get",
+      factory2.createArrowFunction(
+        /*modifiers*/
+        void 0,
+        /*typeParameters*/
+        void 0,
+        [factory2.createParameterDeclaration(
+          /*modifiers*/
+          void 0,
+          /*dotDotDotToken*/
+          void 0,
+          factory2.createIdentifier("obj")
+        )],
+        /*type*/
+        void 0,
+        /*equalsGreaterThanToken*/
+        void 0,
+        accessor
+      )
+    );
+  }
+  function createESDecorateClassElementAccessSetMethod(elementName) {
+    const accessor = elementName.computed ? factory2.createElementAccessExpression(factory2.createIdentifier("obj"), elementName.name) : factory2.createPropertyAccessExpression(factory2.createIdentifier("obj"), elementName.name);
+    return factory2.createPropertyAssignment(
+      "set",
+      factory2.createArrowFunction(
+        /*modifiers*/
+        void 0,
+        /*typeParameters*/
+        void 0,
+        [
+          factory2.createParameterDeclaration(
+            /*modifiers*/
+            void 0,
+            /*dotDotDotToken*/
+            void 0,
+            factory2.createIdentifier("obj")
+          ),
+          factory2.createParameterDeclaration(
+            /*modifiers*/
+            void 0,
+            /*dotDotDotToken*/
+            void 0,
+            factory2.createIdentifier("value")
+          )
+        ],
+        /*type*/
+        void 0,
+        /*equalsGreaterThanToken*/
+        void 0,
+        factory2.createBlock([
+          factory2.createExpressionStatement(
+            factory2.createAssignment(
+              accessor,
+              factory2.createIdentifier("value")
+            )
+          )
+        ])
+      )
+    );
+  }
+  function createESDecorateClassElementAccessHasMethod(elementName) {
+    const propertyName = elementName.computed ? elementName.name : isIdentifier(elementName.name) ? factory2.createStringLiteralFromNode(elementName.name) : elementName.name;
+    return factory2.createPropertyAssignment(
+      "has",
+      factory2.createArrowFunction(
+        /*modifiers*/
+        void 0,
+        /*typeParameters*/
+        void 0,
+        [factory2.createParameterDeclaration(
+          /*modifiers*/
+          void 0,
+          /*dotDotDotToken*/
+          void 0,
+          factory2.createIdentifier("obj")
+        )],
+        /*type*/
+        void 0,
+        /*equalsGreaterThanToken*/
+        void 0,
+        factory2.createBinaryExpression(
+          propertyName,
+          101 /* InKeyword */,
+          factory2.createIdentifier("obj")
+        )
+      )
+    );
+  }
+  function createESDecorateClassElementAccessObject(name, access) {
+    const properties = [];
+    properties.push(createESDecorateClassElementAccessHasMethod(name));
+    if (access.get)
+      properties.push(createESDecorateClassElementAccessGetMethod(name));
+    if (access.set)
+      properties.push(createESDecorateClassElementAccessSetMethod(name));
+    return factory2.createObjectLiteralExpression(properties);
+  }
   function createESDecorateClassElementContextObject(contextIn) {
     return factory2.createObjectLiteralExpression([
       factory2.createPropertyAssignment(factory2.createIdentifier("kind"), factory2.createStringLiteral(contextIn.kind)),
       factory2.createPropertyAssignment(factory2.createIdentifier("name"), contextIn.name.computed ? contextIn.name.name : factory2.createStringLiteralFromNode(contextIn.name.name)),
       factory2.createPropertyAssignment(factory2.createIdentifier("static"), contextIn.static ? factory2.createTrue() : factory2.createFalse()),
-      factory2.createPropertyAssignment(factory2.createIdentifier("private"), contextIn.private ? factory2.createTrue() : factory2.createFalse())
-      // Disabled, pending resolution of https://github.com/tc39/proposal-decorators/issues/494
-      // factory.createPropertyAssignment(factory.createIdentifier("access"), createESDecorateClassElementAccessObject(contextIn.name, contextIn.access))
+      factory2.createPropertyAssignment(factory2.createIdentifier("private"), contextIn.private ? factory2.createTrue() : factory2.createFalse()),
+      factory2.createPropertyAssignment(factory2.createIdentifier("access"), createESDecorateClassElementAccessObject(contextIn.name, contextIn.access))
     ]);
   }
   function createESDecorateContextObject(contextIn) {
@@ -28822,6 +29228,12 @@ var Parser;
       case 114 /* VoidKeyword */:
         return parseVoidExpression();
       case 29 /* LessThanToken */:
+        if (languageVariant === 1 /* JSX */) {
+          return parseJsxElementOrSelfClosingElementOrFragment(
+            /*inExpressionContext*/
+            true
+          );
+        }
         return parseTypeAssertion();
       case 133 /* AwaitKeyword */:
         if (isAwaitExpression2()) {
@@ -29193,6 +29605,7 @@ var Parser;
     return finishNode(factory2.createJsxJsxClosingFragment(), pos);
   }
   function parseTypeAssertion() {
+    Debug.assert(scriptKind === 3 /* TS */, "Type assertions should never be parsed outside of TS; they should either be comparisons or JSX.");
     const pos = getNodePos();
     parseExpected(29 /* LessThanToken */);
     const type = parseType();
@@ -30543,17 +30956,25 @@ var Parser;
   function parseModifiers(allowDecorators, permitConstAsModifier, stopOnStartOfClassStaticBlock) {
     const pos = getNodePos();
     let list;
-    let modifier, hasSeenStaticModifier = false;
+    let decorator, modifier, hasSeenStaticModifier = false, hasLeadingModifier = false, hasTrailingDecorator = false;
+    if (allowDecorators && token() === 59 /* AtToken */) {
+      while (decorator = tryParseDecorator()) {
+        list = append(list, decorator);
+      }
+    }
     while (modifier = tryParseModifier(hasSeenStaticModifier, permitConstAsModifier, stopOnStartOfClassStaticBlock)) {
       if (modifier.kind === 124 /* StaticKeyword */)
         hasSeenStaticModifier = true;
       list = append(list, modifier);
+      hasLeadingModifier = true;
     }
-    if (allowDecorators && token() === 59 /* AtToken */) {
-      let decorator;
+    if (hasLeadingModifier && allowDecorators && token() === 59 /* AtToken */) {
       while (decorator = tryParseDecorator()) {
         list = append(list, decorator);
+        hasTrailingDecorator = true;
       }
+    }
+    if (hasTrailingDecorator) {
       while (modifier = tryParseModifier(hasSeenStaticModifier, permitConstAsModifier, stopOnStartOfClassStaticBlock)) {
         if (modifier.kind === 124 /* StaticKeyword */)
           hasSeenStaticModifier = true;
@@ -55310,7 +55731,7 @@ function createTypeChecker(host) {
     }
   }
   function removeStringLiteralsMatchedByTemplateLiterals(types) {
-    const templates = filter(types, isPatternLiteralType);
+    const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t));
     if (templates.length) {
       let i = types.length;
       while (i > 0) {
@@ -63833,10 +64254,12 @@ function createTypeChecker(host) {
   }
   function isConstantReference(node) {
     switch (node.kind) {
-      case 79 /* Identifier */: {
-        const symbol = getResolvedSymbol(node);
-        return isConstVariable(symbol) || isParameterOrCatchClauseVariable(symbol) && !isSymbolAssigned(symbol);
-      }
+      case 79 /* Identifier */:
+        if (!isThisInTypeQuery(node)) {
+          const symbol = getResolvedSymbol(node);
+          return isConstVariable(symbol) || isParameterOrCatchClauseVariable(symbol) && !isSymbolAssigned(symbol);
+        }
+        break;
       case 208 /* PropertyAccessExpression */:
       case 209 /* ElementAccessExpression */:
         return isConstantReference(node.expression) && isReadonlySymbol(getNodeLinks(node).resolvedSymbol || unknownSymbol);
@@ -68080,26 +68503,22 @@ function createTypeChecker(host) {
   function getSuggestedLibForNonExistentName(name) {
     const missingName = diagnosticName(name);
     const allFeatures = getScriptTargetFeatures();
-    const libTargets = getOwnKeys(allFeatures);
-    for (const libTarget of libTargets) {
-      const containingTypes = getOwnKeys(allFeatures[libTarget]);
-      if (containingTypes !== void 0 && contains(containingTypes, missingName)) {
-        return libTarget;
-      }
-    }
+    const typeFeatures = allFeatures.get(missingName);
+    return typeFeatures && firstIterator(typeFeatures.keys());
   }
   function getSuggestedLibForNonExistentProperty(missingProperty, containingType) {
     const container = getApparentType(containingType).symbol;
     if (!container) {
       return void 0;
     }
+    const containingTypeName = symbolName(container);
     const allFeatures = getScriptTargetFeatures();
-    const libTargets = getOwnKeys(allFeatures);
-    for (const libTarget of libTargets) {
-      const featuresOfLib = allFeatures[libTarget];
-      const featuresOfContainingType = featuresOfLib[symbolName(container)];
-      if (featuresOfContainingType !== void 0 && contains(featuresOfContainingType, missingProperty)) {
-        return libTarget;
+    const typeFeatures = allFeatures.get(containingTypeName);
+    if (typeFeatures) {
+      for (const [libTarget, featuresOfType] of typeFeatures) {
+        if (contains(featuresOfType, missingProperty)) {
+          return libTarget;
+        }
       }
     }
   }
@@ -80557,6 +80976,7 @@ function createTypeChecker(host) {
     let lastStatic, lastDeclare, lastAsync, lastOverride, firstDecorator;
     let flags = 0 /* None */;
     let sawExportBeforeDecorators = false;
+    let hasLeadingDecorators = false;
     for (const modifier of node.modifiers) {
       if (isDecorator(modifier)) {
         if (!nodeCanBeDecorated(legacyDecorators, node, node.parent, node.parent.parent)) {
@@ -80574,8 +80994,22 @@ function createTypeChecker(host) {
         if (flags & ~(1025 /* ExportDefault */ | 131072 /* Decorator */)) {
           return grammarErrorOnNode(modifier, Diagnostics.Decorators_are_not_valid_here);
         }
+        if (hasLeadingDecorators && flags & 126975 /* Modifier */) {
+          Debug.assertIsDefined(firstDecorator);
+          const sourceFile = getSourceFileOfNode(modifier);
+          if (!hasParseDiagnostics(sourceFile)) {
+            addRelatedInfo(
+              error(modifier, Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export),
+              createDiagnosticForNode(firstDecorator, Diagnostics.Decorator_used_before_export_here)
+            );
+            return true;
+          }
+          return false;
+        }
         flags |= 131072 /* Decorator */;
-        if (flags & 1 /* Export */) {
+        if (!(flags & 126975 /* Modifier */)) {
+          hasLeadingDecorators = true;
+        } else if (flags & 1 /* Export */) {
           sawExportBeforeDecorators = true;
         }
         firstDecorator != null ? firstDecorator : firstDecorator = modifier;
@@ -113502,11 +113936,19 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
               diagnostics.push(createDiagnosticForNode2(parent.modifiers[decoratorIndex], Diagnostics.Decorators_are_not_valid_here));
             } else if (isClassDeclaration(parent)) {
               const exportIndex = findIndex(parent.modifiers, isExportModifier);
-              const defaultIndex = findIndex(parent.modifiers, isDefaultModifier);
-              if (exportIndex >= 0 && decoratorIndex < exportIndex) {
-                diagnostics.push(createDiagnosticForNode2(parent.modifiers[decoratorIndex], Diagnostics.Decorators_must_come_after_export_or_export_default_in_JavaScript_files));
-              } else if (defaultIndex >= 0 && decoratorIndex < defaultIndex) {
-                diagnostics.push(createDiagnosticForNode2(parent.modifiers[decoratorIndex], Diagnostics.Decorators_are_not_valid_here));
+              if (exportIndex >= 0) {
+                const defaultIndex = findIndex(parent.modifiers, isDefaultModifier);
+                if (decoratorIndex > exportIndex && defaultIndex >= 0 && decoratorIndex < defaultIndex) {
+                  diagnostics.push(createDiagnosticForNode2(parent.modifiers[decoratorIndex], Diagnostics.Decorators_are_not_valid_here));
+                } else if (exportIndex >= 0 && decoratorIndex < exportIndex) {
+                  const trailingDecoratorIndex = findIndex(parent.modifiers, isDecorator, exportIndex);
+                  if (trailingDecoratorIndex >= 0) {
+                    diagnostics.push(addRelatedInfo(
+                      createDiagnosticForNode2(parent.modifiers[trailingDecoratorIndex], Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export),
+                      createDiagnosticForNode2(parent.modifiers[decoratorIndex], Diagnostics.Decorator_used_before_export_here)
+                    ));
+                  }
+                }
               }
             }
           }