@typescript-deploys/pr-build 5.5.0-pr-57267-12 → 5.5.0-pr-57749-2

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,
@@ -161,6 +162,7 @@ __export(server_exports, {
   SignatureKind: () => SignatureKind,
   SmartSelectionRange: () => ts_SmartSelectionRange_exports,
   SnippetKind: () => SnippetKind,
+  SortKind: () => SortKind,
   StructureIsReused: () => StructureIsReused,
   SymbolAccessibility: () => SymbolAccessibility,
   SymbolDisplay: () => ts_SymbolDisplay_exports,
@@ -495,6 +497,7 @@ __export(server_exports, {
   defaultIncludeSpec: () => defaultIncludeSpec,
   defaultInitCompilerOptions: () => defaultInitCompilerOptions,
   defaultMaximumTruncationLength: () => defaultMaximumTruncationLength,
+  detectSortCaseSensitivity: () => detectSortCaseSensitivity,
   diagnosticCategoryName: () => diagnosticCategoryName,
   diagnosticToString: () => diagnosticToString,
   directoryProbablyExists: () => directoryProbablyExists,
@@ -2323,7 +2326,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-insiders.20240309`;
+var version = `${versionMajorMinor}.0-insiders.20240312`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -2872,6 +2875,30 @@ function arrayIsSorted(array, comparer) {
   }
   return true;
 }
+var SortKind = /* @__PURE__ */ ((SortKind2) => {
+  SortKind2[SortKind2["None"] = 0] = "None";
+  SortKind2[SortKind2["CaseSensitive"] = 1] = "CaseSensitive";
+  SortKind2[SortKind2["CaseInsensitive"] = 2] = "CaseInsensitive";
+  SortKind2[SortKind2["Both"] = 3] = "Both";
+  return SortKind2;
+})(SortKind || {});
+function detectSortCaseSensitivity(array, getString, compareStringsCaseSensitive2, compareStringsCaseInsensitive2) {
+  let kind = 3 /* Both */;
+  if (array.length < 2)
+    return kind;
+  let prevElement = getString(array[0]);
+  for (let i = 1, len = array.length; i < len && kind !== 0 /* None */; i++) {
+    const element = getString(array[i]);
+    if (kind & 1 /* CaseSensitive */ && compareStringsCaseSensitive2(prevElement, element) > 0) {
+      kind &= ~1 /* CaseSensitive */;
+    }
+    if (kind & 2 /* CaseInsensitive */ && compareStringsCaseInsensitive2(prevElement, element) > 0) {
+      kind &= ~2 /* CaseInsensitive */;
+    }
+    prevElement = element;
+  }
+  return kind;
+}
 function arrayIsEqualTo(array1, array2, equalityComparer = equateValues) {
   if (!array1 || !array2) {
     return array1 === array2;
@@ -3606,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);
   }
 })();
@@ -7207,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";
@@ -9616,6 +9675,8 @@ var Diagnostics = {
   The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration: diag(1494, 1 /* Error */, "The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration_1494", "The left-hand side of a 'for...in' statement cannot be an 'await using' declaration."),
   _0_modifier_cannot_appear_on_an_await_using_declaration: diag(1495, 1 /* Error */, "_0_modifier_cannot_appear_on_an_await_using_declaration_1495", "'{0}' modifier cannot appear on an 'await using' declaration."),
   Identifier_string_literal_or_number_literal_expected: diag(1496, 1 /* Error */, "Identifier_string_literal_or_number_literal_expected_1496", "Identifier, string literal, or number literal expected."),
+  Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator: diag(1497, 1 /* Error */, "Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator_1497", "Expression must be enclosed in parentheses to be used as a decorator."),
+  Invalid_syntax_in_decorator: diag(1498, 1 /* Error */, "Invalid_syntax_in_decorator_1498", "Invalid syntax in decorator."),
   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(
@@ -11263,6 +11324,8 @@ var Diagnostics = {
   Add_optional_parameter_to_0: diag(95191, 3 /* Message */, "Add_optional_parameter_to_0_95191", "Add optional parameter to '{0}'"),
   Add_optional_parameters_to_0: diag(95192, 3 /* Message */, "Add_optional_parameters_to_0_95192", "Add optional parameters to '{0}'"),
   Add_all_optional_parameters: diag(95193, 3 /* Message */, "Add_all_optional_parameters_95193", "Add all optional parameters"),
+  Wrap_in_parentheses: diag(95194, 3 /* Message */, "Wrap_in_parentheses_95194", "Wrap in parentheses"),
+  Wrap_all_invalid_decorator_expressions_in_parentheses: diag(95195, 3 /* Message */, "Wrap_all_invalid_decorator_expressions_in_parentheses_95195", "Wrap all invalid decorator expressions in parentheses"),
   No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, 1 /* Error */, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
   Classes_may_not_have_a_field_named_constructor: diag(18006, 1 /* Error */, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
   JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, 1 /* Error */, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -21771,7 +21834,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) {
@@ -48872,8 +48935,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"],
@@ -49291,17 +49352,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) {
@@ -49371,7 +49432,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,
@@ -60044,10 +60112,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);
@@ -60147,7 +60221,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;
         }
@@ -65265,7 +65339,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);
@@ -65273,6 +65347,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);
@@ -70123,9 +70208,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);
@@ -70133,6 +70218,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;
   }
@@ -73700,7 +73793,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);
@@ -73734,7 +73827,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);
@@ -73964,7 +74057,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) {
@@ -74989,7 +75082,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 */);
         }
@@ -76816,7 +76909,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;
     }
@@ -76826,12 +76919,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);
@@ -77602,7 +77691,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);
@@ -79249,7 +79338,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)) {
@@ -79310,7 +79399,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 = [];
@@ -79331,7 +79420,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;
@@ -80033,10 +80122,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 */);
       }
     }
@@ -80808,13 +80897,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 */);
       }
     }
@@ -81047,15 +81136,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 */;
+          }
         }
       }
     }
@@ -82007,7 +82098,56 @@ function createTypeChecker(host) {
       }
     }
   }
+  function checkGrammarDecorator(decorator) {
+    const sourceFile = getSourceFileOfNode(decorator);
+    if (!hasParseDiagnostics(sourceFile)) {
+      let node = decorator.expression;
+      if (isParenthesizedExpression(node)) {
+        return false;
+      }
+      let canHaveCallExpression = true;
+      let errorNode;
+      while (true) {
+        if (isExpressionWithTypeArguments(node) || isNonNullExpression(node)) {
+          node = node.expression;
+          continue;
+        }
+        if (isCallExpression(node)) {
+          if (!canHaveCallExpression) {
+            errorNode = node;
+          }
+          if (node.questionDotToken) {
+            errorNode = node.questionDotToken;
+          }
+          node = node.expression;
+          canHaveCallExpression = false;
+          continue;
+        }
+        if (isPropertyAccessExpression(node)) {
+          if (node.questionDotToken) {
+            errorNode = node.questionDotToken;
+          }
+          node = node.expression;
+          canHaveCallExpression = false;
+          continue;
+        }
+        if (!isIdentifier(node)) {
+          errorNode = node;
+        }
+        break;
+      }
+      if (errorNode) {
+        addRelatedInfo(
+          error2(decorator.expression, Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator),
+          createDiagnosticForNode(errorNode, Diagnostics.Invalid_syntax_in_decorator)
+        );
+        return true;
+      }
+    }
+    return false;
+  }
   function checkDecorator(node) {
+    checkGrammarDecorator(node);
     const signature = getResolvedSignature(node);
     checkDeprecatedSignature(signature, node);
     const returnType = getReturnTypeOfSignature(signature);
@@ -82180,7 +82320,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) {
@@ -82885,7 +83025,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 */) {
@@ -82921,7 +83061,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);
@@ -83072,7 +83212,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);
@@ -83245,11 +83385,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 */) {
@@ -84173,6 +84313,7 @@ function createTypeChecker(host) {
       case "symbol":
       case "void":
       case "object":
+      case "undefined":
         error2(name, message, name.escapedText);
     }
   }
@@ -84312,12 +84453,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) {
@@ -84346,7 +84487,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*/
@@ -84406,7 +84547,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);
@@ -87875,7 +88016,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",
@@ -88529,7 +88670,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);
@@ -91640,12 +91781,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;
@@ -91719,6 +91860,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))) {
@@ -132952,13 +133094,15 @@ function insertImports(changes, sourceFile, imports, blankLineBetween, preferenc
   const decl = isArray(imports) ? imports[0] : imports;
   const importKindPredicate = decl.kind === 243 /* VariableStatement */ ? isRequireVariableStatement : isAnyImportSyntax;
   const existingImportStatements = filter(sourceFile.statements, importKindPredicate);
-  const { comparer, isSorted } = ts_OrganizeImports_exports.getOrganizeImportsStringComparerWithDetection(existingImportStatements, preferences);
+  let sortKind = isArray(imports) ? ts_OrganizeImports_exports.detectImportDeclarationSorting(imports, preferences) : 3 /* Both */;
+  const comparer = ts_OrganizeImports_exports.getOrganizeImportsComparer(preferences, sortKind === 2 /* CaseInsensitive */);
   const sortedNewImports = isArray(imports) ? stableSort(imports, (a, b) => ts_OrganizeImports_exports.compareImportsOrRequireStatements(a, b, comparer)) : [imports];
   if (!existingImportStatements.length) {
     changes.insertNodesAtTopOfFile(sourceFile, sortedNewImports, blankLineBetween);
-  } else if (existingImportStatements && isSorted) {
+  } else if (existingImportStatements && (sortKind = ts_OrganizeImports_exports.detectImportDeclarationSorting(existingImportStatements, preferences))) {
+    const comparer2 = ts_OrganizeImports_exports.getOrganizeImportsComparer(preferences, sortKind === 2 /* CaseInsensitive */);
     for (const newImport of sortedNewImports) {
-      const insertionIndex = ts_OrganizeImports_exports.getImportDeclarationInsertionIndex(existingImportStatements, newImport, comparer);
+      const insertionIndex = ts_OrganizeImports_exports.getImportDeclarationInsertionIndex(existingImportStatements, newImport, comparer2);
       if (insertionIndex === 0) {
         const options = existingImportStatements[0] === sourceFile.statements[0] ? { leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.Exclude } : {};
         changes.insertNodeBefore(
@@ -145541,22 +145685,22 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     }
     return [];
   }
-  function getCodeFixesAtPosition(fileName, start2, end, errorCodes65, formatOptions, preferences = emptyOptions) {
+  function getCodeFixesAtPosition(fileName, start2, end, errorCodes66, formatOptions, preferences = emptyOptions) {
     synchronizeHostData();
     const sourceFile = getValidSourceFile(fileName);
     const span = createTextSpanFromBounds(start2, end);
     const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
-    return flatMap(deduplicate(errorCodes65, equateValues, compareValues), (errorCode) => {
+    return flatMap(deduplicate(errorCodes66, equateValues, compareValues), (errorCode) => {
       cancellationToken.throwIfCancellationRequested();
       return ts_codefix_exports.getFixes({ errorCode, sourceFile, span, program, host, cancellationToken, formatContext, preferences });
     });
   }
-  function getCombinedCodeFix(scope, fixId52, formatOptions, preferences = emptyOptions) {
+  function getCombinedCodeFix(scope, fixId53, formatOptions, preferences = emptyOptions) {
     synchronizeHostData();
     Debug.assert(scope.type === "file");
     const sourceFile = getValidSourceFile(scope.fileName);
     const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
-    return ts_codefix_exports.getAllFixes({ fixId: fixId52, sourceFile, program, host, cancellationToken, formatContext, preferences });
+    return ts_codefix_exports.getAllFixes({ fixId: fixId53, sourceFile, program, host, cancellationToken, formatContext, preferences });
   }
   function organizeImports2(args, formatOptions, preferences = emptyOptions) {
     synchronizeHostData();
@@ -147235,14 +147379,14 @@ function createCodeFixActionWithoutFixAll(fixName8, changes, description3) {
     void 0
   );
 }
-function createCodeFixAction(fixName8, changes, description3, fixId52, fixAllDescription, command) {
-  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId52, diagnosticToString(fixAllDescription), command);
+function createCodeFixAction(fixName8, changes, description3, fixId53, fixAllDescription, command) {
+  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId53, diagnosticToString(fixAllDescription), command);
 }
-function createCodeFixActionMaybeFixAll(fixName8, changes, description3, fixId52, fixAllDescription, command) {
-  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId52, fixAllDescription && diagnosticToString(fixAllDescription), command);
+function createCodeFixActionMaybeFixAll(fixName8, changes, description3, fixId53, fixAllDescription, command) {
+  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId53, fixAllDescription && diagnosticToString(fixAllDescription), command);
 }
-function createCodeFixActionWorker(fixName8, description3, changes, fixId52, fixAllDescription, command) {
-  return { fixName: fixName8, description: description3, changes, fixId: fixId52, fixAllDescription, commands: command ? [command] : void 0 };
+function createCodeFixActionWorker(fixName8, description3, changes, fixId53, fixAllDescription, command) {
+  return { fixName: fixName8, description: description3, changes, fixId: fixId53, fixAllDescription, commands: command ? [command] : void 0 };
 }
 function registerCodeFix(reg) {
   for (const error2 of reg.errorCodes) {
@@ -147250,9 +147394,9 @@ function registerCodeFix(reg) {
     errorCodeToFixes.add(String(error2), reg);
   }
   if (reg.fixIds) {
-    for (const fixId52 of reg.fixIds) {
-      Debug.assert(!fixIdToRegistration.has(fixId52));
-      fixIdToRegistration.set(fixId52, reg);
+    for (const fixId53 of reg.fixIds) {
+      Debug.assert(!fixIdToRegistration.has(fixId53));
+      fixIdToRegistration.set(fixId53, reg);
     }
   }
 }
@@ -147261,17 +147405,17 @@ function getSupportedErrorCodes() {
   return errorCodeToFixesArray ?? (errorCodeToFixesArray = arrayFrom(errorCodeToFixes.keys()));
 }
 function removeFixIdIfFixAllUnavailable(registration, diagnostics) {
-  const { errorCodes: errorCodes65 } = registration;
+  const { errorCodes: errorCodes66 } = registration;
   let maybeFixableDiagnostics = 0;
   for (const diag2 of diagnostics) {
-    if (contains(errorCodes65, diag2.code))
+    if (contains(errorCodes66, diag2.code))
       maybeFixableDiagnostics++;
     if (maybeFixableDiagnostics > 1)
       break;
   }
   const fixAllUnavailable = maybeFixableDiagnostics < 2;
-  return ({ fixId: fixId52, fixAllDescription, ...action }) => {
-    return fixAllUnavailable ? action : { ...action, fixId: fixId52, fixAllDescription };
+  return ({ fixId: fixId53, fixAllDescription, ...action }) => {
+    return fixAllUnavailable ? action : { ...action, fixId: fixId53, fixAllDescription };
   };
 }
 function getFixes(context) {
@@ -147288,14 +147432,14 @@ function createCombinedCodeActions(changes, commands) {
 function createFileTextChanges(fileName, textChanges2) {
   return { fileName, textChanges: textChanges2 };
 }
-function codeFixAll(context, errorCodes65, use) {
+function codeFixAll(context, errorCodes66, use) {
   const commands = [];
-  const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes65, (diag2) => use(t, diag2, commands)));
+  const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes66, (diag2) => use(t, diag2, commands)));
   return createCombinedCodeActions(changes, commands.length === 0 ? void 0 : commands);
 }
-function eachDiagnostic(context, errorCodes65, cb) {
+function eachDiagnostic(context, errorCodes66, cb) {
   for (const diag2 of getDiagnostics(context)) {
-    if (contains(errorCodes65, diag2.code)) {
+    if (contains(errorCodes66, diag2.code)) {
       cb(diag2);
     }
   }
@@ -151224,7 +151368,8 @@ function promoteFromTypeOnly(changes, aliasDeclaration, program, sourceFile, pre
   switch (aliasDeclaration.kind) {
     case 276 /* ImportSpecifier */:
       if (aliasDeclaration.isTypeOnly) {
-        if (aliasDeclaration.parent.elements.length > 1) {
+        const sortKind = ts_OrganizeImports_exports.detectImportSpecifierSorting(aliasDeclaration.parent.elements, preferences);
+        if (aliasDeclaration.parent.elements.length > 1 && sortKind) {
           const newSpecifier = factory.updateImportSpecifier(
             aliasDeclaration,
             /*isTypeOnly*/
@@ -151232,8 +151377,8 @@ function promoteFromTypeOnly(changes, aliasDeclaration, program, sourceFile, pre
             aliasDeclaration.propertyName,
             aliasDeclaration.name
           );
-          const { specifierComparer } = ts_OrganizeImports_exports.getNamedImportSpecifierComparerWithDetection(aliasDeclaration.parent.parent.parent, preferences, sourceFile);
-          const insertionIndex = ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier, specifierComparer);
+          const comparer = ts_OrganizeImports_exports.getOrganizeImportsComparer(preferences, sortKind === 2 /* CaseInsensitive */);
+          const insertionIndex = ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier, comparer, preferences);
           if (insertionIndex !== aliasDeclaration.parent.elements.indexOf(aliasDeclaration)) {
             changes.delete(sourceFile, aliasDeclaration);
             changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
@@ -151273,8 +151418,7 @@ function promoteFromTypeOnly(changes, aliasDeclaration, program, sourceFile, pre
     if (convertExistingToTypeOnly) {
       const namedImports = tryCast(importClause.namedBindings, isNamedImports);
       if (namedImports && namedImports.elements.length > 1) {
-        const sortState = ts_OrganizeImports_exports.getNamedImportSpecifierComparerWithDetection(importClause.parent, preferences, sourceFile);
-        if (sortState.isSorted !== false && aliasDeclaration.kind === 276 /* ImportSpecifier */ && namedImports.elements.indexOf(aliasDeclaration) !== 0) {
+        if (ts_OrganizeImports_exports.detectImportSpecifierSorting(namedImports.elements, preferences) && aliasDeclaration.kind === 276 /* ImportSpecifier */ && namedImports.elements.indexOf(aliasDeclaration) !== 0) {
           changes.delete(sourceFile, aliasDeclaration);
           changes.insertImportSpecifierAtIndex(sourceFile, aliasDeclaration, namedImports, 0);
         }
@@ -151310,7 +151454,19 @@ function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImpor
     changes.insertNodeAt(sourceFile, clause.getStart(sourceFile), factory.createIdentifier(defaultImport.name), { suffix: ", " });
   }
   if (namedImports.length) {
-    const { specifierComparer, isSorted } = ts_OrganizeImports_exports.getNamedImportSpecifierComparerWithDetection(clause.parent, preferences, sourceFile);
+    let ignoreCaseForSorting;
+    if (typeof preferences.organizeImportsIgnoreCase === "boolean") {
+      ignoreCaseForSorting = preferences.organizeImportsIgnoreCase;
+    } else if (existingSpecifiers) {
+      const targetImportSorting = ts_OrganizeImports_exports.detectImportSpecifierSorting(existingSpecifiers, preferences);
+      if (targetImportSorting !== 3 /* Both */) {
+        ignoreCaseForSorting = targetImportSorting === 2 /* CaseInsensitive */;
+      }
+    }
+    if (ignoreCaseForSorting === void 0) {
+      ignoreCaseForSorting = ts_OrganizeImports_exports.detectSorting(sourceFile, preferences) === 2 /* CaseInsensitive */;
+    }
+    const comparer = ts_OrganizeImports_exports.getOrganizeImportsComparer(preferences, ignoreCaseForSorting);
     const newSpecifiers = stableSort(
       namedImports.map(
         (namedImport) => factory.createImportSpecifier(
@@ -151320,11 +151476,12 @@ function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImpor
           factory.createIdentifier(namedImport.name)
         )
       ),
-      specifierComparer
+      (s1, s2) => ts_OrganizeImports_exports.compareImportOrExportSpecifiers(s1, s2, comparer)
     );
-    if ((existingSpecifiers == null ? void 0 : existingSpecifiers.length) && isSorted !== false) {
+    const specifierSort = (existingSpecifiers == null ? void 0 : existingSpecifiers.length) && ts_OrganizeImports_exports.detectImportSpecifierSorting(existingSpecifiers, preferences);
+    if (specifierSort && !(ignoreCaseForSorting && specifierSort === 1 /* CaseSensitive */)) {
       for (const spec of newSpecifiers) {
-        const insertionIndex = ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(existingSpecifiers, spec, specifierComparer);
+        const insertionIndex = promoteFromTypeOnly2 && !spec.isTypeOnly ? 0 : ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(existingSpecifiers, spec, comparer, preferences);
         changes.insertImportSpecifierAtIndex(sourceFile, spec, clause.namedBindings, insertionIndex);
       }
     } else if (existingSpecifiers == null ? void 0 : existingSpecifiers.length) {
@@ -151693,10 +151850,10 @@ registerCodeFix({
     const info = errorCodeFixIdMap[errorCode];
     if (!info)
       return emptyArray;
-    const { descriptions, fixId: fixId52, fixAllDescriptions } = info;
+    const { descriptions, fixId: fixId53, fixAllDescriptions } = info;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => dispatchChanges(changes2, context, errorCode, span.start));
     return [
-      createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId52, fixAllDescriptions)
+      createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId53, fixAllDescriptions)
     ];
   },
   fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId],
@@ -152501,7 +152658,7 @@ registerCodeFix({
   },
   fixIds: [fixMissingMember, fixMissingFunctionDeclaration, fixMissingProperties, fixMissingAttributes],
   getAllCodeActions: (context) => {
-    const { program, fixId: fixId52 } = context;
+    const { program, fixId: fixId53 } = context;
     const checker = program.getTypeChecker();
     const seen = /* @__PURE__ */ new Map();
     const typeDeclToMembers = /* @__PURE__ */ new Map();
@@ -152511,11 +152668,11 @@ registerCodeFix({
         if (!info || !addToSeen(seen, getNodeId(info.parentDeclaration) + "#" + (info.kind === 3 /* ObjectLiteral */ ? info.identifier : info.token.text))) {
           return;
         }
-        if (fixId52 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
+        if (fixId53 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
           addFunctionDeclaration(changes, context, info);
-        } else if (fixId52 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
+        } else if (fixId53 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
           addObjectLiteralProperties(changes, context, info);
-        } else if (fixId52 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
+        } else if (fixId53 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
           addJsxAttributes(changes, context, info);
         } else {
           if (info.kind === 1 /* Enum */) {
@@ -154409,21 +154566,21 @@ registerCodeFix({
       actions2.push(fix(type, fixIdNullable, Diagnostics.Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types));
     }
     return actions2;
-    function fix(type2, fixId52, fixAllDescription) {
+    function fix(type2, fixId53, fixAllDescription) {
       const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange29(t, sourceFile, typeNode, type2, checker));
-      return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId52, fixAllDescription);
+      return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId53, fixAllDescription);
     }
   },
   fixIds: [fixIdPlain, fixIdNullable],
   getAllCodeActions(context) {
-    const { fixId: fixId52, program, sourceFile } = context;
+    const { fixId: fixId53, program, sourceFile } = context;
     const checker = program.getTypeChecker();
     return codeFixAll(context, errorCodes45, (changes, err) => {
       const info = getInfo15(err.file, err.start, checker);
       if (!info)
         return;
       const { typeNode, type } = info;
-      const fixedType = typeNode.kind === 314 /* JSDocNullableType */ && fixId52 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
+      const fixedType = typeNode.kind === 314 /* JSDocNullableType */ && fixId53 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
       doChange29(changes, sourceFile, typeNode, fixedType, checker);
     });
   }
@@ -157131,11 +157288,31 @@ function flattenInvalidBinaryExpr(node) {
   }
 }
 
-// src/services/codefixes/convertToMappedObjectType.ts
-var fixId45 = "fixConvertToMappedObjectType";
-var errorCodes58 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
+// src/services/codefixes/wrapDecoratorInParentheses.ts
+var fixId45 = "wrapDecoratorInParentheses";
+var errorCodes58 = [Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator.code];
 registerCodeFix({
   errorCodes: errorCodes58,
+  getCodeActions: function getCodeActionsToWrapDecoratorExpressionInParentheses(context) {
+    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange10(t, context.sourceFile, context.span.start));
+    return [createCodeFixAction(fixId45, changes, Diagnostics.Wrap_in_parentheses, fixId45, Diagnostics.Wrap_all_invalid_decorator_expressions_in_parentheses)];
+  },
+  fixIds: [fixId45],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes58, (changes, diag2) => makeChange10(changes, diag2.file, diag2.start))
+});
+function makeChange10(changeTracker, sourceFile, pos) {
+  const token = getTokenAtPosition(sourceFile, pos);
+  const decorator = findAncestor(token, isDecorator);
+  Debug.assert(!!decorator, "Expected position to be owned by a decorator.");
+  const replacement = factory.createParenthesizedExpression(decorator.expression);
+  changeTracker.replaceNode(sourceFile, decorator.expression, replacement);
+}
+
+// src/services/codefixes/convertToMappedObjectType.ts
+var fixId46 = "fixConvertToMappedObjectType";
+var errorCodes59 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
+registerCodeFix({
+  errorCodes: errorCodes59,
   getCodeActions: function getCodeActionsToConvertToMappedTypeObject(context) {
     const { sourceFile, span } = context;
     const info = getInfo20(sourceFile, span.start);
@@ -157143,10 +157320,10 @@ registerCodeFix({
       return void 0;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange39(t, sourceFile, info));
     const name = idText(info.container.name);
-    return [createCodeFixAction(fixId45, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId45, [Diagnostics.Convert_0_to_mapped_object_type, name])];
+    return [createCodeFixAction(fixId46, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId46, [Diagnostics.Convert_0_to_mapped_object_type, name])];
   },
-  fixIds: [fixId45],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes58, (changes, diag2) => {
+  fixIds: [fixId46],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes59, (changes, diag2) => {
     const info = getInfo20(diag2.file, diag2.start);
     if (info)
       doChange39(changes, diag2.file, info);
@@ -157194,12 +157371,12 @@ function doChange39(changes, sourceFile, { indexSignature, container }) {
 }
 
 // src/services/codefixes/removeAccidentalCallParentheses.ts
-var fixId46 = "removeAccidentalCallParentheses";
-var errorCodes59 = [
+var fixId47 = "removeAccidentalCallParentheses";
+var errorCodes60 = [
   Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without.code
 ];
 registerCodeFix({
-  errorCodes: errorCodes59,
+  errorCodes: errorCodes60,
   getCodeActions(context) {
     const callExpression = findAncestor(getTokenAtPosition(context.sourceFile, context.span.start), isCallExpression);
     if (!callExpression) {
@@ -157208,30 +157385,30 @@ registerCodeFix({
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
       t.deleteRange(context.sourceFile, { pos: callExpression.expression.end, end: callExpression.end });
     });
-    return [createCodeFixActionWithoutFixAll(fixId46, changes, Diagnostics.Remove_parentheses)];
+    return [createCodeFixActionWithoutFixAll(fixId47, changes, Diagnostics.Remove_parentheses)];
   },
-  fixIds: [fixId46]
+  fixIds: [fixId47]
 });
 
 // src/services/codefixes/removeUnnecessaryAwait.ts
-var fixId47 = "removeUnnecessaryAwait";
-var errorCodes60 = [
+var fixId48 = "removeUnnecessaryAwait";
+var errorCodes61 = [
   Diagnostics.await_has_no_effect_on_the_type_of_this_expression.code
 ];
 registerCodeFix({
-  errorCodes: errorCodes60,
+  errorCodes: errorCodes61,
   getCodeActions: function getCodeActionsToRemoveUnnecessaryAwait(context) {
-    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange10(t, context.sourceFile, context.span));
+    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange11(t, context.sourceFile, context.span));
     if (changes.length > 0) {
-      return [createCodeFixAction(fixId47, changes, Diagnostics.Remove_unnecessary_await, fixId47, Diagnostics.Remove_all_unnecessary_uses_of_await)];
+      return [createCodeFixAction(fixId48, changes, Diagnostics.Remove_unnecessary_await, fixId48, Diagnostics.Remove_all_unnecessary_uses_of_await)];
     }
   },
-  fixIds: [fixId47],
+  fixIds: [fixId48],
   getAllCodeActions: (context) => {
-    return codeFixAll(context, errorCodes60, (changes, diag2) => makeChange10(changes, diag2.file, diag2));
+    return codeFixAll(context, errorCodes61, (changes, diag2) => makeChange11(changes, diag2.file, diag2));
   }
 });
-function makeChange10(changeTracker, sourceFile, span) {
+function makeChange11(changeTracker, sourceFile, span) {
   const awaitKeyword = tryCast(getTokenAtPosition(sourceFile, span.start), (node) => node.kind === 135 /* AwaitKeyword */);
   const awaitExpression = awaitKeyword && tryCast(awaitKeyword.parent, isAwaitExpression);
   if (!awaitExpression) {
@@ -157256,20 +157433,20 @@ function makeChange10(changeTracker, sourceFile, span) {
 }
 
 // src/services/codefixes/splitTypeOnlyImport.ts
-var errorCodes61 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
-var fixId48 = "splitTypeOnlyImport";
+var errorCodes62 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
+var fixId49 = "splitTypeOnlyImport";
 registerCodeFix({
-  errorCodes: errorCodes61,
-  fixIds: [fixId48],
+  errorCodes: errorCodes62,
+  fixIds: [fixId49],
   getCodeActions: function getCodeActionsToSplitTypeOnlyImport(context) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
       return splitTypeOnlyImport(t, getImportDeclaration2(context.sourceFile, context.span), context);
     });
     if (changes.length) {
-      return [createCodeFixAction(fixId48, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId48, Diagnostics.Split_all_invalid_type_only_imports)];
+      return [createCodeFixAction(fixId49, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId49, Diagnostics.Split_all_invalid_type_only_imports)];
     }
   },
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes61, (changes, error2) => {
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes62, (changes, error2) => {
     splitTypeOnlyImport(changes, getImportDeclaration2(context.sourceFile, error2), context);
   })
 });
@@ -157318,23 +157495,23 @@ function splitTypeOnlyImport(changes, importDeclaration, context) {
 }
 
 // src/services/codefixes/convertConstToLet.ts
-var fixId49 = "fixConvertConstToLet";
-var errorCodes62 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
+var fixId50 = "fixConvertConstToLet";
+var errorCodes63 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
 registerCodeFix({
-  errorCodes: errorCodes62,
+  errorCodes: errorCodes63,
   getCodeActions: function getCodeActionsToConvertConstToLet(context) {
     const { sourceFile, span, program } = context;
     const info = getInfo21(sourceFile, span.start, program);
     if (info === void 0)
       return;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange40(t, sourceFile, info.token));
-    return [createCodeFixActionMaybeFixAll(fixId49, changes, Diagnostics.Convert_const_to_let, fixId49, Diagnostics.Convert_all_const_to_let)];
+    return [createCodeFixActionMaybeFixAll(fixId50, changes, Diagnostics.Convert_const_to_let, fixId50, Diagnostics.Convert_all_const_to_let)];
   },
   getAllCodeActions: (context) => {
     const { program } = context;
     const seen = /* @__PURE__ */ new Map();
     return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-      eachDiagnostic(context, errorCodes62, (diag2) => {
+      eachDiagnostic(context, errorCodes63, (diag2) => {
         const info = getInfo21(diag2.file, diag2.start, program);
         if (info) {
           if (addToSeen(seen, getSymbolId(info.symbol))) {
@@ -157345,7 +157522,7 @@ registerCodeFix({
       });
     }));
   },
-  fixIds: [fixId49]
+  fixIds: [fixId50]
 });
 function getInfo21(sourceFile, pos, program) {
   var _a;
@@ -157366,11 +157543,11 @@ function doChange40(changes, sourceFile, token) {
 }
 
 // src/services/codefixes/fixExpectedComma.ts
-var fixId50 = "fixExpectedComma";
+var fixId51 = "fixExpectedComma";
 var expectedErrorCode = Diagnostics._0_expected.code;
-var errorCodes63 = [expectedErrorCode];
+var errorCodes64 = [expectedErrorCode];
 registerCodeFix({
-  errorCodes: errorCodes63,
+  errorCodes: errorCodes64,
   getCodeActions(context) {
     const { sourceFile } = context;
     const info = getInfo22(sourceFile, context.span.start, context.errorCode);
@@ -157378,15 +157555,15 @@ registerCodeFix({
       return void 0;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange41(t, sourceFile, info));
     return [createCodeFixAction(
-      fixId50,
+      fixId51,
       changes,
       [Diagnostics.Change_0_to_1, ";", ","],
-      fixId50,
+      fixId51,
       [Diagnostics.Change_0_to_1, ";", ","]
     )];
   },
-  fixIds: [fixId50],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes63, (changes, diag2) => {
+  fixIds: [fixId51],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes64, (changes, diag2) => {
     const info = getInfo22(diag2.file, diag2.start, diag2.code);
     if (info)
       doChange41(changes, context.sourceFile, info);
@@ -157403,25 +157580,25 @@ function doChange41(changes, sourceFile, { node }) {
 
 // src/services/codefixes/fixAddVoidToPromise.ts
 var fixName7 = "addVoidToPromise";
-var fixId51 = "addVoidToPromise";
-var errorCodes64 = [
+var fixId52 = "addVoidToPromise";
+var errorCodes65 = [
   Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments.code,
   Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise.code
 ];
 registerCodeFix({
-  errorCodes: errorCodes64,
-  fixIds: [fixId51],
+  errorCodes: errorCodes65,
+  fixIds: [fixId52],
   getCodeActions(context) {
-    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange11(t, context.sourceFile, context.span, context.program));
+    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange12(t, context.sourceFile, context.span, context.program));
     if (changes.length > 0) {
-      return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId51, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)];
+      return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId52, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)];
     }
   },
   getAllCodeActions(context) {
-    return codeFixAll(context, errorCodes64, (changes, diag2) => makeChange11(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set()));
+    return codeFixAll(context, errorCodes65, (changes, diag2) => makeChange12(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set()));
   }
 });
-function makeChange11(changes, sourceFile, span, program, seen) {
+function makeChange12(changes, sourceFile, span, program, seen) {
   const node = getTokenAtPosition(sourceFile, span.start);
   if (!isIdentifier(node) || !isCallExpression(node.parent) || node.parent.expression !== node || node.parent.arguments.length !== 0)
     return;
@@ -166498,16 +166675,18 @@ function getRightHandSideOfAssignment(rightHandSide) {
 // src/services/_namespaces/ts.OrganizeImports.ts
 var ts_OrganizeImports_exports = {};
 __export(ts_OrganizeImports_exports, {
+  coalesceExports: () => coalesceExports,
+  coalesceImports: () => coalesceImports,
+  compareImportOrExportSpecifiers: () => compareImportOrExportSpecifiers,
   compareImportsOrRequireStatements: () => compareImportsOrRequireStatements,
   compareModuleSpecifiers: () => compareModuleSpecifiers2,
-  getDetectionLists: () => getDetectionLists,
+  detectImportDeclarationSorting: () => detectImportDeclarationSorting,
+  detectImportSpecifierSorting: () => detectImportSpecifierSorting,
+  detectSorting: () => detectSorting,
   getImportDeclarationInsertionIndex: () => getImportDeclarationInsertionIndex,
   getImportSpecifierInsertionIndex: () => getImportSpecifierInsertionIndex,
-  getNamedImportSpecifierComparerWithDetection: () => getNamedImportSpecifierComparerWithDetection,
-  getOrganizeImportsStringComparerWithDetection: () => getOrganizeImportsStringComparerWithDetection,
-  organizeImports: () => organizeImports,
-  testCoalesceExports: () => testCoalesceExports,
-  testCoalesceImports: () => testCoalesceImports
+  getOrganizeImportsComparer: () => getOrganizeImportsComparer,
+  organizeImports: () => organizeImports
 });
 
 // src/services/organizeImports.ts
@@ -166516,48 +166695,39 @@ function organizeImports(sourceFile, formatContext, host, program, preferences,
   const shouldSort = mode === "SortAndCombine" /* SortAndCombine */ || mode === "All" /* All */;
   const shouldCombine = shouldSort;
   const shouldRemove = mode === "RemoveUnused" /* RemoveUnused */ || mode === "All" /* All */;
-  const topLevelImportDecls = sourceFile.statements.filter(isImportDeclaration);
-  const topLevelImportGroupDecls = groupByNewlineContiguous(sourceFile, topLevelImportDecls);
-  const { comparersToTest, typeOrdersToTest } = getDetectionLists(preferences);
-  const defaultComparer = comparersToTest[0];
-  const comparer = {
-    moduleSpecifierComparer: typeof preferences.organizeImportsIgnoreCase === "boolean" ? defaultComparer : void 0,
-    namedImportComparer: typeof preferences.organizeImportsIgnoreCase === "boolean" ? defaultComparer : void 0,
-    typeOrder: preferences.organizeImportsTypeOrder
+  const topLevelImportGroupDecls = groupByNewlineContiguous(sourceFile, sourceFile.statements.filter(isImportDeclaration));
+  const comparer = getOrganizeImportsComparerWithDetection(preferences, shouldSort ? () => detectSortingWorker(topLevelImportGroupDecls, preferences) === 2 /* CaseInsensitive */ : void 0);
+  const processImportsOfSameModuleSpecifier = (importGroup) => {
+    if (shouldRemove)
+      importGroup = removeUnusedImports(importGroup, sourceFile, program);
+    if (shouldCombine)
+      importGroup = coalesceImportsWorker(importGroup, comparer, sourceFile, preferences);
+    if (shouldSort)
+      importGroup = stableSort(importGroup, (s1, s2) => compareImportsOrRequireStatements(s1, s2, comparer));
+    return importGroup;
   };
-  if (typeof preferences.organizeImportsIgnoreCase !== "boolean") {
-    ({ comparer: comparer.moduleSpecifierComparer } = detectModuleSpecifierCaseBySort(topLevelImportGroupDecls, comparersToTest));
-  }
-  if (!comparer.typeOrder || typeof preferences.organizeImportsIgnoreCase !== "boolean") {
-    const namedImportSort = detectNamedImportOrganizationBySort(topLevelImportDecls, comparersToTest, typeOrdersToTest);
-    if (namedImportSort) {
-      const { namedImportComparer, typeOrder } = namedImportSort;
-      comparer.namedImportComparer = comparer.namedImportComparer ?? namedImportComparer;
-      comparer.typeOrder = comparer.typeOrder ?? typeOrder;
-    }
-  }
-  topLevelImportGroupDecls.forEach((importGroupDecl) => organizeImportsWorker(importGroupDecl, comparer));
+  topLevelImportGroupDecls.forEach((importGroupDecl) => organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier));
   if (mode !== "RemoveUnused" /* RemoveUnused */) {
-    getTopLevelExportGroups(sourceFile).forEach((exportGroupDecl) => organizeExportsWorker(exportGroupDecl, comparer.namedImportComparer));
+    getTopLevelExportGroups(sourceFile).forEach((exportGroupDecl) => organizeImportsWorker(exportGroupDecl, (group2) => coalesceExportsWorker(group2, comparer, preferences)));
   }
   for (const ambientModule of sourceFile.statements.filter(isAmbientModule)) {
     if (!ambientModule.body)
       continue;
     const ambientModuleImportGroupDecls = groupByNewlineContiguous(sourceFile, ambientModule.body.statements.filter(isImportDeclaration));
-    ambientModuleImportGroupDecls.forEach((importGroupDecl) => organizeImportsWorker(importGroupDecl, comparer));
+    ambientModuleImportGroupDecls.forEach((importGroupDecl) => organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier));
     if (mode !== "RemoveUnused" /* RemoveUnused */) {
       const ambientModuleExportDecls = ambientModule.body.statements.filter(isExportDeclaration);
-      organizeExportsWorker(ambientModuleExportDecls, comparer.namedImportComparer);
+      organizeImportsWorker(ambientModuleExportDecls, (group2) => coalesceExportsWorker(group2, comparer, preferences));
     }
   }
   return changeTracker.getChanges();
-  function organizeDeclsWorker(oldImportDecls, coalesce) {
+  function organizeImportsWorker(oldImportDecls, coalesce) {
     if (length(oldImportDecls) === 0) {
       return;
     }
     setEmitFlags(oldImportDecls[0], 1024 /* NoLeadingComments */);
     const oldImportGroups = shouldCombine ? group(oldImportDecls, (importDecl) => getExternalModuleName2(importDecl.moduleSpecifier)) : [oldImportDecls];
-    const sortedImportGroups = shouldSort ? stableSort(oldImportGroups, (group1, group2) => compareModuleSpecifiersWorker(group1[0].moduleSpecifier, group2[0].moduleSpecifier, comparer.moduleSpecifierComparer ?? defaultComparer)) : oldImportGroups;
+    const sortedImportGroups = shouldSort ? stableSort(oldImportGroups, (group1, group2) => compareModuleSpecifiersWorker(group1[0].moduleSpecifier, group2[0].moduleSpecifier, comparer)) : oldImportGroups;
     const newImportDecls = flatMap(sortedImportGroups, (importGroup) => getExternalModuleName2(importGroup[0].moduleSpecifier) || importGroup[0].moduleSpecifier === void 0 ? coalesce(importGroup) : importGroup);
     if (newImportDecls.length === 0) {
       changeTracker.deleteNodes(
@@ -166584,40 +166754,6 @@ function organizeImports(sourceFile, formatContext, host, program, preferences,
       }, hasTrailingComment);
     }
   }
-  function organizeImportsWorker(oldImportDecls, comparer2) {
-    const detectedModuleCaseComparer = comparer2.moduleSpecifierComparer ?? defaultComparer;
-    const detectedNamedImportCaseComparer = comparer2.namedImportComparer ?? defaultComparer;
-    const detectedTypeOrder = comparer2.typeOrder ?? "last";
-    const specifierComparer = getNamedImportSpecifierComparer({ organizeImportsTypeOrder: detectedTypeOrder }, detectedNamedImportCaseComparer);
-    const processImportsOfSameModuleSpecifier = (importGroup) => {
-      if (shouldRemove)
-        importGroup = removeUnusedImports(importGroup, sourceFile, program);
-      if (shouldCombine)
-        importGroup = coalesceImportsWorker(importGroup, detectedModuleCaseComparer, specifierComparer, sourceFile);
-      if (shouldSort)
-        importGroup = stableSort(importGroup, (s1, s2) => compareImportsOrRequireStatements(s1, s2, detectedModuleCaseComparer));
-      return importGroup;
-    };
-    organizeDeclsWorker(oldImportDecls, processImportsOfSameModuleSpecifier);
-  }
-  function organizeExportsWorker(oldExportDecls, specifierCaseComparer) {
-    const useComparer = getNamedImportSpecifierComparer(preferences, specifierCaseComparer);
-    organizeDeclsWorker(oldExportDecls, (group2) => coalesceExportsWorker(group2, useComparer));
-  }
-}
-function getDetectionLists(preferences) {
-  return {
-    comparersToTest: typeof preferences.organizeImportsIgnoreCase === "boolean" ? [getOrganizeImportsStringComparer(preferences, preferences.organizeImportsIgnoreCase)] : [getOrganizeImportsStringComparer(
-      preferences,
-      /*ignoreCase*/
-      true
-    ), getOrganizeImportsStringComparer(
-      preferences,
-      /*ignoreCase*/
-      false
-    )],
-    typeOrdersToTest: preferences.organizeImportsTypeOrder ? [preferences.organizeImportsTypeOrder] : ["last", "inline", "first"]
-  };
 }
 function groupByNewlineContiguous(sourceFile, decls) {
   const scanner2 = createScanner(
@@ -166655,33 +166791,6 @@ function isNewGroup(sourceFile, decl, scanner2) {
   }
   return false;
 }
-function getTopLevelExportGroups(sourceFile) {
-  const topLevelExportGroups = [];
-  const statements = sourceFile.statements;
-  const len = length(statements);
-  let i = 0;
-  let groupIndex = 0;
-  while (i < len) {
-    if (isExportDeclaration(statements[i])) {
-      if (topLevelExportGroups[groupIndex] === void 0) {
-        topLevelExportGroups[groupIndex] = [];
-      }
-      const exportDecl = statements[i];
-      if (exportDecl.moduleSpecifier) {
-        topLevelExportGroups[groupIndex].push(exportDecl);
-        i++;
-      } else {
-        while (i < len && isExportDeclaration(statements[i])) {
-          topLevelExportGroups[groupIndex].push(statements[i++]);
-        }
-        groupIndex++;
-      }
-    } else {
-      i++;
-    }
-  }
-  return flatMap(topLevelExportGroups, (exportGroupDecls) => groupByNewlineContiguous(sourceFile, exportGroupDecls));
-}
 function removeUnusedImports(oldImports, sourceFile, program) {
   const typeChecker = program.getTypeChecker();
   const compilerOptions = program.getCompilerOptions();
@@ -166733,38 +166842,18 @@ function removeUnusedImports(oldImports, sourceFile, program) {
     return jsxElementsPresent && (identifier.text === jsxNamespace || jsxFragmentFactory && identifier.text === jsxFragmentFactory) && jsxModeNeedsExplicitImport(compilerOptions.jsx) || ts_FindAllReferences_exports.Core.isSymbolReferencedInFile(identifier, typeChecker, sourceFile);
   }
 }
+function hasModuleDeclarationMatchingSpecifier(sourceFile, moduleSpecifier) {
+  const moduleSpecifierText = isStringLiteral(moduleSpecifier) && moduleSpecifier.text;
+  return isString(moduleSpecifierText) && some(sourceFile.moduleAugmentations, (moduleName) => isStringLiteral(moduleName) && moduleName.text === moduleSpecifierText);
+}
 function getExternalModuleName2(specifier) {
   return specifier !== void 0 && isStringLiteralLike(specifier) ? specifier.text : void 0;
 }
-function getCategorizedImports(importGroup) {
-  let importWithoutClause;
-  const typeOnlyImports = { defaultImports: [], namespaceImports: [], namedImports: [] };
-  const regularImports = { defaultImports: [], namespaceImports: [], namedImports: [] };
-  for (const importDeclaration of importGroup) {
-    if (importDeclaration.importClause === void 0) {
-      importWithoutClause = importWithoutClause || importDeclaration;
-      continue;
-    }
-    const group2 = importDeclaration.importClause.isTypeOnly ? typeOnlyImports : regularImports;
-    const { name, namedBindings } = importDeclaration.importClause;
-    if (name) {
-      group2.defaultImports.push(importDeclaration);
-    }
-    if (namedBindings) {
-      if (isNamespaceImport(namedBindings)) {
-        group2.namespaceImports.push(importDeclaration);
-      } else {
-        group2.namedImports.push(importDeclaration);
-      }
-    }
-  }
-  return {
-    importWithoutClause,
-    typeOnlyImports,
-    regularImports
-  };
+function coalesceImports(importGroup, ignoreCase, sourceFile, preferences) {
+  const comparer = getOrganizeImportsOrdinalStringComparer(ignoreCase);
+  return coalesceImportsWorker(importGroup, comparer, sourceFile, preferences);
 }
-function coalesceImportsWorker(importGroup, comparer, specifierComparer, sourceFile) {
+function coalesceImportsWorker(importGroup, comparer, sourceFile, preferences) {
   if (importGroup.length === 0) {
     return importGroup;
   }
@@ -166831,7 +166920,7 @@ function coalesceImportsWorker(importGroup, comparer, specifierComparer, sourceF
       }
       newImportSpecifiers.push(...getNewImportSpecifiers(namedImports));
       const sortedImportSpecifiers = factory.createNodeArray(
-        stableSort(newImportSpecifiers, specifierComparer),
+        sortSpecifiers(newImportSpecifiers, comparer, preferences),
         firstNamedImport == null ? void 0 : firstNamedImport.importClause.namedBindings.elements.hasTrailingComma
       );
       const newNamedImports = sortedImportSpecifiers.length === 0 ? newDefaultImport ? void 0 : factory.createNamedImports(emptyArray) : firstNamedImport ? factory.updateNamedImports(firstNamedImport.importClause.namedBindings, sortedImportSpecifiers) : factory.createNamedImports(sortedImportSpecifiers);
@@ -166864,7 +166953,39 @@ function coalesceImportsWorker(importGroup, comparer, specifierComparer, sourceF
   }
   return coalescedImports;
 }
-function coalesceExportsWorker(exportGroup, specifierComparer) {
+function getCategorizedImports(importGroup) {
+  let importWithoutClause;
+  const typeOnlyImports = { defaultImports: [], namespaceImports: [], namedImports: [] };
+  const regularImports = { defaultImports: [], namespaceImports: [], namedImports: [] };
+  for (const importDeclaration of importGroup) {
+    if (importDeclaration.importClause === void 0) {
+      importWithoutClause = importWithoutClause || importDeclaration;
+      continue;
+    }
+    const group2 = importDeclaration.importClause.isTypeOnly ? typeOnlyImports : regularImports;
+    const { name, namedBindings } = importDeclaration.importClause;
+    if (name) {
+      group2.defaultImports.push(importDeclaration);
+    }
+    if (namedBindings) {
+      if (isNamespaceImport(namedBindings)) {
+        group2.namespaceImports.push(importDeclaration);
+      } else {
+        group2.namedImports.push(importDeclaration);
+      }
+    }
+  }
+  return {
+    importWithoutClause,
+    typeOnlyImports,
+    regularImports
+  };
+}
+function coalesceExports(exportGroup, ignoreCase, preferences) {
+  const comparer = getOrganizeImportsOrdinalStringComparer(ignoreCase);
+  return coalesceExportsWorker(exportGroup, comparer, preferences);
+}
+function coalesceExportsWorker(exportGroup, comparer, preferences) {
   if (exportGroup.length === 0) {
     return exportGroup;
   }
@@ -166879,7 +167000,7 @@ function coalesceExportsWorker(exportGroup, specifierComparer) {
     }
     const newExportSpecifiers = [];
     newExportSpecifiers.push(...flatMap(exportGroup2, (i) => i.exportClause && isNamedExports(i.exportClause) ? i.exportClause.elements : emptyArray));
-    const sortedExportSpecifiers = stableSort(newExportSpecifiers, specifierComparer);
+    const sortedExportSpecifiers = sortSpecifiers(newExportSpecifiers, comparer, preferences);
     const exportDecl = exportGroup2[0];
     coalescedExports.push(
       factory.updateExportDeclaration(
@@ -166923,6 +167044,9 @@ function updateImportDeclarationAndClause(importDeclaration, name, namedBindings
     importDeclaration.attributes
   );
 }
+function sortSpecifiers(specifiers, comparer, preferences) {
+  return stableSort(specifiers, (s1, s2) => compareImportOrExportSpecifiers(s1, s2, comparer, preferences));
+}
 function compareImportOrExportSpecifiers(s1, s2, comparer, preferences) {
   switch (preferences == null ? void 0 : preferences.organizeImportsTypeOrder) {
     case "first":
@@ -166933,14 +167057,15 @@ function compareImportOrExportSpecifiers(s1, s2, comparer, preferences) {
       return compareBooleans(s1.isTypeOnly, s2.isTypeOnly) || comparer(s1.name.text, s2.name.text);
   }
 }
+function compareModuleSpecifiers2(m1, m2, ignoreCase) {
+  const comparer = getOrganizeImportsOrdinalStringComparer(!!ignoreCase);
+  return compareModuleSpecifiersWorker(m1, m2, comparer);
+}
 function compareModuleSpecifiersWorker(m1, m2, comparer) {
   const name1 = m1 === void 0 ? void 0 : getExternalModuleName2(m1);
   const name2 = m2 === void 0 ? void 0 : getExternalModuleName2(m2);
   return compareBooleans(name1 === void 0, name2 === void 0) || compareBooleans(isExternalModuleNameRelative(name1), isExternalModuleNameRelative(name2)) || comparer(name1, name2);
 }
-function getModuleNamesFromDecls(decls) {
-  return decls.map((s) => getExternalModuleName2(getModuleSpecifierExpression(s)) || "");
-}
 function getModuleSpecifierExpression(declaration) {
   var _a;
   switch (declaration.kind) {
@@ -166952,114 +167077,164 @@ function getModuleSpecifierExpression(declaration) {
       return declaration.declarationList.declarations[0].initializer.arguments[0];
   }
 }
-function hasModuleDeclarationMatchingSpecifier(sourceFile, moduleSpecifier) {
-  const moduleSpecifierText = isStringLiteral(moduleSpecifier) && moduleSpecifier.text;
-  return isString(moduleSpecifierText) && some(sourceFile.moduleAugmentations, (moduleName) => isStringLiteral(moduleName) && moduleName.text === moduleSpecifierText);
-}
-function getNewImportSpecifiers(namedImports) {
-  return flatMap(namedImports, (namedImport) => map(tryGetNamedBindingElements(namedImport), (importSpecifier) => importSpecifier.name && importSpecifier.propertyName && importSpecifier.name.escapedText === importSpecifier.propertyName.escapedText ? factory.updateImportSpecifier(
-    importSpecifier,
-    importSpecifier.isTypeOnly,
-    /*propertyName*/
-    void 0,
-    importSpecifier.name
-  ) : importSpecifier));
-}
-function tryGetNamedBindingElements(namedImport) {
-  var _a;
-  return ((_a = namedImport.importClause) == null ? void 0 : _a.namedBindings) && isNamedImports(namedImport.importClause.namedBindings) ? namedImport.importClause.namedBindings.elements : void 0;
-}
-function detectModuleSpecifierCaseBySort(importDeclsByGroup, comparersToTest) {
-  const moduleSpecifiersByGroup = [];
-  importDeclsByGroup.forEach((importGroup) => {
-    moduleSpecifiersByGroup.push(getModuleNamesFromDecls(importGroup));
-  });
-  return detectCaseSensitivityBySort(moduleSpecifiersByGroup, comparersToTest);
+function detectSorting(sourceFile, preferences) {
+  return detectSortingWorker(
+    groupByNewlineContiguous(sourceFile, sourceFile.statements.filter(isImportDeclaration)),
+    preferences
+  );
 }
-function detectNamedImportOrganizationBySort(originalGroups, comparersToTest, typesToTest) {
-  let bothNamedImports = false;
-  const importDeclsWithNamed = originalGroups.filter((i) => {
-    var _a, _b;
-    const namedImports = (_b = tryCast((_a = i.importClause) == null ? void 0 : _a.namedBindings, isNamedImports)) == null ? void 0 : _b.elements;
-    if (!(namedImports == null ? void 0 : namedImports.length))
-      return false;
-    if (!bothNamedImports && namedImports.some((n) => n.isTypeOnly) && namedImports.some((n) => !n.isTypeOnly)) {
-      bothNamedImports = true;
-    }
-    return true;
-  });
-  if (importDeclsWithNamed.length === 0)
-    return;
-  const namedImportsByDecl = importDeclsWithNamed.map((importDecl) => {
-    var _a, _b;
-    return (_b = tryCast((_a = importDecl.importClause) == null ? void 0 : _a.namedBindings, isNamedImports)) == null ? void 0 : _b.elements;
-  }).filter((elements) => elements !== void 0);
-  if (!bothNamedImports || typesToTest.length === 0) {
-    const sortState = detectCaseSensitivityBySort(namedImportsByDecl.map((i) => i.map((n) => n.name.text)), comparersToTest);
-    return {
-      namedImportComparer: sortState.comparer,
-      typeOrder: typesToTest.length === 1 ? typesToTest[0] : void 0,
-      isSorted: sortState.isSorted
-    };
-  }
-  const bestDiff = { first: Infinity, last: Infinity, inline: Infinity };
-  const bestComparer = { first: comparersToTest[0], last: comparersToTest[0], inline: comparersToTest[0] };
-  for (const curComparer of comparersToTest) {
-    const currDiff = { first: 0, last: 0, inline: 0 };
-    for (const importDecl of namedImportsByDecl) {
-      for (const typeOrder of typesToTest) {
-        currDiff[typeOrder] = (currDiff[typeOrder] ?? 0) + measureSortedness(importDecl, (n1, n2) => compareImportOrExportSpecifiers(n1, n2, curComparer, { organizeImportsTypeOrder: typeOrder }));
+function detectSortingWorker(importGroups, preferences) {
+  const collateCaseSensitive = getOrganizeImportsComparer(
+    preferences,
+    /*ignoreCase*/
+    false
+  );
+  const collateCaseInsensitive = getOrganizeImportsComparer(
+    preferences,
+    /*ignoreCase*/
+    true
+  );
+  let sortState = 3 /* Both */;
+  let seenUnsortedGroup = false;
+  for (const importGroup of importGroups) {
+    if (importGroup.length > 1) {
+      const moduleSpecifierSort = detectSortCaseSensitivity(
+        importGroup,
+        (i) => {
+          var _a;
+          return ((_a = tryCast(i.moduleSpecifier, isStringLiteral)) == null ? void 0 : _a.text) ?? "";
+        },
+        collateCaseSensitive,
+        collateCaseInsensitive
+      );
+      if (moduleSpecifierSort) {
+        sortState &= moduleSpecifierSort;
+        seenUnsortedGroup = true;
       }
-    }
-    for (const key of typesToTest) {
-      const typeOrder = key;
-      if (currDiff[typeOrder] < bestDiff[typeOrder]) {
-        bestDiff[typeOrder] = currDiff[typeOrder];
-        bestComparer[typeOrder] = curComparer;
+      if (!sortState) {
+        return sortState;
       }
     }
-  }
-  outer:
-    for (const bestKey of typesToTest) {
-      const bestTypeOrder = bestKey;
-      for (const testKey of typesToTest) {
-        const testTypeOrder = testKey;
-        if (bestDiff[testTypeOrder] < bestDiff[bestTypeOrder])
-          continue outer;
+    const declarationWithNamedImports = find(
+      importGroup,
+      (i) => {
+        var _a, _b;
+        return ((_b = tryCast((_a = i.importClause) == null ? void 0 : _a.namedBindings, isNamedImports)) == null ? void 0 : _b.elements.length) > 1;
+      }
+    );
+    if (declarationWithNamedImports) {
+      const namedImportSort = detectImportSpecifierSorting(declarationWithNamedImports.importClause.namedBindings.elements, preferences);
+      if (namedImportSort) {
+        sortState &= namedImportSort;
+        seenUnsortedGroup = true;
+      }
+      if (!sortState) {
+        return sortState;
       }
-      return { namedImportComparer: bestComparer[bestTypeOrder], typeOrder: bestTypeOrder, isSorted: bestDiff[bestTypeOrder] === 0 };
     }
-  return { namedImportComparer: bestComparer.last, typeOrder: "last", isSorted: bestDiff.last === 0 };
-}
-function measureSortedness(arr, comparer) {
-  let i = 0;
-  for (let j = 0; j < arr.length - 1; j++) {
-    if (comparer(arr[j], arr[j + 1]) > 0) {
-      i++;
+    if (sortState !== 3 /* Both */) {
+      return sortState;
     }
   }
-  return i;
+  return seenUnsortedGroup ? 0 /* None */ : sortState;
 }
-function detectCaseSensitivityBySort(originalGroups, comparersToTest) {
-  let bestComparer;
-  let bestDiff = Infinity;
-  for (const curComparer of comparersToTest) {
-    let diffOfCurrentComparer = 0;
-    for (const listToSort of originalGroups) {
-      if (listToSort.length <= 1)
-        continue;
-      const diff = measureSortedness(listToSort, curComparer);
-      diffOfCurrentComparer += diff;
+function detectImportDeclarationSorting(imports, preferences) {
+  const collateCaseSensitive = getOrganizeImportsComparer(
+    preferences,
+    /*ignoreCase*/
+    false
+  );
+  const collateCaseInsensitive = getOrganizeImportsComparer(
+    preferences,
+    /*ignoreCase*/
+    true
+  );
+  return detectSortCaseSensitivity(
+    imports,
+    (s) => getExternalModuleName2(getModuleSpecifierExpression(s)) || "",
+    collateCaseSensitive,
+    collateCaseInsensitive
+  );
+}
+var ImportSpecifierSortingCache = class {
+  has([specifiers, preferences]) {
+    if (this._lastPreferences !== preferences || !this._cache)
+      return false;
+    return this._cache.has(specifiers);
+  }
+  get([specifiers, preferences]) {
+    if (this._lastPreferences !== preferences || !this._cache)
+      return void 0;
+    return this._cache.get(specifiers);
+  }
+  set([specifiers, preferences], value) {
+    if (this._lastPreferences !== preferences) {
+      this._lastPreferences = preferences;
+      this._cache = void 0;
     }
-    if (diffOfCurrentComparer < bestDiff) {
-      bestDiff = diffOfCurrentComparer;
-      bestComparer = curComparer;
+    this._cache ?? (this._cache = /* @__PURE__ */ new WeakMap());
+    this._cache.set(specifiers, value);
+  }
+};
+var detectImportSpecifierSorting = memoizeCached((specifiers, preferences) => {
+  switch (preferences.organizeImportsTypeOrder) {
+    case "first":
+      if (!arrayIsSorted(specifiers, (s1, s2) => compareBooleans(s2.isTypeOnly, s1.isTypeOnly)))
+        return 0 /* None */;
+      break;
+    case "inline":
+      if (!arrayIsSorted(specifiers, (s1, s2) => {
+        const comparer = getStringComparer(
+          /*ignoreCase*/
+          true
+        );
+        return comparer(s1.name.text, s2.name.text);
+      })) {
+        return 0 /* None */;
+      }
+      break;
+    default:
+      if (!arrayIsSorted(specifiers, (s1, s2) => compareBooleans(s1.isTypeOnly, s2.isTypeOnly)))
+        return 0 /* None */;
+      break;
+  }
+  const collateCaseSensitive = getOrganizeImportsComparer(
+    preferences,
+    /*ignoreCase*/
+    false
+  );
+  const collateCaseInsensitive = getOrganizeImportsComparer(
+    preferences,
+    /*ignoreCase*/
+    true
+  );
+  if (preferences.organizeImportsTypeOrder !== "inline") {
+    const { type: regularImports, regular: typeImports } = groupBy(specifiers, (s) => s.isTypeOnly ? "type" : "regular");
+    const regularCaseSensitivity = (regularImports == null ? void 0 : regularImports.length) ? detectSortCaseSensitivity(regularImports, (specifier) => specifier.name.text, collateCaseSensitive, collateCaseInsensitive) : void 0;
+    const typeCaseSensitivity = (typeImports == null ? void 0 : typeImports.length) ? detectSortCaseSensitivity(typeImports, (specifier) => specifier.name.text ?? "", collateCaseSensitive, collateCaseInsensitive) : void 0;
+    if (regularCaseSensitivity === void 0) {
+      return typeCaseSensitivity ?? 0 /* None */;
+    }
+    if (typeCaseSensitivity === void 0) {
+      return regularCaseSensitivity;
+    }
+    if (regularCaseSensitivity === 0 /* None */ || typeCaseSensitivity === 0 /* None */) {
+      return 0 /* None */;
     }
+    return typeCaseSensitivity & regularCaseSensitivity;
   }
-  return {
-    comparer: bestComparer ?? comparersToTest[0],
-    isSorted: bestDiff === 0
-  };
+  return detectSortCaseSensitivity(specifiers, (specifier) => specifier.name.text, collateCaseSensitive, collateCaseInsensitive);
+}, new ImportSpecifierSortingCache());
+function getImportDeclarationInsertionIndex(sortedImports, newImport, comparer) {
+  const index = binarySearch(sortedImports, newImport, identity, (a, b) => compareImportsOrRequireStatements(a, b, comparer));
+  return index < 0 ? ~index : index;
+}
+function getImportSpecifierInsertionIndex(sortedImports, newImport, comparer, preferences) {
+  const index = binarySearch(sortedImports, newImport, identity, (s1, s2) => compareImportOrExportSpecifiers(s1, s2, comparer, preferences));
+  return index < 0 ? ~index : index;
+}
+function compareImportsOrRequireStatements(s1, s2, comparer) {
+  return compareModuleSpecifiersWorker(getModuleSpecifierExpression(s1), getModuleSpecifierExpression(s2), comparer) || compareImportKind(s1, s2);
 }
 function compareImportKind(s1, s2) {
   return compareValues(getImportKindOrder(s1), getImportKindOrder(s2));
@@ -167083,6 +167258,19 @@ function getImportKindOrder(s1) {
       return 6;
   }
 }
+function getNewImportSpecifiers(namedImports) {
+  return flatMap(namedImports, (namedImport) => map(tryGetNamedBindingElements(namedImport), (importSpecifier) => importSpecifier.name && importSpecifier.propertyName && importSpecifier.name.escapedText === importSpecifier.propertyName.escapedText ? factory.updateImportSpecifier(
+    importSpecifier,
+    importSpecifier.isTypeOnly,
+    /*propertyName*/
+    void 0,
+    importSpecifier.name
+  ) : importSpecifier));
+}
+function tryGetNamedBindingElements(namedImport) {
+  var _a;
+  return ((_a = namedImport.importClause) == null ? void 0 : _a.namedBindings) && isNamedImports(namedImport.importClause.namedBindings) ? namedImport.importClause.namedBindings.elements : void 0;
+}
 function getOrganizeImportsOrdinalStringComparer(ignoreCase) {
   return ignoreCase ? compareStringsCaseInsensitiveEslintCompatible : compareStringsCaseSensitive;
 }
@@ -167110,61 +167298,40 @@ function getOrganizeImportsLocale(preferences) {
   const resolvedLocale = supportedLocales.length ? supportedLocales[0] : "en";
   return resolvedLocale;
 }
-function getOrganizeImportsStringComparer(preferences, ignoreCase) {
+function getOrganizeImportsComparer(preferences, ignoreCase) {
   const collation = preferences.organizeImportsCollation ?? "ordinal";
   return collation === "unicode" ? getOrganizeImportsUnicodeStringComparer(ignoreCase, preferences) : getOrganizeImportsOrdinalStringComparer(ignoreCase);
 }
-function getOrganizeImportsStringComparerWithDetection(originalImportDecls, preferences) {
-  return detectModuleSpecifierCaseBySort([originalImportDecls], getDetectionLists(preferences).comparersToTest);
+function getOrganizeImportsComparerWithDetection(preferences, detectIgnoreCase) {
+  const ignoreCase = typeof preferences.organizeImportsIgnoreCase === "boolean" ? preferences.organizeImportsIgnoreCase : (detectIgnoreCase == null ? void 0 : detectIgnoreCase()) ?? false;
+  return getOrganizeImportsComparer(preferences, ignoreCase);
 }
-function getNamedImportSpecifierComparer(preferences, comparer) {
-  const stringComparer = comparer ?? getOrganizeImportsOrdinalStringComparer(!!preferences.organizeImportsIgnoreCase);
-  return (s1, s2) => compareImportOrExportSpecifiers(s1, s2, stringComparer, preferences);
-}
-function getNamedImportSpecifierComparerWithDetection(importDecl, preferences, sourceFile) {
-  const { comparersToTest, typeOrdersToTest } = getDetectionLists(preferences);
-  const detectFromDecl = detectNamedImportOrganizationBySort([importDecl], comparersToTest, typeOrdersToTest);
-  let specifierComparer = getNamedImportSpecifierComparer(preferences, comparersToTest[0]);
-  let isSorted;
-  if (typeof preferences.organizeImportsIgnoreCase !== "boolean" || !preferences.organizeImportsTypeOrder) {
-    if (detectFromDecl) {
-      const { namedImportComparer, typeOrder, isSorted: isDetectedSorted } = detectFromDecl;
-      isSorted = isDetectedSorted;
-      specifierComparer = getNamedImportSpecifierComparer({ organizeImportsTypeOrder: typeOrder }, namedImportComparer);
-    } else if (sourceFile) {
-      const detectFromFile = detectNamedImportOrganizationBySort(sourceFile.statements.filter(isImportDeclaration), comparersToTest, typeOrdersToTest);
-      if (detectFromFile) {
-        const { namedImportComparer, typeOrder, isSorted: isDetectedSorted } = detectFromFile;
-        isSorted = isDetectedSorted;
-        specifierComparer = getNamedImportSpecifierComparer({ organizeImportsTypeOrder: typeOrder }, namedImportComparer);
+function getTopLevelExportGroups(sourceFile) {
+  const topLevelExportGroups = [];
+  const statements = sourceFile.statements;
+  const len = length(statements);
+  let i = 0;
+  let groupIndex = 0;
+  while (i < len) {
+    if (isExportDeclaration(statements[i])) {
+      if (topLevelExportGroups[groupIndex] === void 0) {
+        topLevelExportGroups[groupIndex] = [];
+      }
+      const exportDecl = statements[i];
+      if (exportDecl.moduleSpecifier) {
+        topLevelExportGroups[groupIndex].push(exportDecl);
+        i++;
+      } else {
+        while (i < len && isExportDeclaration(statements[i])) {
+          topLevelExportGroups[groupIndex].push(statements[i++]);
+        }
+        groupIndex++;
       }
+    } else {
+      i++;
     }
   }
-  return { specifierComparer, isSorted };
-}
-function getImportDeclarationInsertionIndex(sortedImports, newImport, comparer) {
-  const index = binarySearch(sortedImports, newImport, identity, (a, b) => compareImportsOrRequireStatements(a, b, comparer));
-  return index < 0 ? ~index : index;
-}
-function getImportSpecifierInsertionIndex(sortedImports, newImport, comparer) {
-  const index = binarySearch(sortedImports, newImport, identity, comparer);
-  return index < 0 ? ~index : index;
-}
-function compareImportsOrRequireStatements(s1, s2, comparer) {
-  return compareModuleSpecifiersWorker(getModuleSpecifierExpression(s1), getModuleSpecifierExpression(s2), comparer) || compareImportKind(s1, s2);
-}
-function testCoalesceImports(importGroup, ignoreCase, sourceFile, preferences) {
-  const comparer = getOrganizeImportsOrdinalStringComparer(ignoreCase);
-  const specifierComparer = getNamedImportSpecifierComparer({ organizeImportsTypeOrder: preferences == null ? void 0 : preferences.organizeImportsTypeOrder }, comparer);
-  return coalesceImportsWorker(importGroup, comparer, specifierComparer, sourceFile);
-}
-function testCoalesceExports(exportGroup, ignoreCase, preferences) {
-  const comparer = (s1, s2) => compareImportOrExportSpecifiers(s1, s2, getOrganizeImportsOrdinalStringComparer(ignoreCase), { organizeImportsTypeOrder: (preferences == null ? void 0 : preferences.organizeImportsTypeOrder) ?? "last" });
-  return coalesceExportsWorker(exportGroup, comparer);
-}
-function compareModuleSpecifiers2(m1, m2, ignoreCase) {
-  const comparer = getOrganizeImportsOrdinalStringComparer(!!ignoreCase);
-  return compareModuleSpecifiersWorker(m1, m2, comparer);
+  return flatMap(topLevelExportGroups, (exportGroupDecls) => groupByNewlineContiguous(sourceFile, exportGroupDecls));
 }
 
 // src/services/_namespaces/ts.OutliningElementsCollector.ts
@@ -173262,6 +173429,7 @@ __export(ts_exports2, {
   JsxEmit: () => JsxEmit,
   JsxFlags: () => JsxFlags,
   JsxReferenceKind: () => JsxReferenceKind,
+  LanguageFeatureMinimumTarget: () => LanguageFeatureMinimumTarget,
   LanguageServiceMode: () => LanguageServiceMode,
   LanguageVariant: () => LanguageVariant,
   LexicalEnvironmentFlags: () => LexicalEnvironmentFlags,
@@ -173317,6 +173485,7 @@ __export(ts_exports2, {
   SignatureKind: () => SignatureKind,
   SmartSelectionRange: () => ts_SmartSelectionRange_exports,
   SnippetKind: () => SnippetKind,
+  SortKind: () => SortKind,
   StructureIsReused: () => StructureIsReused,
   SymbolAccessibility: () => SymbolAccessibility,
   SymbolDisplay: () => ts_SymbolDisplay_exports,
@@ -173651,6 +173820,7 @@ __export(ts_exports2, {
   defaultIncludeSpec: () => defaultIncludeSpec,
   defaultInitCompilerOptions: () => defaultInitCompilerOptions,
   defaultMaximumTruncationLength: () => defaultMaximumTruncationLength,
+  detectSortCaseSensitivity: () => detectSortCaseSensitivity,
   diagnosticCategoryName: () => diagnosticCategoryName,
   diagnosticToString: () => diagnosticToString,
   directoryProbablyExists: () => directoryProbablyExists,
@@ -185916,10 +186086,10 @@ ${e.message}`;
     }
     return simplifiedResult ? codeActions.map((codeAction) => this.mapCodeFixAction(codeAction)) : codeActions;
   }
-  getCombinedCodeFix({ scope, fixId: fixId52 }, simplifiedResult) {
+  getCombinedCodeFix({ scope, fixId: fixId53 }, simplifiedResult) {
     Debug.assert(scope.type === "file");
     const { file, project } = this.getFileAndProject(scope.args);
-    const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId52, this.getFormatOptions(file), this.getPreferences(file));
+    const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId53, this.getFormatOptions(file), this.getPreferences(file));
     if (simplifiedResult) {
       return { changes: this.mapTextChangesToCodeEdits(res.changes), commands: res.commands };
     } else {
@@ -185958,8 +186128,8 @@ ${e.message}`;
   mapCodeAction({ description: description3, changes, commands }) {
     return { description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands };
   }
-  mapCodeFixAction({ fixName: fixName8, description: description3, changes, commands, fixId: fixId52, fixAllDescription }) {
-    return { fixName: fixName8, description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId52, fixAllDescription };
+  mapCodeFixAction({ fixName: fixName8, description: description3, changes, commands, fixId: fixId53, fixAllDescription }) {
+    return { fixName: fixName8, description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId53, fixAllDescription };
   }
   mapTextChangesToCodeEdits(textChanges2) {
     return textChanges2.map((change) => this.mapTextChangeToCodeEdit(change));
@@ -188035,6 +188205,7 @@ start(initializeNodeSystem(), require("os").platform());
   JsxEmit,
   JsxFlags,
   JsxReferenceKind,
+  LanguageFeatureMinimumTarget,
   LanguageServiceMode,
   LanguageVariant,
   LexicalEnvironmentFlags,
@@ -188090,6 +188261,7 @@ start(initializeNodeSystem(), require("os").platform());
   SignatureKind,
   SmartSelectionRange,
   SnippetKind,
+  SortKind,
   StructureIsReused,
   SymbolAccessibility,
   SymbolDisplay,
@@ -188424,6 +188596,7 @@ start(initializeNodeSystem(), require("os").platform());
   defaultIncludeSpec,
   defaultInitCompilerOptions,
   defaultMaximumTruncationLength,
+  detectSortCaseSensitivity,
   diagnosticCategoryName,
   diagnosticToString,
   directoryProbablyExists,