typescript 5.5.0-dev.20240311 → 5.5.0-dev.20240313

package/lib/tsserver.js

@@ -106,6 +106,7 @@ __export(server_exports, {
   JsxEmit: () => JsxEmit,
   JsxFlags: () => JsxFlags,
   JsxReferenceKind: () => JsxReferenceKind,
+  LanguageFeatureMinimumTarget: () => LanguageFeatureMinimumTarget,
   LanguageServiceMode: () => LanguageServiceMode,
   LanguageVariant: () => LanguageVariant,
   LexicalEnvironmentFlags: () => LexicalEnvironmentFlags,
@@ -2325,7 +2326,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240311`;
+var version = `${versionMajorMinor}.0-dev.20240313`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -3632,7 +3633,7 @@ var createUIStringComparer = /* @__PURE__ */ (() => {
     return value < 0 ? -1 /* LessThan */ : value > 0 ? 1 /* GreaterThan */ : 0 /* EqualTo */;
   }
   function createIntlCollatorStringComparer(locale) {
-    const comparer = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" }).compare;
+    const comparer = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant", numeric: true }).compare;
     return (a, b) => compareWithCallback(a, b, comparer);
   }
 })();
@@ -7233,6 +7234,38 @@ var InternalEmitFlags = /* @__PURE__ */ ((InternalEmitFlags3) => {
   InternalEmitFlags3[InternalEmitFlags3["TransformPrivateStaticElements"] = 32] = "TransformPrivateStaticElements";
   return InternalEmitFlags3;
 })(InternalEmitFlags || {});
+var LanguageFeatureMinimumTarget = /* @__PURE__ */ ((LanguageFeatureMinimumTarget2) => {
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["Classes"] = 2 /* ES2015 */] = "Classes";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ForOf"] = 2 /* ES2015 */] = "ForOf";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["Generators"] = 2 /* ES2015 */] = "Generators";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["Iteration"] = 2 /* ES2015 */] = "Iteration";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["SpreadElements"] = 2 /* ES2015 */] = "SpreadElements";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["RestElements"] = 2 /* ES2015 */] = "RestElements";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["TaggedTemplates"] = 2 /* ES2015 */] = "TaggedTemplates";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["DestructuringAssignment"] = 2 /* ES2015 */] = "DestructuringAssignment";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["BindingPatterns"] = 2 /* ES2015 */] = "BindingPatterns";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ArrowFunctions"] = 2 /* ES2015 */] = "ArrowFunctions";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["BlockScopedVariables"] = 2 /* ES2015 */] = "BlockScopedVariables";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ObjectAssign"] = 2 /* ES2015 */] = "ObjectAssign";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["Exponentiation"] = 3 /* ES2016 */] = "Exponentiation";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["AsyncFunctions"] = 4 /* ES2017 */] = "AsyncFunctions";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ForAwaitOf"] = 5 /* ES2018 */] = "ForAwaitOf";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["AsyncGenerators"] = 5 /* ES2018 */] = "AsyncGenerators";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["AsyncIteration"] = 5 /* ES2018 */] = "AsyncIteration";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ObjectSpreadRest"] = 5 /* ES2018 */] = "ObjectSpreadRest";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["BindinglessCatch"] = 6 /* ES2019 */] = "BindinglessCatch";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["BigInt"] = 7 /* ES2020 */] = "BigInt";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["NullishCoalesce"] = 7 /* ES2020 */] = "NullishCoalesce";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["OptionalChaining"] = 7 /* ES2020 */] = "OptionalChaining";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["LogicalAssignment"] = 8 /* ES2021 */] = "LogicalAssignment";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["TopLevelAwait"] = 9 /* ES2022 */] = "TopLevelAwait";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ClassFields"] = 9 /* ES2022 */] = "ClassFields";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["PrivateNamesAndClassStaticBlocks"] = 9 /* ES2022 */] = "PrivateNamesAndClassStaticBlocks";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ShebangComments"] = 99 /* ESNext */] = "ShebangComments";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["UsingAndAwaitUsing"] = 99 /* ESNext */] = "UsingAndAwaitUsing";
+  LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ClassAndClassElementDecorators"] = 99 /* ESNext */] = "ClassAndClassElementDecorators";
+  return LanguageFeatureMinimumTarget2;
+})(LanguageFeatureMinimumTarget || {});
 var ExternalEmitHelpers = /* @__PURE__ */ ((ExternalEmitHelpers2) => {
   ExternalEmitHelpers2[ExternalEmitHelpers2["Extends"] = 1] = "Extends";
   ExternalEmitHelpers2[ExternalEmitHelpers2["Assign"] = 2] = "Assign";
@@ -9888,7 +9921,7 @@ var Diagnostics = {
   Overload_signatures_must_all_be_abstract_or_non_abstract: diag(2512, 1 /* Error */, "Overload_signatures_must_all_be_abstract_or_non_abstract_2512", "Overload signatures must all be abstract or non-abstract."),
   Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: diag(2513, 1 /* Error */, "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression_2513", "Abstract method '{0}' in class '{1}' cannot be accessed via super expression."),
   A_tuple_type_cannot_be_indexed_with_a_negative_value: diag(2514, 1 /* Error */, "A_tuple_type_cannot_be_indexed_with_a_negative_value_2514", "A tuple type cannot be indexed with a negative value."),
-  Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: diag(2515, 1 /* Error */, "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'."),
+  Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: diag(2515, 1 /* Error */, "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", "Non-abstract class '{0}' does not implement inherited abstract member {1} from class '{2}'."),
   All_declarations_of_an_abstract_method_must_be_consecutive: diag(2516, 1 /* Error */, "All_declarations_of_an_abstract_method_must_be_consecutive_2516", "All declarations of an abstract method must be consecutive."),
   Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: diag(2517, 1 /* Error */, "Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type_2517", "Cannot assign an abstract constructor type to a non-abstract constructor type."),
   A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard: diag(2518, 1 /* Error */, "A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard_2518", "A 'this'-based type guard is not compatible with a parameter-based type guard."),
@@ -9998,9 +10031,13 @@ var Diagnostics = {
   Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator: diag(2638, 1 /* Error */, "Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operato_2638", "Type '{0}' may represent a primitive value, which is not permitted as the right operand of the 'in' operator."),
   React_components_cannot_include_JSX_namespace_names: diag(2639, 1 /* Error */, "React_components_cannot_include_JSX_namespace_names_2639", "React components cannot include JSX namespace names"),
   Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, 1 /* Error */, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."),
+  Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and_2_more: diag(2650, 1 /* Error */, "Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and__2650", "Non-abstract class expression is missing implementations for the following members of '{0}': {1} and {2} more."),
   A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, 1 /* Error */, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."),
   Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, 1 /* Error */, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."),
   Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: diag(2653, 1 /* Error */, "Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1_2653", "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'."),
+  Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2: diag(2654, 1 /* Error */, "Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_2654", "Non-abstract class '{0}' is missing implementations for the following members of '{1}': {2}."),
+  Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more: diag(2655, 1 /* Error */, "Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more_2655", "Non-abstract class '{0}' is missing implementations for the following members of '{1}': {2} and {3} more."),
+  Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1: diag(2656, 1 /* Error */, "Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_2656", "Non-abstract class expression is missing implementations for the following members of '{0}': {1}."),
   JSX_expressions_must_have_one_parent_element: diag(2657, 1 /* Error */, "JSX_expressions_must_have_one_parent_element_2657", "JSX expressions must have one parent element."),
   Type_0_provides_no_match_for_the_signature_1: diag(2658, 1 /* Error */, "Type_0_provides_no_match_for_the_signature_1_2658", "Type '{0}' provides no match for the signature '{1}'."),
   super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher: diag(2659, 1 /* Error */, "super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_highe_2659", "'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher."),
@@ -11329,7 +11366,6 @@ var Diagnostics = {
   _0_is_possibly_null_or_undefined: diag(18049, 1 /* Error */, "_0_is_possibly_null_or_undefined_18049", "'{0}' is possibly 'null' or 'undefined'."),
   The_value_0_cannot_be_used_here: diag(18050, 1 /* Error */, "The_value_0_cannot_be_used_here_18050", "The value '{0}' cannot be used here."),
   Compiler_option_0_cannot_be_given_an_empty_string: diag(18051, 1 /* Error */, "Compiler_option_0_cannot_be_given_an_empty_string_18051", "Compiler option '{0}' cannot be given an empty string."),
-  Non_abstract_class_0_does_not_implement_all_abstract_members_of_1: diag(18052, 1 /* Error */, "Non_abstract_class_0_does_not_implement_all_abstract_members_of_1_18052", "Non-abstract class '{0}' does not implement all abstract members of '{1}'"),
   Its_type_0_is_not_a_valid_JSX_element_type: diag(18053, 1 /* Error */, "Its_type_0_is_not_a_valid_JSX_element_type_18053", "Its type '{0}' is not a valid JSX element type."),
   await_using_statements_cannot_be_used_inside_a_class_static_block: diag(18054, 1 /* Error */, "await_using_statements_cannot_be_used_inside_a_class_static_block_18054", "'await using' statements cannot be used inside a class static block.")
 };
@@ -21797,7 +21833,7 @@ function hasTabstop(node) {
 }
 function isJSDocOptionalParameter(node) {
   return isInJSFile(node) && // node.type should only be a JSDocOptionalType when node is a parameter of a JSDocFunctionType
-  (node.type && node.type.kind === 316 /* JSDocOptionalType */ || getJSDocParameterTags(node).some(({ isBracketed, typeExpression }) => isBracketed || !!typeExpression && typeExpression.type.kind === 316 /* JSDocOptionalType */));
+  (node.type && node.type.kind === 316 /* JSDocOptionalType */ || getJSDocParameterTags(node).some(isOptionalJSDocPropertyLikeTag));
 }
 function isOptionalDeclaration(declaration) {
   switch (declaration.kind) {
@@ -48898,8 +48934,6 @@ function createTypeChecker(host) {
   var comparableRelation = /* @__PURE__ */ new Map();
   var identityRelation = /* @__PURE__ */ new Map();
   var enumRelation = /* @__PURE__ */ new Map();
-  var builtinGlobals = createSymbolTable();
-  builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
   var suggestedExtensions = [
     [".mts", ".mjs"],
     [".ts", ".js"],
@@ -49317,17 +49351,17 @@ function createTypeChecker(host) {
       }
     }
   }
-  function addToSymbolTable(target, source, message) {
-    source.forEach((sourceSymbol, id) => {
-      const targetSymbol = target.get(id);
-      if (targetSymbol) {
-        forEach(targetSymbol.declarations, addDeclarationDiagnostic(unescapeLeadingUnderscores(id), message));
-      } else {
-        target.set(id, sourceSymbol);
-      }
-    });
-    function addDeclarationDiagnostic(id, message2) {
-      return (declaration) => diagnostics.add(createDiagnosticForNode(declaration, message2, id));
+  function addUndefinedToGlobalsOrErrorOnRedeclaration() {
+    const name = undefinedSymbol.escapedName;
+    const targetSymbol = globals.get(name);
+    if (targetSymbol) {
+      forEach(targetSymbol.declarations, (declaration) => {
+        if (!isTypeDeclaration(declaration)) {
+          diagnostics.add(createDiagnosticForNode(declaration, Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0, unescapeLeadingUnderscores(name)));
+        }
+      });
+    } else {
+      globals.set(name, undefinedSymbol);
     }
   }
   function getSymbolLinks(symbol) {
@@ -49397,7 +49431,14 @@ function createTypeChecker(host) {
       } else if (declaration.kind === 260 /* VariableDeclaration */) {
         return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage);
       } else if (isClassLike(declaration)) {
-        return !findAncestor(usage, (n) => isComputedPropertyName(n) && n.parent.parent === declaration);
+        const container = findAncestor(usage, (n) => n === declaration ? "quit" : isComputedPropertyName(n) ? n.parent.parent === declaration : isDecorator(n) && (n.parent === declaration || isMethodDeclaration(n.parent) && n.parent.parent === declaration || isGetOrSetAccessorDeclaration(n.parent) && n.parent.parent === declaration || isPropertyDeclaration(n.parent) && n.parent.parent === declaration || isParameter(n.parent) && n.parent.parent.parent === declaration));
+        if (!container) {
+          return true;
+        }
+        if (isDecorator(container)) {
+          return !!findAncestor(usage, (n) => n === container ? "quit" : isFunctionLike(n) && !getImmediatelyInvokedFunctionExpression(n));
+        }
+        return false;
       } else if (isPropertyDeclaration(declaration)) {
         return !isPropertyImmediatelyReferencedWithinDeclaration(
           declaration,
@@ -60070,10 +60111,16 @@ function createTypeChecker(host) {
     const symbol = getSymbol2(globals, '"' + moduleName + '"', 512 /* ValueModule */);
     return symbol && withAugmentations ? getMergedSymbol(symbol) : symbol;
   }
+  function hasEffectiveQuestionToken(node) {
+    return hasQuestionToken(node) || isOptionalJSDocPropertyLikeTag(node) || isParameter(node) && isJSDocOptionalParameter(node);
+  }
   function isOptionalParameter(node) {
-    if (hasQuestionToken(node) || isOptionalJSDocPropertyLikeTag(node) || isJSDocOptionalParameter(node)) {
+    if (hasEffectiveQuestionToken(node)) {
       return true;
     }
+    if (!isParameter(node)) {
+      return false;
+    }
     if (node.initializer) {
       const signature = getSignatureFromDeclaration(node.parent);
       const parameterIndex = node.parent.parameters.indexOf(node);
@@ -60173,7 +60220,7 @@ function createTypeChecker(host) {
         if (type && type.kind === 201 /* LiteralType */) {
           flags |= 2 /* HasLiteralTypes */;
         }
-        const isOptionalParameter2 = isOptionalJSDocPropertyLikeTag(param) || param.initializer || param.questionToken || isRestParameter(param) || iife && parameters.length > iife.arguments.length && !type || isJSDocOptionalParameter(param);
+        const isOptionalParameter2 = hasEffectiveQuestionToken(param) || isParameter(param) && param.initializer || isRestParameter(param) || iife && parameters.length > iife.arguments.length && !type;
         if (!isOptionalParameter2) {
           minArgumentCount = parameters.length;
         }
@@ -65291,7 +65338,7 @@ function createTypeChecker(host) {
     if (reduced !== type) {
       return reduced;
     }
-    if (type.flags & 2097152 /* Intersection */ && some(type.types, isEmptyAnonymousObjectType)) {
+    if (type.flags & 2097152 /* Intersection */ && shouldNormalizeIntersection(type)) {
       const normalizedTypes = sameMap(type.types, (t) => getNormalizedType(t, writing));
       if (normalizedTypes !== type.types) {
         return getIntersectionType(normalizedTypes);
@@ -65299,6 +65346,17 @@ function createTypeChecker(host) {
     }
     return type;
   }
+  function shouldNormalizeIntersection(type) {
+    let hasInstantiable = false;
+    let hasNullableOrEmpty = false;
+    for (const t of type.types) {
+      hasInstantiable || (hasInstantiable = !!(t.flags & 465829888 /* Instantiable */));
+      hasNullableOrEmpty || (hasNullableOrEmpty = !!(t.flags & 98304 /* Nullable */) || isEmptyAnonymousObjectType(t));
+      if (hasInstantiable && hasNullableOrEmpty)
+        return true;
+    }
+    return false;
+  }
   function getNormalizedTupleType(type, writing) {
     const elements = getElementTypes(type);
     const normalizedElements = sameMap(elements, (t) => t.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(t, writing) : t);
@@ -70149,9 +70207,9 @@ function createTypeChecker(host) {
     if (strictNullChecks) {
       switch (facts) {
         case 524288 /* NEUndefined */:
-          return mapType(reduced, (t) => hasTypeFacts(t, 65536 /* EQUndefined */) ? getIntersectionType([t, hasTypeFacts(t, 131072 /* EQNull */) && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
+          return removeNullableByIntersection(reduced, 65536 /* EQUndefined */, 131072 /* EQNull */, 33554432 /* IsNull */, nullType);
         case 1048576 /* NENull */:
-          return mapType(reduced, (t) => hasTypeFacts(t, 131072 /* EQNull */) ? getIntersectionType([t, hasTypeFacts(t, 65536 /* EQUndefined */) && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
+          return removeNullableByIntersection(reduced, 131072 /* EQNull */, 65536 /* EQUndefined */, 16777216 /* IsUndefined */, undefinedType);
         case 2097152 /* NEUndefinedOrNull */:
         case 4194304 /* Truthy */:
           return mapType(reduced, (t) => hasTypeFacts(t, 262144 /* EQUndefinedOrNull */) ? getGlobalNonNullableTypeInstantiation(t) : t);
@@ -70159,6 +70217,14 @@ function createTypeChecker(host) {
     }
     return reduced;
   }
+  function removeNullableByIntersection(type, targetFacts, otherFacts, otherIncludesFacts, otherType) {
+    const facts = getTypeFacts(type, 65536 /* EQUndefined */ | 131072 /* EQNull */ | 16777216 /* IsUndefined */ | 33554432 /* IsNull */);
+    if (!(facts & targetFacts)) {
+      return type;
+    }
+    const emptyAndOtherUnion = getUnionType([emptyObjectType, otherType]);
+    return mapType(type, (t) => hasTypeFacts(t, targetFacts) ? getIntersectionType([t, !(facts & otherIncludesFacts) && hasTypeFacts(t, otherFacts) ? emptyAndOtherUnion : emptyObjectType]) : t);
+  }
   function recombineUnknownType(type) {
     return type === unknownUnionType ? unknownType : type;
   }
@@ -73726,7 +73792,7 @@ function createTypeChecker(host) {
     }
   }
   function checkSpreadExpression(node, checkMode) {
-    if (languageVersion < 2 /* ES2015 */) {
+    if (languageVersion < 2 /* SpreadElements */) {
       checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */);
     }
     const arrayOrIterableType = checkExpression(node.expression, checkMode);
@@ -73760,7 +73826,7 @@ function createTypeChecker(host) {
     for (let i = 0; i < elementCount; i++) {
       const e = elements[i];
       if (e.kind === 230 /* SpreadElement */) {
-        if (languageVersion < 2 /* ES2015 */) {
+        if (languageVersion < 2 /* SpreadElements */) {
           checkExternalEmitHelpers(e, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */);
         }
         const spreadType = checkExpression(e.expression, checkMode, forceTuple);
@@ -73990,7 +74056,7 @@ function createTypeChecker(host) {
           addIntraExpressionInferenceSite(inferenceContext, inferenceNode, type);
         }
       } else if (memberDecl.kind === 305 /* SpreadAssignment */) {
-        if (languageVersion < 2 /* ES2015 */) {
+        if (languageVersion < 2 /* ObjectAssign */) {
           checkExternalEmitHelpers(memberDecl, 2 /* Assign */);
         }
         if (propertiesArray.length > 0) {
@@ -75015,7 +75081,7 @@ function createTypeChecker(host) {
     const isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType;
     let prop;
     if (isPrivateIdentifier(right)) {
-      if (languageVersion < 99 /* ESNext */) {
+      if (languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */ || !useDefineForClassFields) {
         if (assignmentKind !== 0 /* None */) {
           checkExternalEmitHelpers(node, 1048576 /* ClassPrivateFieldSet */);
         }
@@ -76842,7 +76908,7 @@ function createTypeChecker(host) {
       }
       return resolveErrorCall(node);
     }
-    if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunctionOrConstructor)) {
+    if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
       skippedGenericFunction(node, checkMode);
       return resolvingSignature;
     }
@@ -76852,12 +76918,8 @@ function createTypeChecker(host) {
     }
     return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags);
   }
-  function isGenericFunctionReturningFunctionOrConstructor(signature) {
-    if (!signature.typeParameters) {
-      return false;
-    }
-    const returnType = getReturnTypeOfSignature(signature);
-    return isFunctionType(returnType) || isConstructorType(returnType);
+  function isGenericFunctionReturningFunction(signature) {
+    return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature)));
   }
   function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) {
     return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144 /* TypeParameter */) || !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & 1048576 /* Union */) && !(getReducedType(apparentFuncType).flags & 131072 /* Never */) && isTypeAssignableTo(funcType, globalFunctionType);
@@ -77628,7 +77690,7 @@ function createTypeChecker(host) {
   function checkTaggedTemplateExpression(node) {
     if (!checkGrammarTaggedTemplateChain(node))
       checkGrammarTypeArguments(node, node.typeArguments);
-    if (languageVersion < 2 /* ES2015 */) {
+    if (languageVersion < 2 /* TaggedTemplates */) {
       checkExternalEmitHelpers(node, 262144 /* MakeTemplateObject */);
     }
     const signature = getResolvedSignature(node);
@@ -79275,7 +79337,7 @@ function createTypeChecker(host) {
       return silentNeverType;
     }
     if (isPrivateIdentifier(left)) {
-      if (languageVersion < 99 /* ESNext */) {
+      if (languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */ || !useDefineForClassFields) {
         checkExternalEmitHelpers(left, 2097152 /* ClassPrivateFieldIn */);
       }
       if (!getNodeLinks(left).resolvedSymbol && getContainingClass(left)) {
@@ -79336,7 +79398,7 @@ function createTypeChecker(host) {
       if (propertyIndex < properties.length - 1) {
         error2(property, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
       } else {
-        if (languageVersion < 99 /* ESNext */) {
+        if (languageVersion < 5 /* ObjectSpreadRest */) {
           checkExternalEmitHelpers(property, 4 /* Rest */);
         }
         const nonRestNames = [];
@@ -79357,7 +79419,7 @@ function createTypeChecker(host) {
   }
   function checkArrayLiteralAssignment(node, sourceType, checkMode) {
     const elements = node.elements;
-    if (languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
+    if (languageVersion < 2 /* DestructuringAssignment */ && compilerOptions.downlevelIteration) {
       checkExternalEmitHelpers(node, 512 /* Read */);
     }
     const possiblyOutOfBoundsType = checkIteratedTypeOrElementType(65 /* Destructuring */ | 128 /* PossiblyOutOfBounds */, sourceType, undefinedType, node) || errorType;
@@ -80059,10 +80121,10 @@ function createTypeChecker(host) {
     }
     const isAsync = (functionFlags & 2 /* Async */) !== 0;
     if (node.asteriskToken) {
-      if (isAsync && languageVersion < 99 /* ESNext */) {
+      if (isAsync && languageVersion < 5 /* AsyncGenerators */) {
         checkExternalEmitHelpers(node, 26624 /* AsyncDelegatorIncludes */);
       }
-      if (!isAsync && languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
+      if (!isAsync && languageVersion < 2 /* Generators */ && compilerOptions.downlevelIteration) {
         checkExternalEmitHelpers(node, 256 /* Values */);
       }
     }
@@ -80834,13 +80896,13 @@ function createTypeChecker(host) {
     }
     const functionFlags = getFunctionFlags(node);
     if (!(functionFlags & 4 /* Invalid */)) {
-      if ((functionFlags & 3 /* AsyncGenerator */) === 3 /* AsyncGenerator */ && languageVersion < 99 /* ESNext */) {
+      if ((functionFlags & 3 /* AsyncGenerator */) === 3 /* AsyncGenerator */ && languageVersion < 5 /* AsyncGenerators */) {
         checkExternalEmitHelpers(node, 6144 /* AsyncGeneratorIncludes */);
       }
-      if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */ && languageVersion < 4 /* ES2017 */) {
+      if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */ && languageVersion < 4 /* AsyncFunctions */) {
         checkExternalEmitHelpers(node, 64 /* Awaiter */);
       }
-      if ((functionFlags & 3 /* AsyncGenerator */) !== 0 /* Normal */ && languageVersion < 2 /* ES2015 */) {
+      if ((functionFlags & 3 /* AsyncGenerator */) !== 0 /* Normal */ && languageVersion < 2 /* Generators */) {
         checkExternalEmitHelpers(node, 128 /* Generator */);
       }
     }
@@ -81073,15 +81135,17 @@ function createTypeChecker(host) {
     setNodeLinksForPrivateIdentifierScope(node);
   }
   function setNodeLinksForPrivateIdentifierScope(node) {
-    if (isPrivateIdentifier(node.name) && languageVersion < 99 /* ESNext */) {
-      for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) {
-        getNodeLinks(lexicalScope).flags |= 1048576 /* ContainsClassWithPrivateIdentifiers */;
-      }
-      if (isClassExpression(node.parent)) {
-        const enclosingIterationStatement = getEnclosingIterationStatement(node.parent);
-        if (enclosingIterationStatement) {
-          getNodeLinks(node.name).flags |= 32768 /* BlockScopedBindingInLoop */;
-          getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
+    if (isPrivateIdentifier(node.name)) {
+      if (languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */ || !useDefineForClassFields) {
+        for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) {
+          getNodeLinks(lexicalScope).flags |= 1048576 /* ContainsClassWithPrivateIdentifiers */;
+        }
+        if (isClassExpression(node.parent)) {
+          const enclosingIterationStatement = getEnclosingIterationStatement(node.parent);
+          if (enclosingIterationStatement) {
+            getNodeLinks(node.name).flags |= 32768 /* BlockScopedBindingInLoop */;
+            getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
+          }
         }
       }
     }
@@ -82206,7 +82270,7 @@ function createTypeChecker(host) {
       if (node.kind === 169 /* Parameter */) {
         checkExternalEmitHelpers(firstDecorator, 32 /* Param */);
       }
-    } else if (languageVersion < 99 /* ESNext */) {
+    } else if (languageVersion < 99 /* ClassAndClassElementDecorators */) {
       checkExternalEmitHelpers(firstDecorator, 8 /* ESDecorateAndRunInitializers */);
       if (isClassDeclaration(node)) {
         if (!node.name) {
@@ -82911,7 +82975,7 @@ function createTypeChecker(host) {
         potentialUnusedRenamedBindingElementsInTypes.push(node);
         return;
       }
-      if (isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ES2018 */) {
+      if (isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ObjectSpreadRest */) {
         checkExternalEmitHelpers(node, 4 /* Rest */);
       }
       if (node.propertyName && node.propertyName.kind === 167 /* ComputedPropertyName */) {
@@ -82947,7 +83011,7 @@ function createTypeChecker(host) {
       }
     }
     if (isBindingPattern(node.name)) {
-      if (node.name.kind === 207 /* ArrayBindingPattern */ && languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
+      if (node.name.kind === 207 /* ArrayBindingPattern */ && languageVersion < 2 /* BindingPatterns */ && compilerOptions.downlevelIteration) {
         checkExternalEmitHelpers(node, 512 /* Read */);
       }
       forEach(node.name.elements, checkSourceElement);
@@ -83098,7 +83162,7 @@ function createTypeChecker(host) {
   }
   function checkVariableDeclarationList(node) {
     const blockScopeKind = getCombinedNodeFlags(node) & 7 /* BlockScoped */;
-    if (blockScopeKind === 4 /* Using */ || blockScopeKind === 6 /* AwaitUsing */) {
+    if ((blockScopeKind === 4 /* Using */ || blockScopeKind === 6 /* AwaitUsing */) && languageVersion < 99 /* UsingAndAwaitUsing */) {
       checkExternalEmitHelpers(node, 16777216 /* AddDisposableResourceAndDisposeResources */);
     }
     forEach(node.declarations, checkSourceElement);
@@ -83271,11 +83335,11 @@ function createTypeChecker(host) {
         grammarErrorOnNode(node.awaitModifier, Diagnostics.for_await_loops_cannot_be_used_inside_a_class_static_block);
       } else {
         const functionFlags = getFunctionFlags(container);
-        if ((functionFlags & (4 /* Invalid */ | 2 /* Async */)) === 2 /* Async */ && languageVersion < 99 /* ESNext */) {
+        if ((functionFlags & (4 /* Invalid */ | 2 /* Async */)) === 2 /* Async */ && languageVersion < 5 /* ForAwaitOf */) {
           checkExternalEmitHelpers(node, 16384 /* ForAwaitOfIncludes */);
         }
       }
-    } else if (compilerOptions.downlevelIteration && languageVersion < 2 /* ES2015 */) {
+    } else if (compilerOptions.downlevelIteration && languageVersion < 2 /* ForOf */) {
       checkExternalEmitHelpers(node, 256 /* ForOfIncludes */);
     }
     if (node.initializer.kind === 261 /* VariableDeclarationList */) {
@@ -84199,6 +84263,7 @@ function createTypeChecker(host) {
       case "symbol":
       case "void":
       case "object":
+      case "undefined":
         error2(name, message, name.escapedText);
     }
   }
@@ -84338,12 +84403,12 @@ function createTypeChecker(host) {
     return true;
   }
   function getFirstTransformableStaticClassElement(node) {
-    const willTransformStaticElementsOfDecoratedClass = !legacyDecorators && languageVersion < 99 /* ESNext */ && classOrConstructorParameterIsDecorated(
+    const willTransformStaticElementsOfDecoratedClass = !legacyDecorators && languageVersion < 99 /* ClassAndClassElementDecorators */ && classOrConstructorParameterIsDecorated(
       /*useLegacyDecorators*/
       false,
       node
     );
-    const willTransformPrivateElementsOrClassStaticBlocks = languageVersion <= 9 /* ES2022 */;
+    const willTransformPrivateElementsOrClassStaticBlocks = languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */;
     const willTransformInitializers = !emitStandardClassFields;
     if (willTransformStaticElementsOfDecoratedClass || willTransformPrivateElementsOrClassStaticBlocks) {
       for (const member of node.members) {
@@ -84372,7 +84437,7 @@ function createTypeChecker(host) {
     const parent2 = walkUpOuterExpressions(node);
     if (!isNamedEvaluationSource(parent2))
       return;
-    const willTransformESDecorators = !legacyDecorators && languageVersion < 99 /* ESNext */;
+    const willTransformESDecorators = !legacyDecorators && languageVersion < 99 /* ClassAndClassElementDecorators */;
     let location;
     if (willTransformESDecorators && classOrConstructorParameterIsDecorated(
       /*useLegacyDecorators*/
@@ -84432,7 +84497,7 @@ function createTypeChecker(host) {
     const baseTypeNode = getEffectiveBaseTypeNode(node);
     if (baseTypeNode) {
       forEach(baseTypeNode.typeArguments, checkSourceElement);
-      if (languageVersion < 2 /* ES2015 */) {
+      if (languageVersion < 2 /* Classes */) {
         checkExternalEmitHelpers(baseTypeNode.parent, 1 /* Extends */);
       }
       const extendsNode = getClassExtendsHeritageElement(node);
@@ -84728,9 +84793,9 @@ function createTypeChecker(host) {
     return filter(symbol.declarations, (d) => d.kind === 263 /* ClassDeclaration */ || d.kind === 264 /* InterfaceDeclaration */);
   }
   function checkKindsOfPropertyMemberOverrides(type, baseType) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const baseProperties = getPropertiesOfType(baseType);
-    let inheritedAbstractMemberNotImplementedError;
+    const notImplementedInfo = /* @__PURE__ */ new Map();
     basePropertyCheck:
       for (const baseProperty of baseProperties) {
         const base = getTargetSymbol(baseProperty);
@@ -84756,36 +84821,11 @@ function createTypeChecker(host) {
                 continue basePropertyCheck;
               }
             }
-            if (!inheritedAbstractMemberNotImplementedError) {
-              inheritedAbstractMemberNotImplementedError = error2(
-                derivedClassDecl,
-                Diagnostics.Non_abstract_class_0_does_not_implement_all_abstract_members_of_1,
-                typeToString(type),
-                typeToString(baseType)
-              );
-            }
-            if (derivedClassDecl.kind === 231 /* ClassExpression */) {
-              addRelatedInfo(
-                inheritedAbstractMemberNotImplementedError,
-                createDiagnosticForNode(
-                  baseProperty.valueDeclaration ?? (baseProperty.declarations && first(baseProperty.declarations)) ?? derivedClassDecl,
-                  Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1,
-                  symbolToString(baseProperty),
-                  typeToString(baseType)
-                )
-              );
-            } else {
-              addRelatedInfo(
-                inheritedAbstractMemberNotImplementedError,
-                createDiagnosticForNode(
-                  baseProperty.valueDeclaration ?? (baseProperty.declarations && first(baseProperty.declarations)) ?? derivedClassDecl,
-                  Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2,
-                  typeToString(type),
-                  symbolToString(baseProperty),
-                  typeToString(baseType)
-                )
-              );
-            }
+            const baseTypeName = typeToString(baseType);
+            const typeName = typeToString(type);
+            const basePropertyName = symbolToString(baseProperty);
+            const missedProperties = append((_a = notImplementedInfo.get(derivedClassDecl)) == null ? void 0 : _a.missedProperties, basePropertyName);
+            notImplementedInfo.set(derivedClassDecl, { baseTypeName, typeName, missedProperties });
           }
         } else {
           const derivedDeclarationFlags = getDeclarationModifierFlagsFromSymbol(derived);
@@ -84796,7 +84836,7 @@ function createTypeChecker(host) {
           const basePropertyFlags = base.flags & 98308 /* PropertyOrAccessor */;
           const derivedPropertyFlags = derived.flags & 98308 /* PropertyOrAccessor */;
           if (basePropertyFlags && derivedPropertyFlags) {
-            if ((getCheckFlags(base) & 6 /* Synthetic */ ? (_a = base.declarations) == null ? void 0 : _a.some((d) => isPropertyAbstractOrInterface(d, baseDeclarationFlags)) : (_b = base.declarations) == null ? void 0 : _b.every((d) => isPropertyAbstractOrInterface(d, baseDeclarationFlags))) || getCheckFlags(base) & 262144 /* Mapped */ || derived.valueDeclaration && isBinaryExpression(derived.valueDeclaration)) {
+            if ((getCheckFlags(base) & 6 /* Synthetic */ ? (_b = base.declarations) == null ? void 0 : _b.some((d) => isPropertyAbstractOrInterface(d, baseDeclarationFlags)) : (_c = base.declarations) == null ? void 0 : _c.every((d) => isPropertyAbstractOrInterface(d, baseDeclarationFlags))) || getCheckFlags(base) & 262144 /* Mapped */ || derived.valueDeclaration && isBinaryExpression(derived.valueDeclaration)) {
               continue;
             }
             const overriddenInstanceProperty = basePropertyFlags !== 4 /* Property */ && derivedPropertyFlags === 4 /* Property */;
@@ -84805,8 +84845,8 @@ function createTypeChecker(host) {
               const errorMessage2 = overriddenInstanceProperty ? Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property : Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor;
               error2(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, symbolToString(base), typeToString(baseType), typeToString(type));
             } else if (useDefineForClassFields) {
-              const uninitialized = (_c = derived.declarations) == null ? void 0 : _c.find((d) => d.kind === 172 /* PropertyDeclaration */ && !d.initializer);
-              if (uninitialized && !(derived.flags & 33554432 /* Transient */) && !(baseDeclarationFlags & 64 /* Abstract */) && !(derivedDeclarationFlags & 64 /* Abstract */) && !((_d = derived.declarations) == null ? void 0 : _d.some((d) => !!(d.flags & 33554432 /* Ambient */)))) {
+              const uninitialized = (_d = derived.declarations) == null ? void 0 : _d.find((d) => d.kind === 172 /* PropertyDeclaration */ && !d.initializer);
+              if (uninitialized && !(derived.flags & 33554432 /* Transient */) && !(baseDeclarationFlags & 64 /* Abstract */) && !(derivedDeclarationFlags & 64 /* Abstract */) && !((_e = derived.declarations) == null ? void 0 : _e.some((d) => !!(d.flags & 33554432 /* Ambient */)))) {
                 const constructor = findConstructorDeclaration(getClassLikeDeclarationOfSymbol(type.symbol));
                 const propName = uninitialized.name;
                 if (uninitialized.exclamationToken || !constructor || !isIdentifier(propName) || !strictNullChecks || !isPropertyInitializedInConstructor(propName, type, constructor)) {
@@ -84831,6 +84871,30 @@ function createTypeChecker(host) {
           error2(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type));
         }
       }
+    for (const [errorNode, memberInfo] of notImplementedInfo) {
+      if (length(memberInfo.missedProperties) === 1) {
+        if (isClassExpression(errorNode)) {
+          error2(errorNode, Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, first(memberInfo.missedProperties), memberInfo.baseTypeName);
+        } else {
+          error2(errorNode, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, memberInfo.typeName, first(memberInfo.missedProperties), memberInfo.baseTypeName);
+        }
+      } else if (length(memberInfo.missedProperties) > 5) {
+        const missedProperties = map(memberInfo.missedProperties.slice(0, 4), (prop) => `'${prop}'`).join(", ");
+        const remainingMissedProperties = length(memberInfo.missedProperties) - 4;
+        if (isClassExpression(errorNode)) {
+          error2(errorNode, Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and_2_more, memberInfo.baseTypeName, missedProperties, remainingMissedProperties);
+        } else {
+          error2(errorNode, Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more, memberInfo.typeName, memberInfo.baseTypeName, missedProperties, remainingMissedProperties);
+        }
+      } else {
+        const missedProperties = map(memberInfo.missedProperties, (prop) => `'${prop}'`).join(", ");
+        if (isClassExpression(errorNode)) {
+          error2(errorNode, Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1, memberInfo.baseTypeName, missedProperties);
+        } else {
+          error2(errorNode, Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2, memberInfo.typeName, memberInfo.baseTypeName, missedProperties);
+        }
+      }
+    }
   }
   function isPropertyAbstractOrInterface(declaration, baseDeclarationFlags) {
     return baseDeclarationFlags & 64 /* Abstract */ && (!isPropertyDeclaration(declaration) || !declaration.initializer) || isInterfaceDeclaration(declaration.parent);
@@ -87901,7 +87965,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    addToSymbolTable(globals, builtinGlobals, Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0);
+    addUndefinedToGlobalsOrErrorOnRedeclaration();
     getSymbolLinks(undefinedSymbol).type = undefinedWideningType;
     getSymbolLinks(argumentsSymbol).type = getGlobalType(
       "IArguments",
@@ -88555,7 +88619,7 @@ function createTypeChecker(host) {
         if (parameter.initializer) {
           return grammarErrorOnNode(parameter.name, Diagnostics.A_rest_parameter_cannot_have_an_initializer);
         }
-      } else if (isOptionalParameter(parameter)) {
+      } else if (hasEffectiveQuestionToken(parameter)) {
         seenOptionalParameter = true;
         if (parameter.questionToken && parameter.initializer) {
           return grammarErrorOnNode(parameter.name, Diagnostics.Parameter_cannot_have_question_mark_and_initializer);
@@ -91666,12 +91730,12 @@ function getOriginalNodeId(node) {
 function containsDefaultReference(node) {
   if (!node)
     return false;
-  if (!isNamedImports(node))
+  if (!isNamedImports(node) && !isNamedExports(node))
     return false;
   return some(node.elements, isNamedDefaultReference);
 }
 function isNamedDefaultReference(e) {
-  return e.propertyName !== void 0 && e.propertyName.escapedText === "default" /* Default */;
+  return e.propertyName !== void 0 ? e.propertyName.escapedText === "default" /* Default */ : e.name.escapedText === "default" /* Default */;
 }
 function chainBundle(context, transformSourceFile) {
   return transformSourceFileOrBundle;
@@ -91745,6 +91809,7 @@ function collectExternalModuleInfo(context, sourceFile) {
             externalImports.push(node);
             if (isNamedExports(node.exportClause)) {
               addExportedNamesForExportDeclaration(node);
+              hasImportDefault || (hasImportDefault = containsDefaultReference(node.exportClause));
             } else {
               const name = node.exportClause.name;
               if (!uniqueExports.get(idText(name))) {
@@ -153463,7 +153528,12 @@ function getTypesPackageNameToInstall(packageName, host, diagCode) {
 
 // src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts
 var errorCodes31 = [
-  Diagnostics.Non_abstract_class_0_does_not_implement_all_abstract_members_of_1.code
+  Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2.code,
+  Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2.code,
+  Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more.code,
+  Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1.code,
+  Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1.code,
+  Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and_2_more.code
 ];
 var fixId25 = "fixClassDoesntImplementInheritedAbstractMember";
 registerCodeFix({
@@ -165492,7 +165562,7 @@ function provideInlayHints(context) {
     return type.symbol && type.symbol.flags & 1536 /* Module */;
   }
   function visitVariableLikeDeclaration(decl) {
-    if (!decl.initializer || isBindingPattern(decl.name) || isVariableDeclaration(decl) && !isHintableDeclaration(decl)) {
+    if (decl.initializer === void 0 && !(isPropertyDeclaration(decl) && !(checker.getTypeAtLocation(decl).flags & 1 /* Any */)) || isBindingPattern(decl.name) || isVariableDeclaration(decl) && !isHintableDeclaration(decl)) {
       return;
     }
     const effectiveTypeAnnotation = getEffectiveTypeAnnotationNode(decl);
@@ -173293,6 +173363,7 @@ __export(ts_exports2, {
   JsxEmit: () => JsxEmit,
   JsxFlags: () => JsxFlags,
   JsxReferenceKind: () => JsxReferenceKind,
+  LanguageFeatureMinimumTarget: () => LanguageFeatureMinimumTarget,
   LanguageServiceMode: () => LanguageServiceMode,
   LanguageVariant: () => LanguageVariant,
   LexicalEnvironmentFlags: () => LexicalEnvironmentFlags,
@@ -188068,6 +188139,7 @@ start(initializeNodeSystem(), require("os").platform());
   JsxEmit,
   JsxFlags,
   JsxReferenceKind,
+  LanguageFeatureMinimumTarget,
   LanguageServiceMode,
   LanguageVariant,
   LexicalEnvironmentFlags,