typescript 5.4.0-dev.20240108 → 5.4.0-dev.20240110

package/lib/tsserver.js

@@ -1655,7 +1655,6 @@ __export(server_exports, {
   isPackedArrayLiteral: () => isPackedArrayLiteral,
   isParameter: () => isParameter,
   isParameterDeclaration: () => isParameterDeclaration,
-  isParameterOrCatchClauseVariable: () => isParameterOrCatchClauseVariable,
   isParameterPropertyDeclaration: () => isParameterPropertyDeclaration,
   isParameterPropertyModifier: () => isParameterPropertyModifier,
   isParenthesizedExpression: () => isParenthesizedExpression,
@@ -2341,7 +2340,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20240108`;
+var version = `${versionMajorMinor}.0-dev.20240110`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -16547,7 +16546,7 @@ function isPartOfTypeNode(node) {
     case 116 /* VoidKeyword */:
       return node.parent.kind !== 222 /* VoidExpression */;
     case 233 /* ExpressionWithTypeArguments */:
-      return isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+      return isPartOfTypeExpressionWithTypeArguments(node);
     case 168 /* TypeParameter */:
       return node.parent.kind === 200 /* MappedType */ || node.parent.kind === 195 /* InferType */;
     case 80 /* Identifier */:
@@ -16572,7 +16571,7 @@ function isPartOfTypeNode(node) {
       }
       switch (parent2.kind) {
         case 233 /* ExpressionWithTypeArguments */:
-          return isHeritageClause(parent2.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent2);
+          return isPartOfTypeExpressionWithTypeArguments(parent2);
         case 168 /* TypeParameter */:
           return node === parent2.constraint;
         case 352 /* JSDocTemplateTag */:
@@ -16606,6 +16605,9 @@ function isPartOfTypeNode(node) {
   }
   return false;
 }
+function isPartOfTypeExpressionWithTypeArguments(node) {
+  return isJSDocImplementsTag(node.parent) || isJSDocAugmentsTag(node.parent) || isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+}
 function isChildOfNodeWithKind(node, kind) {
   while (node) {
     if (node.kind === kind) {
@@ -20241,7 +20243,7 @@ function Symbol4(flags, name) {
   this.exportSymbol = void 0;
   this.constEnumOnlyModule = void 0;
   this.isReferenced = void 0;
-  this.isAssigned = void 0;
+  this.lastAssignmentPos = void 0;
   this.links = void 0;
 }
 function Type3(checker, flags) {
@@ -21716,10 +21718,6 @@ function isInfinityOrNaNString(name) {
 function isCatchClauseVariableDeclaration(node) {
   return node.kind === 260 /* VariableDeclaration */ && node.parent.kind === 299 /* CatchClause */;
 }
-function isParameterOrCatchClauseVariable(symbol) {
-  const declaration = symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration);
-  return !!declaration && (isParameter(declaration) || isCatchClauseVariableDeclaration(declaration));
-}
 function isFunctionExpressionOrArrowFunction(node) {
   return node.kind === 218 /* FunctionExpression */ || node.kind === 219 /* ArrowFunction */;
 }
@@ -49024,6 +49022,14 @@ function createTypeChecker(host) {
     emptyArray,
     emptyArray
   );
+  var resolvingApparentMappedType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    emptyArray
+  );
   var markerSuperType = createTypeParameter();
   var markerSubType = createTypeParameter();
   markerSubType.constraint = markerSuperType;
@@ -52073,29 +52079,7 @@ function createTypeChecker(host) {
   function getContainersOfSymbol(symbol, enclosingDeclaration, meaning) {
     const container = getParentOfSymbol(symbol);
     if (container && !(symbol.flags & 262144 /* TypeParameter */)) {
-      const additionalContainers = mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
-      const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
-      const objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container, meaning);
-      if (enclosingDeclaration && container.flags & getQualifiedLeftMeaning(meaning) && getAccessibleSymbolChain(
-        container,
-        enclosingDeclaration,
-        1920 /* Namespace */,
-        /*useOnlyExternalAliasing*/
-        false
-      )) {
-        return append(concatenate(concatenate([container], additionalContainers), reexportContainers), objectLiteralContainer);
-      }
-      const firstVariableMatch = !(container.flags & getQualifiedLeftMeaning(meaning)) && container.flags & 788968 /* Type */ && getDeclaredTypeOfSymbol(container).flags & 524288 /* Object */ && meaning === 111551 /* Value */ ? forEachSymbolTableInScope(enclosingDeclaration, (t) => {
-        return forEachEntry(t, (s) => {
-          if (s.flags & getQualifiedLeftMeaning(meaning) && getTypeOfSymbol(s) === getDeclaredTypeOfSymbol(container)) {
-            return s;
-          }
-        });
-      }) : void 0;
-      let res = firstVariableMatch ? [firstVariableMatch, ...additionalContainers, container] : [...additionalContainers, container];
-      res = append(res, objectLiteralContainer);
-      res = addRange(res, reexportContainers);
-      return res;
+      return getWithAlternativeContainers(container);
     }
     const candidates = mapDefined(symbol.declarations, (d) => {
       if (!isAmbientModule(d) && d.parent) {
@@ -52117,7 +52101,40 @@ function createTypeChecker(host) {
     if (!length(candidates)) {
       return void 0;
     }
-    return mapDefined(candidates, (candidate) => getAliasForSymbolInContainer(candidate, symbol) ? candidate : void 0);
+    const containers = mapDefined(candidates, (candidate) => getAliasForSymbolInContainer(candidate, symbol) ? candidate : void 0);
+    let bestContainers = [];
+    let alternativeContainers = [];
+    for (const container2 of containers) {
+      const [bestMatch, ...rest] = getWithAlternativeContainers(container2);
+      bestContainers = append(bestContainers, bestMatch);
+      alternativeContainers = addRange(alternativeContainers, rest);
+    }
+    return concatenate(bestContainers, alternativeContainers);
+    function getWithAlternativeContainers(container2) {
+      const additionalContainers = mapDefined(container2.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
+      const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
+      const objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container2, meaning);
+      if (enclosingDeclaration && container2.flags & getQualifiedLeftMeaning(meaning) && getAccessibleSymbolChain(
+        container2,
+        enclosingDeclaration,
+        1920 /* Namespace */,
+        /*useOnlyExternalAliasing*/
+        false
+      )) {
+        return append(concatenate(concatenate([container2], additionalContainers), reexportContainers), objectLiteralContainer);
+      }
+      const firstVariableMatch = !(container2.flags & getQualifiedLeftMeaning(meaning)) && container2.flags & 788968 /* Type */ && getDeclaredTypeOfSymbol(container2).flags & 524288 /* Object */ && meaning === 111551 /* Value */ ? forEachSymbolTableInScope(enclosingDeclaration, (t) => {
+        return forEachEntry(t, (s) => {
+          if (s.flags & getQualifiedLeftMeaning(meaning) && getTypeOfSymbol(s) === getDeclaredTypeOfSymbol(container2)) {
+            return s;
+          }
+        });
+      }) : void 0;
+      let res = firstVariableMatch ? [firstVariableMatch, ...additionalContainers, container2] : [...additionalContainers, container2];
+      res = append(res, objectLiteralContainer);
+      res = addRange(res, reexportContainers);
+      return res;
+    }
     function fileSymbolIfFileSymbolExportEqualsContainer(d) {
       return container && getFileSymbolIfFileSymbolExportEqualsContainer(d, container);
     }
@@ -52155,6 +52172,13 @@ function createTypeChecker(host) {
     });
   }
   function getSymbolIfSameReference(s1, s2) {
+    var _a, _b;
+    if (s1.flags & 524288 /* TypeAlias */ && ((_a = s2.declarations) == null ? void 0 : _a.find(isTypeAlias))) {
+      s2 = getDeclaredTypeOfTypeAlias(s2).aliasSymbol || s2;
+    }
+    if (s2.flags & 524288 /* TypeAlias */ && ((_b = s1.declarations) == null ? void 0 : _b.find(isTypeAlias))) {
+      s1 = getDeclaredTypeOfTypeAlias(s1).aliasSymbol || s1;
+    }
     if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
       return s1;
     }
@@ -59893,14 +59917,30 @@ function createTypeChecker(host) {
     return !!(typeParameter.symbol && forEach(typeParameter.symbol.declarations, (decl) => isTypeParameterDeclaration(decl) && decl.default));
   }
   function getApparentTypeOfMappedType(type) {
-    return type.resolvedApparentType || (type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type));
+    if (type.resolvedApparentType) {
+      if (type.resolvedApparentType === resolvingApparentMappedType) {
+        return type.resolvedApparentType = type;
+      }
+      return type.resolvedApparentType;
+    }
+    type.resolvedApparentType = resolvingApparentMappedType;
+    return type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type);
   }
   function getResolvedApparentTypeOfMappedType(type) {
-    const typeVariable = getHomomorphicTypeVariable(type);
-    if (typeVariable && !type.declaration.nameType) {
-      const constraint = getConstraintOfTypeParameter(typeVariable);
+    const mappedType = type.target || type;
+    const typeVariable = getHomomorphicTypeVariable(mappedType);
+    if (typeVariable && !mappedType.declaration.nameType) {
+      let constraint;
+      if (!type.target) {
+        constraint = getConstraintOfTypeParameter(typeVariable);
+      } else {
+        const modifiersConstraint = getConstraintOfType(getModifiersTypeFromMappedType(type));
+        if (modifiersConstraint) {
+          constraint = getApparentType(modifiersConstraint);
+        }
+      }
       if (constraint && everyType(constraint, isArrayOrTupleType)) {
-        return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper));
+        return instantiateType(mappedType, prependTypeMapping(typeVariable, constraint, mappedType.mapper));
       }
     }
     return type;
@@ -59991,6 +60031,7 @@ function createTypeChecker(host) {
         clone2.parent = (_c = (_b = singleProp.valueDeclaration) == null ? void 0 : _b.symbol) == null ? void 0 : _c.parent;
         clone2.links.containingType = containingType;
         clone2.links.mapper = links == null ? void 0 : links.mapper;
+        clone2.links.writeType = getWriteTypeOfSymbol(singleProp);
         return clone2;
       } else {
         return singleProp;
@@ -66616,6 +66657,18 @@ function createTypeChecker(host) {
       }
       return result2;
     }
+    function getApparentMappedTypeKeys(nameType, targetType) {
+      const modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType));
+      const mappedKeys = [];
+      forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
+        modifiersType,
+        8576 /* StringOrNumberLiteralOrUnique */,
+        /*stringsOnly*/
+        false,
+        (t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
+      );
+      return getUnionType(mappedKeys);
+    }
     function structuredTypeRelatedToWorker(source2, target2, reportErrors2, intersectionState, saveErrorInfo) {
       let result2;
       let originalErrorInfo;
@@ -66798,16 +66851,8 @@ function createTypeChecker(host) {
             const constraintType = getConstraintTypeFromMappedType(targetType);
             let targetKeys;
             if (nameType && isMappedTypeWithKeyofConstraintDeclaration(targetType)) {
-              const modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType));
-              const mappedKeys = [];
-              forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
-                modifiersType,
-                8576 /* StringOrNumberLiteralOrUnique */,
-                /*stringsOnly*/
-                false,
-                (t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
-              );
-              targetKeys = getUnionType([...mappedKeys, nameType]);
+              const mappedKeys = getApparentMappedTypeKeys(nameType, targetType);
+              targetKeys = getUnionType([mappedKeys, nameType]);
             } else {
               targetKeys = nameType || constraintType;
             }
@@ -66978,9 +67023,18 @@ function createTypeChecker(host) {
           }
         }
       } else if (sourceFlags & 4194304 /* Index */) {
-        if (result2 = isRelatedTo(keyofConstraintType, target2, 1 /* Source */, reportErrors2)) {
+        const isDeferredMappedIndex = shouldDeferIndexType(source2.type, source2.indexFlags) && getObjectFlags(source2.type) & 32 /* Mapped */;
+        if (result2 = isRelatedTo(keyofConstraintType, target2, 1 /* Source */, reportErrors2 && !isDeferredMappedIndex)) {
           return result2;
         }
+        if (isDeferredMappedIndex) {
+          const mappedType = source2.type;
+          const nameType = getNameTypeFromMappedType(mappedType);
+          const sourceMappedKeys = nameType && isMappedTypeWithKeyofConstraintDeclaration(mappedType) ? getApparentMappedTypeKeys(nameType, mappedType) : nameType || getConstraintTypeFromMappedType(mappedType);
+          if (result2 = isRelatedTo(sourceMappedKeys, target2, 1 /* Source */, reportErrors2)) {
+            return result2;
+          }
+        }
       } else if (sourceFlags & 134217728 /* TemplateLiteral */ && !(targetFlags & 524288 /* Object */)) {
         if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
           const constraint = getBaseConstraintOfType(source2);
@@ -70917,7 +70971,7 @@ function createTypeChecker(host) {
       case 80 /* Identifier */:
         if (!isThisInTypeQuery(node)) {
           const symbol = getResolvedSymbol(node);
-          return isConstantVariable(symbol) || isParameterOrCatchClauseVariable(symbol) && !isSymbolAssigned(symbol);
+          return isConstantVariable(symbol) || isParameterOrMutableLocalVariable(symbol) && !isSymbolAssigned(symbol);
         }
         break;
       case 211 /* PropertyAccessExpression */:
@@ -70926,7 +70980,7 @@ function createTypeChecker(host) {
       case 206 /* ObjectBindingPattern */:
       case 207 /* ArrayBindingPattern */:
         const rootDeclaration = getRootDeclaration(node.parent);
-        return isVariableDeclaration(rootDeclaration) && isVarConstLike(rootDeclaration);
+        return isParameter(rootDeclaration) || isCatchClauseVariableDeclaration(rootDeclaration) ? !isSomeSymbolAssigned(rootDeclaration) : isVariableDeclaration(rootDeclaration) && isVarConstLike(rootDeclaration);
     }
     return false;
   }
@@ -72007,10 +72061,17 @@ function createTypeChecker(host) {
     return findAncestor(node.parent, (node2) => isFunctionLike(node2) && !getImmediatelyInvokedFunctionExpression(node2) || node2.kind === 268 /* ModuleBlock */ || node2.kind === 312 /* SourceFile */ || node2.kind === 172 /* PropertyDeclaration */);
   }
   function isSymbolAssigned(symbol) {
-    if (!symbol.valueDeclaration) {
+    return !isPastLastAssignment(
+      symbol,
+      /*location*/
+      void 0
+    );
+  }
+  function isPastLastAssignment(symbol, location) {
+    const parent2 = findAncestor(symbol.valueDeclaration, isFunctionOrSourceFile);
+    if (!parent2) {
       return false;
     }
-    const parent2 = getRootDeclaration(symbol.valueDeclaration).parent;
     const links = getNodeLinks(parent2);
     if (!(links.flags & 131072 /* AssignmentsMarked */)) {
       links.flags |= 131072 /* AssignmentsMarked */;
@@ -72018,7 +72079,7 @@ function createTypeChecker(host) {
         markNodeAssignments(parent2);
       }
     }
-    return symbol.isAssigned || false;
+    return !symbol.lastAssignmentPos || location && symbol.lastAssignmentPos < location.pos;
   }
   function isSomeSymbolAssigned(rootDeclaration) {
     Debug.assert(isVariableDeclaration(rootDeclaration) || isParameter(rootDeclaration));
@@ -72031,23 +72092,81 @@ function createTypeChecker(host) {
     return some(node.elements, (e) => e.kind !== 232 /* OmittedExpression */ && isSomeSymbolAssignedWorker(e.name));
   }
   function hasParentWithAssignmentsMarked(node) {
-    return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 131072 /* AssignmentsMarked */));
+    return !!findAncestor(node.parent, (node2) => isFunctionOrSourceFile(node2) && !!(getNodeLinks(node2).flags & 131072 /* AssignmentsMarked */));
+  }
+  function isFunctionOrSourceFile(node) {
+    return isFunctionLikeDeclaration(node) || isSourceFile(node);
   }
   function markNodeAssignments(node) {
-    if (node.kind === 80 /* Identifier */) {
-      if (isAssignmentTarget(node)) {
-        const symbol = getResolvedSymbol(node);
-        if (isParameterOrCatchClauseVariable(symbol)) {
-          symbol.isAssigned = true;
+    switch (node.kind) {
+      case 80 /* Identifier */:
+        if (isAssignmentTarget(node)) {
+          const symbol = getResolvedSymbol(node);
+          if (isParameterOrMutableLocalVariable(symbol) && symbol.lastAssignmentPos !== Number.MAX_VALUE) {
+            const referencingFunction = findAncestor(node, isFunctionOrSourceFile);
+            const declaringFunction = findAncestor(symbol.valueDeclaration, isFunctionOrSourceFile);
+            symbol.lastAssignmentPos = referencingFunction === declaringFunction ? extendAssignmentPosition(node, symbol.valueDeclaration) : Number.MAX_VALUE;
+          }
         }
+        return;
+      case 281 /* ExportSpecifier */:
+        const exportDeclaration = node.parent.parent;
+        if (!node.isTypeOnly && !exportDeclaration.isTypeOnly && !exportDeclaration.moduleSpecifier) {
+          const symbol = resolveEntityName(
+            node.propertyName || node.name,
+            111551 /* Value */,
+            /*ignoreErrors*/
+            true,
+            /*dontResolveAlias*/
+            true
+          );
+          if (symbol && isParameterOrMutableLocalVariable(symbol)) {
+            symbol.lastAssignmentPos = Number.MAX_VALUE;
+          }
+        }
+        return;
+      case 264 /* InterfaceDeclaration */:
+      case 265 /* TypeAliasDeclaration */:
+      case 266 /* EnumDeclaration */:
+        return;
+    }
+    if (isTypeNode(node)) {
+      return;
+    }
+    forEachChild(node, markNodeAssignments);
+  }
+  function extendAssignmentPosition(node, declaration) {
+    let pos = node.pos;
+    while (node && node.pos > declaration.pos) {
+      switch (node.kind) {
+        case 243 /* VariableStatement */:
+        case 244 /* ExpressionStatement */:
+        case 245 /* IfStatement */:
+        case 246 /* DoStatement */:
+        case 247 /* WhileStatement */:
+        case 248 /* ForStatement */:
+        case 249 /* ForInStatement */:
+        case 250 /* ForOfStatement */:
+        case 254 /* WithStatement */:
+        case 255 /* SwitchStatement */:
+        case 258 /* TryStatement */:
+        case 263 /* ClassDeclaration */:
+          pos = node.end;
       }
-    } else {
-      forEachChild(node, markNodeAssignments);
+      node = node.parent;
     }
+    return pos;
   }
   function isConstantVariable(symbol) {
     return symbol.flags & 3 /* Variable */ && (getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* Constant */) !== 0;
   }
+  function isParameterOrMutableLocalVariable(symbol) {
+    const declaration = symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration);
+    return !!declaration && (isParameter(declaration) || isVariableDeclaration(declaration) && (isCatchClause(declaration.parent) || isMutableLocalVariableDeclaration(declaration)));
+  }
+  function isMutableLocalVariableDeclaration(declaration) {
+    return !!(declaration.parent.flags & 1 /* Let */) && !(getCombinedModifierFlags(declaration) & 32 /* Export */ || declaration.parent.parent.kind === 243 /* VariableStatement */ && isGlobalSourceFile(declaration.parent.parent.parent));
+  }
   function parameterInitializerContainsUndefined(declaration) {
     const links = getNodeLinks(declaration);
     if (links.parameterInitializerContainsUndefined === void 0) {
@@ -72296,7 +72415,7 @@ function createTypeChecker(host) {
     const isModuleExports = symbol.flags & 134217728 /* ModuleExports */;
     const typeIsAutomatic = type === autoType || type === autoArrayType;
     const isAutomaticTypeInNonNull = typeIsAutomatic && node.parent.kind === 235 /* NonNullExpression */;
-    while (flowContainer !== declarationContainer && (flowContainer.kind === 218 /* FunctionExpression */ || flowContainer.kind === 219 /* ArrowFunction */ || isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) && (isConstantVariable(localOrExportSymbol) && type !== autoArrayType || isParameter2 && !isSymbolAssigned(localOrExportSymbol))) {
+    while (flowContainer !== declarationContainer && (flowContainer.kind === 218 /* FunctionExpression */ || flowContainer.kind === 219 /* ArrowFunction */ || isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) && (isConstantVariable(localOrExportSymbol) && type !== autoArrayType || isParameterOrMutableLocalVariable(localOrExportSymbol) && isPastLastAssignment(localOrExportSymbol, node))) {
       flowContainer = getControlFlowContainer(flowContainer);
     }
     const assumeInitialized = isParameter2 || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */)) !== 0 || isInTypeQuery(node) || isInAmbientOrTypeNode(node) || node.parent.kind === 281 /* ExportSpecifier */) || node.parent.kind === 235 /* NonNullExpression */ || declaration.kind === 260 /* VariableDeclaration */ && declaration.exclamationToken || declaration.flags & 33554432 /* Ambient */;
@@ -118337,7 +118456,14 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   function willEmitLeadingNewLine(node) {
     if (!currentSourceFile)
       return false;
-    if (some(getLeadingCommentRanges(currentSourceFile.text, node.pos), commentWillEmitNewLine))
+    const leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);
+    if (leadingCommentRanges) {
+      const parseNode = getParseTreeNode(node);
+      if (parseNode && isParenthesizedExpression(parseNode.parent)) {
+        return true;
+      }
+    }
+    if (some(leadingCommentRanges, commentWillEmitNewLine))
       return true;
     if (some(getSyntheticLeadingComments(node), commentWillEmitNewLine))
       return true;
@@ -152295,14 +152421,14 @@ function promoteFromTypeOnly(changes, aliasDeclaration, program, sourceFile, pre
             aliasDeclaration.name
           );
           const comparer = ts_OrganizeImports_exports.getOrganizeImportsComparer(preferences, sortKind === 2 /* CaseInsensitive */);
-          const insertionIndex = ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier, comparer);
-          if (aliasDeclaration.parent.elements.indexOf(aliasDeclaration) !== insertionIndex) {
+          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);
             return aliasDeclaration;
           }
         }
-        changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken());
+        changes.deleteRange(sourceFile, { pos: getTokenPosOfNode(aliasDeclaration.getFirstToken()), end: getTokenPosOfNode(aliasDeclaration.propertyName ?? aliasDeclaration.name) });
         return aliasDeclaration;
       } else {
         Debug.assert(aliasDeclaration.parent.parent.isTypeOnly);
@@ -152398,7 +152524,7 @@ function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImpor
     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 = promoteFromTypeOnly2 && !spec.isTypeOnly ? 0 : ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(existingSpecifiers, spec, comparer);
+        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) {
@@ -167263,14 +167389,14 @@ function organizeImports(sourceFile, formatContext, host, program, preferences,
     if (shouldRemove)
       importGroup = removeUnusedImports(importGroup, sourceFile, program);
     if (shouldCombine)
-      importGroup = coalesceImportsWorker(importGroup, comparer, sourceFile);
+      importGroup = coalesceImportsWorker(importGroup, comparer, sourceFile, preferences);
     if (shouldSort)
       importGroup = stableSort(importGroup, (s1, s2) => compareImportsOrRequireStatements(s1, s2, comparer));
     return importGroup;
   };
   topLevelImportGroupDecls.forEach((importGroupDecl) => organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier));
   if (mode !== "RemoveUnused" /* RemoveUnused */) {
-    getTopLevelExportGroups(sourceFile).forEach((exportGroupDecl) => organizeImportsWorker(exportGroupDecl, (group2) => coalesceExportsWorker(group2, comparer)));
+    getTopLevelExportGroups(sourceFile).forEach((exportGroupDecl) => organizeImportsWorker(exportGroupDecl, (group2) => coalesceExportsWorker(group2, comparer, preferences)));
   }
   for (const ambientModule of sourceFile.statements.filter(isAmbientModule)) {
     if (!ambientModule.body)
@@ -167279,7 +167405,7 @@ function organizeImports(sourceFile, formatContext, host, program, preferences,
     ambientModuleImportGroupDecls.forEach((importGroupDecl) => organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier));
     if (mode !== "RemoveUnused" /* RemoveUnused */) {
       const ambientModuleExportDecls = ambientModule.body.statements.filter(isExportDeclaration);
-      organizeImportsWorker(ambientModuleExportDecls, (group2) => coalesceExportsWorker(group2, comparer));
+      organizeImportsWorker(ambientModuleExportDecls, (group2) => coalesceExportsWorker(group2, comparer, preferences));
     }
   }
   return changeTracker.getChanges();
@@ -167411,11 +167537,11 @@ function hasModuleDeclarationMatchingSpecifier(sourceFile, moduleSpecifier) {
 function getExternalModuleName2(specifier) {
   return specifier !== void 0 && isStringLiteralLike(specifier) ? specifier.text : void 0;
 }
-function coalesceImports(importGroup, ignoreCase, sourceFile) {
+function coalesceImports(importGroup, ignoreCase, sourceFile, preferences) {
   const comparer = getOrganizeImportsOrdinalStringComparer(ignoreCase);
-  return coalesceImportsWorker(importGroup, comparer, sourceFile);
+  return coalesceImportsWorker(importGroup, comparer, sourceFile, preferences);
 }
-function coalesceImportsWorker(importGroup, comparer, sourceFile) {
+function coalesceImportsWorker(importGroup, comparer, sourceFile, preferences) {
   if (importGroup.length === 0) {
     return importGroup;
   }
@@ -167469,7 +167595,7 @@ function coalesceImportsWorker(importGroup, comparer, sourceFile) {
     }
     newImportSpecifiers.push(...getNewImportSpecifiers(namedImports));
     const sortedImportSpecifiers = factory.createNodeArray(
-      sortSpecifiers(newImportSpecifiers, comparer),
+      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);
@@ -167529,11 +167655,11 @@ function getCategorizedImports(importGroup) {
     regularImports
   };
 }
-function coalesceExports(exportGroup, ignoreCase) {
+function coalesceExports(exportGroup, ignoreCase, preferences) {
   const comparer = getOrganizeImportsOrdinalStringComparer(ignoreCase);
-  return coalesceExportsWorker(exportGroup, comparer);
+  return coalesceExportsWorker(exportGroup, comparer, preferences);
 }
-function coalesceExportsWorker(exportGroup, comparer) {
+function coalesceExportsWorker(exportGroup, comparer, preferences) {
   if (exportGroup.length === 0) {
     return exportGroup;
   }
@@ -167548,7 +167674,7 @@ function coalesceExportsWorker(exportGroup, comparer) {
     }
     const newExportSpecifiers = [];
     newExportSpecifiers.push(...flatMap(exportGroup2, (i) => i.exportClause && isNamedExports(i.exportClause) ? i.exportClause.elements : emptyArray));
-    const sortedExportSpecifiers = sortSpecifiers(newExportSpecifiers, comparer);
+    const sortedExportSpecifiers = sortSpecifiers(newExportSpecifiers, comparer, preferences);
     const exportDecl = exportGroup2[0];
     coalescedExports.push(
       factory.updateExportDeclaration(
@@ -167592,11 +167718,18 @@ function updateImportDeclarationAndClause(importDeclaration, name, namedBindings
     importDeclaration.attributes
   );
 }
-function sortSpecifiers(specifiers, comparer) {
-  return stableSort(specifiers, (s1, s2) => compareImportOrExportSpecifiers(s1, s2, comparer));
+function sortSpecifiers(specifiers, comparer, preferences) {
+  return stableSort(specifiers, (s1, s2) => compareImportOrExportSpecifiers(s1, s2, comparer, preferences));
 }
-function compareImportOrExportSpecifiers(s1, s2, comparer) {
-  return compareBooleans(s1.isTypeOnly, s2.isTypeOnly) || comparer(s1.name.text, s2.name.text);
+function compareImportOrExportSpecifiers(s1, s2, comparer, preferences) {
+  switch (preferences == null ? void 0 : preferences.organizeImportsTypeOrder) {
+    case "first":
+      return compareBooleans(s2.isTypeOnly, s1.isTypeOnly) || comparer(s1.name.text, s2.name.text);
+    case "inline":
+      return comparer(s1.name.text, s2.name.text);
+    default:
+      return compareBooleans(s1.isTypeOnly, s2.isTypeOnly) || comparer(s1.name.text, s2.name.text);
+  }
 }
 function compareModuleSpecifiers2(m1, m2, ignoreCase) {
   const comparer = getOrganizeImportsOrdinalStringComparer(!!ignoreCase);
@@ -167718,8 +167851,26 @@ var ImportSpecifierSortingCache = class {
   }
 };
 var detectImportSpecifierSorting = memoizeCached((specifiers, preferences) => {
-  if (!arrayIsSorted(specifiers, (s1, s2) => compareBooleans(s1.isTypeOnly, s2.isTypeOnly))) {
-    return 0 /* None */;
+  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,
@@ -167731,14 +167882,29 @@ var detectImportSpecifierSorting = memoizeCached((specifiers, 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 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) {
-  const index = binarySearch(sortedImports, newImport, identity, (s1, s2) => compareImportOrExportSpecifiers(s1, s2, comparer));
+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) {
@@ -175484,7 +175650,6 @@ __export(ts_exports2, {
   isPackedArrayLiteral: () => isPackedArrayLiteral,
   isParameter: () => isParameter,
   isParameterDeclaration: () => isParameterDeclaration,
-  isParameterOrCatchClauseVariable: () => isParameterOrCatchClauseVariable,
   isParameterPropertyDeclaration: () => isParameterPropertyDeclaration,
   isParameterPropertyModifier: () => isParameterPropertyModifier,
   isParenthesizedExpression: () => isParenthesizedExpression,
@@ -190285,7 +190450,6 @@ start(initializeNodeSystem(), require("os").platform());
   isPackedArrayLiteral,
   isParameter,
   isParameterDeclaration,
-  isParameterOrCatchClauseVariable,
   isParameterPropertyDeclaration,
   isParameterPropertyModifier,
   isParenthesizedExpression,

package/lib/typescript.d.ts

@@ -2933,6 +2933,13 @@ declare namespace ts {
                  * Default: `false`
                  */
                 readonly organizeImportsCaseFirst?: "upper" | "lower" | false;
+                /**
+                 * Indicates where named type-only imports should sort. "inline" sorts named imports without regard to if the import is
+                 * type-only.
+                 *
+                 * Default: `last`
+                 */
+                readonly organizeImportsTypeOrder?: "last" | "first" | "inline";
                 /**
                  * Indicates whether {@link ReferencesResponseItem.lineText} is supported.
                  */
@@ -8784,6 +8791,7 @@ declare namespace ts {
         readonly organizeImportsNumericCollation?: boolean;
         readonly organizeImportsAccentCollation?: boolean;
         readonly organizeImportsCaseFirst?: "upper" | "lower" | false;
+        readonly organizeImportsTypeOrder?: "first" | "last" | "inline";
         readonly excludeLibrarySymbolsInNavTo?: boolean;
     }
     /** Represents a bigint literal value without requiring bigint support */