typescript 5.4.0-dev.20240109 → 5.4.0-dev.20240111

package/lib/tsserver.js

@@ -898,6 +898,7 @@ __export(server_exports, {
   getModuleSpecifierEndingPreference: () => getModuleSpecifierEndingPreference,
   getModuleSpecifierResolverHost: () => getModuleSpecifierResolverHost,
   getNameForExportedSymbol: () => getNameForExportedSymbol,
+  getNameFromImportAttribute: () => getNameFromImportAttribute,
   getNameFromIndexInfo: () => getNameFromIndexInfo,
   getNameFromPropertyName: () => getNameFromPropertyName,
   getNameOfAccessExpression: () => getNameOfAccessExpression,
@@ -2340,7 +2341,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20240109`;
+var version = `${versionMajorMinor}.0-dev.20240111`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6599,6 +6600,7 @@ var InternalSymbolName = /* @__PURE__ */ ((InternalSymbolName2) => {
   InternalSymbolName2["Default"] = "default";
   InternalSymbolName2["This"] = "this";
   InternalSymbolName2["InstantiationExpression"] = "__instantiationExpression";
+  InternalSymbolName2["ImportAttributes"] = "__importAttributes";
   return InternalSymbolName2;
 })(InternalSymbolName || {});
 var NodeCheckFlags = /* @__PURE__ */ ((NodeCheckFlags2) => {
@@ -16546,7 +16548,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 */:
@@ -16571,7 +16573,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 */:
@@ -16605,6 +16607,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) {
@@ -21899,6 +21904,9 @@ var stringReplace = String.prototype.replace;
 function replaceFirstStar(s, replacement) {
   return stringReplace.call(s, "*", replacement);
 }
+function getNameFromImportAttribute(node) {
+  return isIdentifier(node.name) ? node.name.escapedText : escapeLeadingUnderscores(node.name.text);
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -49019,6 +49027,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;
@@ -49173,6 +49189,7 @@ function createTypeChecker(host) {
   var deferredGlobalImportMetaType;
   var deferredGlobalImportMetaExpressionType;
   var deferredGlobalImportCallOptionsType;
+  var deferredGlobalImportAttributesType;
   var deferredGlobalDisposableType;
   var deferredGlobalAsyncDisposableType;
   var deferredGlobalExtractSymbol;
@@ -52068,29 +52085,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) {
@@ -52112,7 +52107,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);
     }
@@ -52150,6 +52178,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;
     }
@@ -57392,7 +57427,7 @@ function createTypeChecker(host) {
         /*reportErrors*/
         false
       ) : unknownType;
-      return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType)));
+      return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, reportErrors2 ? 0 /* Normal */ : 1 /* Contextual */, contextualType)));
     }
     if (isBindingPattern(element.name)) {
       return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors2);
@@ -57473,6 +57508,24 @@ function createTypeChecker(host) {
       0 /* Normal */
     ), declaration, reportErrors2);
   }
+  function getTypeFromImportAttributes(node) {
+    const links = getNodeLinks(node);
+    if (!links.resolvedType) {
+      const symbol = createSymbol(4096 /* ObjectLiteral */, "__importAttributes" /* ImportAttributes */);
+      const members = createSymbolTable();
+      forEach(node.elements, (attr) => {
+        const member = createSymbol(4 /* Property */, getNameFromImportAttribute(attr));
+        member.parent = symbol;
+        member.links.type = checkImportAttribute(attr);
+        member.links.target = member;
+        members.set(member.escapedName, member);
+      });
+      const type = createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
+      type.objectFlags |= 128 /* ObjectLiteral */ | 262144 /* NonInferrableType */;
+      links.resolvedType = type;
+    }
+    return links.resolvedType;
+  }
   function isGlobalSymbolConstructor(node) {
     const symbol = getSymbolOfNode(node);
     const globalSymbol = getGlobalESSymbolConstructorTypeSymbol(
@@ -57526,18 +57579,18 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function getTypeOfVariableOrParameterOrProperty(symbol) {
+  function getTypeOfVariableOrParameterOrProperty(symbol, checkMode) {
     const links = getSymbolLinks(symbol);
     if (!links.type) {
-      const type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
-      if (!links.type && !isParameterOfContextSensitiveSignature(symbol)) {
+      const type = getTypeOfVariableOrParameterOrPropertyWorker(symbol, checkMode);
+      if (!links.type && !isParameterOfContextSensitiveSignature(symbol) && !checkMode) {
         links.type = type;
       }
       return type;
     }
     return links.type;
   }
-  function getTypeOfVariableOrParameterOrPropertyWorker(symbol) {
+  function getTypeOfVariableOrParameterOrPropertyWorker(symbol, checkMode) {
     if (symbol.flags & 4194304 /* Prototype */) {
       return getTypeOfPrototypeProperty(symbol);
     }
@@ -57575,6 +57628,9 @@ function createTypeChecker(host) {
       if (symbol.flags & 512 /* ValueModule */ && !(symbol.flags & 67108864 /* Assignment */)) {
         return getTypeOfFuncClassEnumModule(symbol);
       }
+      if (isBindingElement(declaration) && checkMode === 1 /* Contextual */) {
+        return errorType;
+      }
       return reportCircularityError(symbol);
     }
     let type;
@@ -57612,6 +57668,9 @@ function createTypeChecker(host) {
       if (symbol.flags & 512 /* ValueModule */ && !(symbol.flags & 67108864 /* Assignment */)) {
         return getTypeOfFuncClassEnumModule(symbol);
       }
+      if (isBindingElement(declaration) && checkMode === 1 /* Contextual */) {
+        return type;
+      }
       return reportCircularityError(symbol);
     }
     return type;
@@ -57840,7 +57899,7 @@ function createTypeChecker(host) {
     }
     return getTypeOfSymbol(symbol);
   }
-  function getTypeOfSymbol(symbol) {
+  function getTypeOfSymbol(symbol, checkMode) {
     const checkFlags = getCheckFlags(symbol);
     if (checkFlags & 65536 /* DeferredType */) {
       return getTypeOfSymbolWithDeferredType(symbol);
@@ -57855,7 +57914,7 @@ function createTypeChecker(host) {
       return getTypeOfReverseMappedSymbol(symbol);
     }
     if (symbol.flags & (3 /* Variable */ | 4 /* Property */)) {
-      return getTypeOfVariableOrParameterOrProperty(symbol);
+      return getTypeOfVariableOrParameterOrProperty(symbol, checkMode);
     }
     if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) {
       return getTypeOfFuncClassEnumModule(symbol);
@@ -59888,14 +59947,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;
@@ -59986,6 +60061,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;
@@ -61454,6 +61530,14 @@ function createTypeChecker(host) {
       reportErrors2
     )) || emptyObjectType;
   }
+  function getGlobalImportAttributesType(reportErrors2) {
+    return deferredGlobalImportAttributesType || (deferredGlobalImportAttributesType = getGlobalType(
+      "ImportAttributes",
+      /*arity*/
+      0,
+      reportErrors2
+    )) || emptyObjectType;
+  }
   function getGlobalESSymbolConstructorSymbol(reportErrors2) {
     return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors2));
   }
@@ -66611,6 +66695,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;
@@ -66793,16 +66889,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;
             }
@@ -66973,9 +67061,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);
@@ -72188,9 +72285,9 @@ function createTypeChecker(host) {
       }
     }
   }
-  function getNarrowedTypeOfSymbol(symbol, location) {
+  function getNarrowedTypeOfSymbol(symbol, location, checkMode) {
     var _a;
-    const type = getTypeOfSymbol(symbol);
+    const type = getTypeOfSymbol(symbol, checkMode);
     const declaration = symbol.valueDeclaration;
     if (declaration) {
       if (isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
@@ -72317,7 +72414,7 @@ function createTypeChecker(host) {
       }
     }
     checkNestedBlockScopedBinding(node, symbol);
-    let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);
+    let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node, checkMode);
     const assignmentKind = getAssignmentTargetKind(node);
     if (assignmentKind) {
       if (!(localOrExportSymbol.flags & 3 /* Variable */) && !(isInJSFile(node) && localOrExportSymbol.flags & 512 /* ValueModule */)) {
@@ -73627,6 +73724,8 @@ function createTypeChecker(host) {
       case 286 /* JsxOpeningElement */:
       case 285 /* JsxSelfClosingElement */:
         return getContextualJsxElementAttributesType(parent2, contextFlags);
+      case 301 /* ImportAttribute */:
+        return getContextualImportAttributeType(parent2);
     }
     return void 0;
   }
@@ -73674,6 +73773,12 @@ function createTypeChecker(host) {
       }
     }
   }
+  function getContextualImportAttributeType(node) {
+    return getTypeOfPropertyOfContextualType(getGlobalImportAttributesType(
+      /*reportErrors*/
+      false
+    ), getNameFromImportAttribute(node));
+  }
   function getContextualJsxElementAttributesType(node, contextFlags) {
     if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
       const index = findContextualNode(
@@ -85759,6 +85864,13 @@ function createTypeChecker(host) {
     var _a;
     const node = declaration.attributes;
     if (node) {
+      const importAttributesType = getGlobalImportAttributesType(
+        /*reportErrors*/
+        true
+      );
+      if (importAttributesType !== emptyObjectType) {
+        checkTypeAssignableTo(getTypeFromImportAttributes(node), getNullableType(importAttributesType, 32768 /* Undefined */), node);
+      }
       const validForTypeAttributes = isExclusivelyTypeOnlyImportOrExport(declaration);
       const override = getResolutionModeOverride(node, validForTypeAttributes ? grammarErrorOnNode : void 0);
       const isImportAttributes2 = declaration.attributes.token === 118 /* WithKeyword */;
@@ -85778,6 +85890,9 @@ function createTypeChecker(host) {
       }
     }
   }
+  function checkImportAttribute(node) {
+    return getRegularTypeOfLiteralType(checkExpressionCached(node.value));
+  }
   function checkImportDeclaration(node) {
     if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
       return;
@@ -87193,6 +87308,12 @@ function createTypeChecker(host) {
     if (isMetaProperty(node.parent) && node.parent.keywordToken === node.kind) {
       return checkMetaPropertyKeyword(node.parent);
     }
+    if (isImportAttributes(node)) {
+      return getGlobalImportAttributesType(
+        /*reportErrors*/
+        false
+      );
+    }
     return errorType;
   }
   function getTypeOfAssignmentPattern(expr) {
@@ -118397,7 +118518,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;
@@ -124498,7 +124626,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         }
         const isFromNodeModulesSearch = resolution.isExternalLibraryImport;
         const isJsFile = !resolutionExtensionIsTSOrJson(resolution.extension);
-        const isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile;
+        const isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile && (!resolution.originalPath || pathContainsNodeModules(resolution.resolvedFileName));
         const resolvedFileName = resolution.resolvedFileName;
         if (isFromNodeModulesSearch) {
           currentNodeModulesDepth++;
@@ -152355,14 +152483,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);
@@ -152458,7 +152586,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) {
@@ -160813,7 +160941,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     return isIdentifier(e) ? e : isPropertyAccessExpression(e) ? getLeftMostName(e.expression) : void 0;
   }
   function tryGetGlobalSymbols() {
-    const result = tryGetObjectTypeLiteralInTypeArgumentCompletionSymbols() || tryGetObjectLikeCompletionSymbols() || tryGetImportCompletionSymbols() || tryGetImportOrExportClauseCompletionSymbols() || tryGetLocalNamedExportCompletionSymbols() || tryGetConstructorCompletion() || tryGetClassLikeCompletionSymbols() || tryGetJsxCompletionSymbols() || (getGlobalCompletions(), 1 /* Success */);
+    const result = tryGetObjectTypeLiteralInTypeArgumentCompletionSymbols() || tryGetObjectLikeCompletionSymbols() || tryGetImportCompletionSymbols() || tryGetImportOrExportClauseCompletionSymbols() || tryGetImportAttributesCompletionSymbols() || tryGetLocalNamedExportCompletionSymbols() || tryGetConstructorCompletion() || tryGetClassLikeCompletionSymbols() || tryGetJsxCompletionSymbols() || (getGlobalCompletions(), 1 /* Success */);
     return result === 1 /* Success */;
   }
   function tryGetConstructorCompletion() {
@@ -161281,6 +161409,16 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     }
     return 1 /* Success */;
   }
+  function tryGetImportAttributesCompletionSymbols() {
+    if (contextToken === void 0)
+      return 0 /* Continue */;
+    const importAttributes = contextToken.kind === 19 /* OpenBraceToken */ || contextToken.kind === 28 /* CommaToken */ ? tryCast(contextToken.parent, isImportAttributes) : contextToken.kind === 59 /* ColonToken */ ? tryCast(contextToken.parent.parent, isImportAttributes) : void 0;
+    if (importAttributes === void 0)
+      return 0 /* Continue */;
+    const existing = new Set(importAttributes.elements.map(getNameFromImportAttribute));
+    symbols = filter(typeChecker.getTypeAtLocation(importAttributes).getApparentProperties(), (attr) => !existing.has(attr.escapedName));
+    return 1 /* Success */;
+  }
   function tryGetLocalNamedExportCompletionSymbols() {
     var _a;
     const namedExports = contextToken && (contextToken.kind === 19 /* OpenBraceToken */ || contextToken.kind === 28 /* CommaToken */) ? tryCast(contextToken.parent, isNamedExports) : void 0;
@@ -167323,14 +167461,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)
@@ -167339,7 +167477,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();
@@ -167471,11 +167609,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;
   }
@@ -167529,7 +167667,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);
@@ -167589,11 +167727,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;
   }
@@ -167608,7 +167746,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(
@@ -167652,11 +167790,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);
@@ -167778,8 +167923,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,
@@ -167791,14 +167954,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) {
@@ -174787,6 +174965,7 @@ __export(ts_exports2, {
   getModuleSpecifierEndingPreference: () => getModuleSpecifierEndingPreference,
   getModuleSpecifierResolverHost: () => getModuleSpecifierResolverHost,
   getNameForExportedSymbol: () => getNameForExportedSymbol,
+  getNameFromImportAttribute: () => getNameFromImportAttribute,
   getNameFromIndexInfo: () => getNameFromIndexInfo,
   getNameFromPropertyName: () => getNameFromPropertyName,
   getNameOfAccessExpression: () => getNameOfAccessExpression,
@@ -189587,6 +189766,7 @@ start(initializeNodeSystem(), require("os").platform());
   getModuleSpecifierEndingPreference,
   getModuleSpecifierResolverHost,
   getNameForExportedSymbol,
+  getNameFromImportAttribute,
   getNameFromIndexInfo,
   getNameFromPropertyName,
   getNameOfAccessExpression,