typescript 5.0.0-dev.20230209 → 5.0.0-dev.20230211

package/lib/tsserver.js

@@ -2287,7 +2287,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230209`;
+var version = `${versionMajorMinor}.0-dev.20230211`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -9643,6 +9643,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(
@@ -10999,7 +11000,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'."),
@@ -15334,101 +15335,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"
+      ]
+    }))
+  }));
 }
 var GetLiteralTextFlags = /* @__PURE__ */ ((GetLiteralTextFlags2) => {
   GetLiteralTextFlags2[GetLiteralTextFlags2["None"] = 0] = "None";
@@ -26682,14 +26982,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) {
@@ -33143,6 +33543,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()) {
@@ -33514,6 +33920,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();
@@ -34864,17 +35271,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;
@@ -47456,6 +47871,7 @@ function createTypeChecker(host) {
   let flowTypeCache;
   const contextualTypeNodes = [];
   const contextualTypes = [];
+  const contextualIsCache = [];
   let contextualTypeCount = 0;
   const inferenceContextNodes = [];
   const inferenceContexts = [];
@@ -59892,7 +60308,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) {
@@ -62417,7 +62833,12 @@ function createTypeChecker(host) {
     }
   }
   function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
-    pushContextualType(next, sourcePropType);
+    pushContextualType(
+      next,
+      sourcePropType,
+      /*isCache*/
+      false
+    );
     const result = checkExpressionForMutableLocation(next, 1 /* Contextual */);
     popContextualType();
     return result;
@@ -62725,7 +63146,12 @@ function createTypeChecker(host) {
     if (isTupleLikeType(source)) {
       return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
     }
-    pushContextualType(node, target);
+    pushContextualType(
+      node,
+      target,
+      /*isCache*/
+      false
+    );
     const tupleizedType = checkArrayLiteral(
       node,
       1 /* Contextual */,
@@ -68415,10 +68841,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);
@@ -70772,11 +71200,13 @@ function createTypeChecker(host) {
     if (node.flags & 33554432 /* InWithStatement */) {
       return void 0;
     }
-    const index = findContextualNode(node);
+    const index = findContextualNode(
+      node,
+      /*includeCaches*/
+      !contextFlags
+    );
     if (index >= 0) {
-      const cached = contextualTypes[index];
-      if (cached || !contextFlags)
-        return cached;
+      return contextualTypes[index];
     }
     const { parent: parent2 } = node;
     switch (parent2.kind) {
@@ -70847,17 +71277,30 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function pushContextualType(node, type) {
+  function pushCachedContextualType(node) {
+    pushContextualType(
+      node,
+      getContextualType2(
+        node,
+        /*contextFlags*/
+        void 0
+      ),
+      /*isCache*/
+      true
+    );
+  }
+  function pushContextualType(node, type, isCache) {
     contextualTypeNodes[contextualTypeCount] = node;
     contextualTypes[contextualTypeCount] = type;
+    contextualIsCache[contextualTypeCount] = isCache;
     contextualTypeCount++;
   }
   function popContextualType() {
     contextualTypeCount--;
   }
-  function findContextualNode(node) {
+  function findContextualNode(node, includeCaches) {
     for (let i = contextualTypeCount - 1; i >= 0; i--) {
-      if (node === contextualTypeNodes[i]) {
+      if (node === contextualTypeNodes[i] && (includeCaches || !contextualIsCache[i])) {
         return i;
       }
     }
@@ -70880,7 +71323,11 @@ function createTypeChecker(host) {
   }
   function getContextualJsxElementAttributesType(node, contextFlags) {
     if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
-      const index = findContextualNode(node.parent);
+      const index = findContextualNode(
+        node.parent,
+        /*includeCaches*/
+        !contextFlags
+      );
       if (index >= 0) {
         return contextualTypes[index];
       }
@@ -71151,11 +71598,7 @@ function createTypeChecker(host) {
     const elementCount = elements.length;
     const elementTypes = [];
     const elementFlags = [];
-    pushContextualType(node, getContextualType2(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const inDestructuringPattern = isAssignmentTarget(node);
     const inConstContext = isConstContext(node);
     const contextualType = getApparentTypeOfContextualType(
@@ -71318,11 +71761,7 @@ function createTypeChecker(host) {
     let propertiesTable = createSymbolTable();
     let propertiesArray = [];
     let spread = emptyObjectType;
-    pushContextualType(node, getContextualType2(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const contextualType = getApparentTypeOfContextualType(
       node,
       /*contextFlags*/
@@ -72662,26 +73101,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;
+        }
       }
     }
   }
@@ -77337,14 +77772,19 @@ function createTypeChecker(host) {
     return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
   }
   function getContextNode2(node) {
-    if (node.kind === 289 /* JsxAttributes */ && !isJsxSelfClosingElement(node.parent)) {
+    if (isJsxAttributes(node) && !isJsxSelfClosingElement(node.parent)) {
       return node.parent.parent;
     }
     return node;
   }
   function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
     const contextNode = getContextNode2(node);
-    pushContextualType(contextNode, contextualType);
+    pushContextualType(
+      contextNode,
+      contextualType,
+      /*isCache*/
+      false
+    );
     pushInferenceContext(contextNode, inferenceContext);
     const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
     if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
@@ -77685,7 +78125,12 @@ function createTypeChecker(host) {
     if (links.contextFreeType) {
       return links.contextFreeType;
     }
-    pushContextualType(node, anyType);
+    pushContextualType(
+      node,
+      anyType,
+      /*isCache*/
+      false
+    );
     const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
     popContextualType();
     return type;
@@ -85139,6 +85584,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)) {
@@ -85156,8 +85602,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;
@@ -118320,11 +118780,19 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
               diagnostics.push(createDiagnosticForNode2(parent2.modifiers[decoratorIndex], Diagnostics.Decorators_are_not_valid_here));
             } else if (isClassDeclaration(parent2)) {
               const exportIndex = findIndex(parent2.modifiers, isExportModifier);
-              const defaultIndex = findIndex(parent2.modifiers, isDefaultModifier);
-              if (exportIndex >= 0 && decoratorIndex < exportIndex) {
-                diagnostics.push(createDiagnosticForNode2(parent2.modifiers[decoratorIndex], Diagnostics.Decorators_must_come_after_export_or_export_default_in_JavaScript_files));
-              } else if (defaultIndex >= 0 && decoratorIndex < defaultIndex) {
-                diagnostics.push(createDiagnosticForNode2(parent2.modifiers[decoratorIndex], Diagnostics.Decorators_are_not_valid_here));
+              if (exportIndex >= 0) {
+                const defaultIndex = findIndex(parent2.modifiers, isDefaultModifier);
+                if (decoratorIndex > exportIndex && defaultIndex >= 0 && decoratorIndex < defaultIndex) {
+                  diagnostics.push(createDiagnosticForNode2(parent2.modifiers[decoratorIndex], Diagnostics.Decorators_are_not_valid_here));
+                } else if (exportIndex >= 0 && decoratorIndex < exportIndex) {
+                  const trailingDecoratorIndex = findIndex(parent2.modifiers, isDecorator, exportIndex);
+                  if (trailingDecoratorIndex >= 0) {
+                    diagnostics.push(addRelatedInfo(
+                      createDiagnosticForNode2(parent2.modifiers[trailingDecoratorIndex], Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export),
+                      createDiagnosticForNode2(parent2.modifiers[decoratorIndex], Diagnostics.Decorator_used_before_export_here)
+                    ));
+                  }
+                }
               }
             }
           }
@@ -129430,10 +129898,13 @@ function needsNameFromDeclaration(symbol) {
   return !(symbol.flags & 33554432 /* Transient */) && (symbol.escapedName === "export=" /* ExportEquals */ || symbol.escapedName === "default" /* Default */);
 }
 function getDefaultLikeExportNameFromDeclaration(symbol) {
-  return firstDefined(symbol.declarations, (d) => {
-    var _a2;
-    return isExportAssignment(d) ? (_a2 = tryCast(skipOuterExpressions(d.expression), isIdentifier)) == null ? void 0 : _a2.text : void 0;
-  });
+  return firstDefined(
+    symbol.declarations,
+    (d) => {
+      var _a2, _b;
+      return isExportAssignment(d) ? (_a2 = tryCast(skipOuterExpressions(d.expression), isIdentifier)) == null ? void 0 : _a2.text : (_b = tryCast(getNameOfDeclaration(d), isIdentifier)) == null ? void 0 : _b.text;
+    }
+  );
 }
 function getSymbolParentOrFail(symbol) {
   var _a2;
@@ -140792,6 +141263,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
       sourceFile,
       symbol,
       symbolName2,
+      moduleSymbol,
       /*isJsxTagName*/
       false,
       program,
@@ -140803,7 +141275,6 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
     const fix = getImportFixForSymbol(
       sourceFile,
       Debug.checkDefined(exportInfo),
-      moduleSymbol,
       program,
       /*position*/
       void 0,
@@ -140981,13 +141452,19 @@ function createImportSpecifierResolver(importingFile, program, host, preferences
     return result && { ...result, computedWithoutCacheCount };
   }
 }
-function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
+function getImportCompletionAction(targetSymbol, moduleSymbol, exportMapKey, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
   const compilerOptions = program.getCompilerOptions();
-  const exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, isJsxTagName, program, host, preferences, cancellationToken);
-  Debug.assertIsDefined(exportInfos);
+  let exportInfos;
+  if (exportMapKey) {
+    exportInfos = getExportInfoMap(sourceFile, host, program, preferences, cancellationToken).get(sourceFile.path, exportMapKey);
+    Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified exportMapKey");
+  } else {
+    exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, symbolName2, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, moduleSymbol, isJsxTagName, program, host, preferences, cancellationToken);
+    Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified symbol / moduleSymbol");
+  }
   const useRequire = shouldUseRequire(sourceFile, program);
   const isValidTypeOnlyUseSite = isValidTypeOnlyAliasUseSite(getTokenAtPosition(sourceFile, position));
-  const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
+  const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
   return {
     moduleSpecifier: fix.moduleSpecifier,
     codeAction: codeFixActionToCodeAction(codeActionForFix(
@@ -141009,23 +141486,22 @@ function getPromoteTypeOnlyCompletionAction(sourceFile, symbolToken, program, ho
   const includeSymbolNameInDescription = symbolName2 !== symbolToken.text;
   return fix && codeFixActionToCodeAction(codeActionForFix({ host, formatContext, preferences }, sourceFile, symbolName2, fix, includeSymbolNameInDescription, compilerOptions, preferences));
 }
-function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
-  Debug.assert(exportInfos.some((info) => info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol), "Some exportInfo should match the specified moduleSymbol");
+function getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
   const packageJsonImportFilter = createPackageJsonImportFilter(sourceFile, preferences, host);
   return getBestFix(getImportFixes(exportInfos, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes, sourceFile, program, packageJsonImportFilter, host);
 }
 function codeFixActionToCodeAction({ description: description2, changes, commands }) {
   return { description: description2, changes, commands };
 }
-function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, preferCapitalized, program, host, preferences, cancellationToken) {
+function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, moduleSymbol, preferCapitalized, program, host, preferences, cancellationToken) {
   const getChecker = createGetChecker(program, host);
   return getExportInfoMap(importingFile, host, program, preferences, cancellationToken).search(importingFile.path, preferCapitalized, (name) => name === symbolName2, (info) => {
-    if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol) {
+    if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol && info.some((i) => i.moduleSymbol === moduleSymbol || i.symbol.parent === moduleSymbol)) {
       return info;
     }
   });
 }
-function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) {
+function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program, host) {
   var _a2, _b;
   const compilerOptions = program.getCompilerOptions();
   const mainProgramInfo = getInfoWithChecker(
@@ -141047,7 +141523,7 @@ function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) {
     if (defaultInfo && skipAlias(defaultInfo.symbol, checker) === symbol) {
       return { symbol: defaultInfo.symbol, moduleSymbol, moduleFileName: void 0, exportKind: defaultInfo.exportKind, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
     }
-    const named = checker.tryGetMemberInModuleExportsAndProperties(symbol.name, moduleSymbol);
+    const named = checker.tryGetMemberInModuleExportsAndProperties(symbolName2, moduleSymbol);
     if (named && skipAlias(named, checker) === symbol) {
       return { symbol: named, moduleSymbol, moduleFileName: void 0, exportKind: 0 /* Named */, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
     }
@@ -148706,6 +149182,7 @@ function originToCompletionEntryData(origin) {
   if (originIsResolvedExport(origin)) {
     const resolvedData = {
       exportName: origin.exportName,
+      exportMapKey: origin.exportMapKey,
       moduleSpecifier: origin.moduleSpecifier,
       ambientModuleName,
       fileName: origin.fileName,
@@ -148729,6 +149206,7 @@ function completionEntryDataToSymbolOriginInfo(data, completionName, moduleSymbo
     const resolvedOrigin = {
       kind: 32 /* ResolvedExport */,
       exportName: data.exportName,
+      exportMapKey: data.exportMapKey,
       moduleSpecifier: data.moduleSpecifier,
       symbolName: completionName,
       fileName: data.fileName,
@@ -149107,6 +149585,7 @@ function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextTo
   const { moduleSpecifier, codeAction } = ts_codefix_exports.getImportCompletionAction(
     targetSymbol,
     moduleSymbol,
+    data == null ? void 0 : data.exportMapKey,
     sourceFile,
     name,
     isJsxOpeningTagName,
@@ -149805,16 +150284,16 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
             if (detailsEntryId && !some(info, (i) => detailsEntryId.source === stripQuotes(i.moduleSymbol.name))) {
               return;
             }
-            const firstImportableExportInfo = find(info, isImportableExportInfo);
-            if (!firstImportableExportInfo) {
+            info = filter(info, isImportableExportInfo);
+            if (!info.length) {
               return;
             }
             const result = context.tryResolve(info, isFromAmbientModule) || {};
             if (result === "failed")
               return;
-            let exportInfo2 = firstImportableExportInfo, moduleSpecifier;
+            let exportInfo2 = info[0], moduleSpecifier;
             if (result !== "skipped") {
-              ({ exportInfo: exportInfo2 = firstImportableExportInfo, moduleSpecifier } = result);
+              ({ exportInfo: exportInfo2 = info[0], moduleSpecifier } = result);
             }
             const isDefaultExport = exportInfo2.exportKind === 1 /* Default */;
             const symbol = isDefaultExport && getLocalSymbolForExportDefault(exportInfo2.symbol) || exportInfo2.symbol;
@@ -149978,7 +150457,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     return false;
   }
   function isInStringOrRegularExpressionOrTemplateLiteral(contextToken2) {
-    return (isRegularExpressionLiteral(contextToken2) || isStringTextContainingNode(contextToken2)) && (rangeContainsPositionExclusive(createTextRangeFromSpan(createTextSpanFromNode(contextToken2)), position) || position === contextToken2.end && (!!contextToken2.isUnterminated || isRegularExpressionLiteral(contextToken2)));
+    return (isRegularExpressionLiteral(contextToken2) || isStringTextContainingNode(contextToken2)) && (rangeContainsPositionExclusive(contextToken2, position) || position === contextToken2.end && (!!contextToken2.isUnterminated || isRegularExpressionLiteral(contextToken2)));
   }
   function tryGetObjectTypeLiteralInTypeArgumentCompletionSymbols() {
     const typeLiteralNode = tryGetTypeLiteralNode(contextToken);