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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20240108`;
+      version = `${versionMajorMinor}.0-dev.20240110`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -13917,7 +13917,7 @@ ${lanes.join("\n")}
       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 */:
@@ -13942,7 +13942,7 @@ ${lanes.join("\n")}
         }
         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 */:
@@ -13976,6 +13976,9 @@ ${lanes.join("\n")}
     }
     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) {
@@ -17529,7 +17532,7 @@ ${lanes.join("\n")}
     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) {
@@ -18711,10 +18714,6 @@ ${lanes.join("\n")}
   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 */;
   }
@@ -46778,6 +46777,14 @@ ${lanes.join("\n")}
       emptyArray,
       emptyArray
     );
+    var resolvingApparentMappedType = createAnonymousType(
+      /*symbol*/
+      void 0,
+      emptySymbols,
+      emptyArray,
+      emptyArray,
+      emptyArray
+    );
     var markerSuperType = createTypeParameter();
     var markerSubType = createTypeParameter();
     markerSubType.constraint = markerSuperType;
@@ -49827,29 +49834,7 @@ ${lanes.join("\n")}
     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) {
@@ -49871,7 +49856,40 @@ ${lanes.join("\n")}
       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);
       }
@@ -49909,6 +49927,13 @@ ${lanes.join("\n")}
       });
     }
     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;
       }
@@ -57647,14 +57672,30 @@ ${lanes.join("\n")}
       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;
@@ -57745,6 +57786,7 @@ ${lanes.join("\n")}
           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;
@@ -64370,6 +64412,18 @@ ${lanes.join("\n")}
         }
         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;
@@ -64552,16 +64606,8 @@ ${lanes.join("\n")}
               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;
               }
@@ -64732,9 +64778,18 @@ ${lanes.join("\n")}
             }
           }
         } 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);
@@ -68671,7 +68726,7 @@ ${lanes.join("\n")}
         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 */:
@@ -68680,7 +68735,7 @@ ${lanes.join("\n")}
         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;
     }
@@ -69761,10 +69816,17 @@ ${lanes.join("\n")}
       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 */;
@@ -69772,7 +69834,7 @@ ${lanes.join("\n")}
           markNodeAssignments(parent2);
         }
       }
-      return symbol.isAssigned || false;
+      return !symbol.lastAssignmentPos || location && symbol.lastAssignmentPos < location.pos;
     }
     function isSomeSymbolAssigned(rootDeclaration) {
       Debug.assert(isVariableDeclaration(rootDeclaration) || isParameter(rootDeclaration));
@@ -69785,23 +69847,81 @@ ${lanes.join("\n")}
       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) {
@@ -70050,7 +70170,7 @@ ${lanes.join("\n")}
       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 */;
@@ -116367,7 +116487,14 @@ ${lanes.join("\n")}
     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;
@@ -150993,14 +151120,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               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);
@@ -151096,7 +151223,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       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) {
@@ -166612,14 +166739,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       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)
@@ -166628,7 +166755,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       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();
@@ -166760,11 +166887,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   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;
     }
@@ -166818,7 +166945,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       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);
@@ -166878,11 +167005,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       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;
     }
@@ -166897,7 +167024,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       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(
@@ -166941,11 +167068,18 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       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);
@@ -167050,8 +167184,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     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) {
@@ -167180,8 +167314,26 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
       };
       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,
@@ -167193,6 +167345,21 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           /*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());
     }
@@ -187033,7 +187200,6 @@ ${e.message}`;
     isPackedArrayLiteral: () => isPackedArrayLiteral,
     isParameter: () => isParameter,
     isParameterDeclaration: () => isParameterDeclaration,
-    isParameterOrCatchClauseVariable: () => isParameterOrCatchClauseVariable,
     isParameterPropertyDeclaration: () => isParameterPropertyDeclaration,
     isParameterPropertyModifier: () => isParameterPropertyModifier,
     isParenthesizedExpression: () => isParenthesizedExpression,
@@ -189455,7 +189621,6 @@ ${e.message}`;
     isPackedArrayLiteral: () => isPackedArrayLiteral,
     isParameter: () => isParameter,
     isParameterDeclaration: () => isParameterDeclaration,
-    isParameterOrCatchClauseVariable: () => isParameterOrCatchClauseVariable,
     isParameterPropertyDeclaration: () => isParameterPropertyDeclaration,
     isParameterPropertyModifier: () => isParameterPropertyModifier,
     isParenthesizedExpression: () => isParenthesizedExpression,

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20240108`;
+var version = `${versionMajorMinor}.0-dev.20240110`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -11129,7 +11129,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) {