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

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20230209`;
+      version = `${versionMajorMinor}.0-dev.20230211`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7466,6 +7466,7 @@ ${lanes.join("\n")}
         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(
@@ -8822,7 +8823,7 @@ ${lanes.join("\n")}
         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'."),
@@ -13168,101 +13169,400 @@ ${lanes.join("\n")}
     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;
@@ -24552,14 +24852,114 @@ ${lanes.join("\n")}
         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) {
@@ -31254,6 +31654,12 @@ ${lanes.join("\n")}
             case 114 /* VoidKeyword */:
               return parseVoidExpression();
             case 29 /* LessThanToken */:
+              if (languageVariant === 1 /* JSX */) {
+                return parseJsxElementOrSelfClosingElementOrFragment(
+                  /*inExpressionContext*/
+                  true
+                );
+              }
               return parseTypeAssertion();
             case 133 /* AwaitKeyword */:
               if (isAwaitExpression2()) {
@@ -31625,6 +32031,7 @@ ${lanes.join("\n")}
           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();
@@ -32975,17 +33382,25 @@ ${lanes.join("\n")}
         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;
@@ -45266,6 +45681,7 @@ ${lanes.join("\n")}
     let flowTypeCache;
     const contextualTypeNodes = [];
     const contextualTypes = [];
+    const contextualIsCache = [];
     let contextualTypeCount = 0;
     const inferenceContextNodes = [];
     const inferenceContexts = [];
@@ -57702,7 +58118,7 @@ ${lanes.join("\n")}
       }
     }
     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) {
@@ -60227,7 +60643,12 @@ ${lanes.join("\n")}
       }
     }
     function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
-      pushContextualType(next, sourcePropType);
+      pushContextualType(
+        next,
+        sourcePropType,
+        /*isCache*/
+        false
+      );
       const result = checkExpressionForMutableLocation(next, 1 /* Contextual */);
       popContextualType();
       return result;
@@ -60535,7 +60956,12 @@ ${lanes.join("\n")}
       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 */,
@@ -66225,10 +66651,12 @@ ${lanes.join("\n")}
     }
     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);
@@ -68582,11 +69010,13 @@ ${lanes.join("\n")}
       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) {
@@ -68657,17 +69087,30 @@ ${lanes.join("\n")}
       }
       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;
         }
       }
@@ -68690,7 +69133,11 @@ ${lanes.join("\n")}
     }
     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];
         }
@@ -68961,11 +69408,7 @@ ${lanes.join("\n")}
       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(
@@ -69128,11 +69571,7 @@ ${lanes.join("\n")}
       let propertiesTable = createSymbolTable();
       let propertiesArray = [];
       let spread = emptyObjectType;
-      pushContextualType(node, getContextualType2(
-        node,
-        /*contextFlags*/
-        void 0
-      ));
+      pushCachedContextualType(node);
       const contextualType = getApparentTypeOfContextualType(
         node,
         /*contextFlags*/
@@ -70472,26 +70911,22 @@ ${lanes.join("\n")}
     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;
+          }
         }
       }
     }
@@ -75147,14 +75582,19 @@ ${lanes.join("\n")}
       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) {
@@ -75495,7 +75935,12 @@ ${lanes.join("\n")}
       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;
@@ -82949,6 +83394,7 @@ ${lanes.join("\n")}
       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)) {
@@ -82966,8 +83412,22 @@ ${lanes.join("\n")}
           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;
@@ -116338,11 +116798,19 @@ ${lanes.join("\n")}
                 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)
+                      ));
+                    }
+                  }
                 }
               }
             }
@@ -127722,10 +128190,13 @@ ${lanes.join("\n")}
     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;
@@ -139345,6 +139816,7 @@ ${lanes.join("\n")}
         sourceFile,
         symbol,
         symbolName2,
+        moduleSymbol,
         /*isJsxTagName*/
         false,
         program,
@@ -139356,7 +139828,6 @@ ${lanes.join("\n")}
       const fix = getImportFixForSymbol(
         sourceFile,
         Debug.checkDefined(exportInfo),
-        moduleSymbol,
         program,
         /*position*/
         void 0,
@@ -139534,13 +140005,19 @@ ${lanes.join("\n")}
       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(
@@ -139562,23 +140039,22 @@ ${lanes.join("\n")}
     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(
@@ -139600,7 +140076,7 @@ ${lanes.join("\n")}
       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 };
       }
@@ -147761,6 +148237,7 @@ ${lanes.join("\n")}
     if (originIsResolvedExport(origin)) {
       const resolvedData = {
         exportName: origin.exportName,
+        exportMapKey: origin.exportMapKey,
         moduleSpecifier: origin.moduleSpecifier,
         ambientModuleName,
         fileName: origin.fileName,
@@ -147784,6 +148261,7 @@ ${lanes.join("\n")}
       const resolvedOrigin = {
         kind: 32 /* ResolvedExport */,
         exportName: data.exportName,
+        exportMapKey: data.exportMapKey,
         moduleSpecifier: data.moduleSpecifier,
         symbolName: completionName,
         fileName: data.fileName,
@@ -148162,6 +148640,7 @@ ${lanes.join("\n")}
     const { moduleSpecifier, codeAction } = ts_codefix_exports.getImportCompletionAction(
       targetSymbol,
       moduleSymbol,
+      data == null ? void 0 : data.exportMapKey,
       sourceFile,
       name,
       isJsxOpeningTagName,
@@ -148851,16 +149330,16 @@ ${lanes.join("\n")}
               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;
@@ -149024,7 +149503,7 @@ ${lanes.join("\n")}
       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);