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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20230208`;
+      version = `${versionMajorMinor}.0-dev.20230210`;
       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;
@@ -57702,7 +58117,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) {
@@ -66225,10 +66640,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);
@@ -70472,26 +70889,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;
+          }
         }
       }
     }
@@ -82949,6 +83362,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 +83380,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 +116766,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)
+                      ));
+                    }
+                  }
                 }
               }
             }
@@ -127736,10 +128172,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;
@@ -128162,13 +128601,25 @@ ${lanes.join("\n")}
     const autoImportProvider = useAutoImportProvider && ((_a2 = host.getPackageJsonAutoImportProvider) == null ? void 0 : _a2.call(host));
     if (autoImportProvider) {
       const start = timestamp();
-      forEachExternalModule(autoImportProvider.getTypeChecker(), autoImportProvider.getSourceFiles(), excludePatterns, (module2, file) => cb(
-        module2,
-        file,
-        autoImportProvider,
-        /*isFromPackageJson*/
-        true
-      ));
+      const checker = program.getTypeChecker();
+      forEachExternalModule(autoImportProvider.getTypeChecker(), autoImportProvider.getSourceFiles(), excludePatterns, (module2, file) => {
+        if (file && !program.getSourceFile(file.fileName) || !file && !checker.resolveName(
+          module2.name,
+          /*location*/
+          void 0,
+          1536 /* Module */,
+          /*excludeGlobals*/
+          false
+        )) {
+          cb(
+            module2,
+            file,
+            autoImportProvider,
+            /*isFromPackageJson*/
+            true
+          );
+        }
+      });
       (_b = host.log) == null ? void 0 : _b.call(host, `forEachExternalModuleToImportFrom autoImportProvider: ${timestamp() - start}`);
     }
   }
@@ -141967,7 +142418,7 @@ ${lanes.join("\n")}
     }
     if (isObjectLiteralType(type)) {
       const props = map(checker.getPropertiesOfType(type), (prop) => {
-        const initializer = prop.valueDeclaration ? tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeAtLocation(prop.valueDeclaration), enclosingDeclaration) : createUndefined();
+        const initializer = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(prop), enclosingDeclaration);
         return factory.createPropertyAssignment(prop.name, initializer);
       });
       return factory.createObjectLiteralExpression(
@@ -149026,7 +149477,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);