typescript 5.4.2 → 5.4.5

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = "5.4.2";
+      version = "5.4.5";
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -5423,14 +5423,17 @@ ${lanes.join("\n")}
       pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === 250 /* Low */ ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingInterval === 250 /* Low */ ? "pollLowPollingIntervalQueue" : "pollPollingIntervalQueue", pollingIntervalQueue(pollingInterval));
     }
   }
-  function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2) {
+  function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2, getModifiedTime3, fsWatchWithTimestamp) {
     const fileWatcherCallbacks = createMultiMap();
+    const fileTimestamps = fsWatchWithTimestamp ? /* @__PURE__ */ new Map() : void 0;
     const dirWatchers = /* @__PURE__ */ new Map();
     const toCanonicalName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
     return nonPollingWatchFile;
     function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) {
       const filePath = toCanonicalName(fileName);
-      fileWatcherCallbacks.add(filePath, callback);
+      if (fileWatcherCallbacks.add(filePath, callback).length === 1 && fileTimestamps) {
+        fileTimestamps.set(filePath, getModifiedTime3(fileName) || missingFileModifiedTime);
+      }
       const dirPath = getDirectoryPath(filePath) || ".";
       const watcher = dirWatchers.get(dirPath) || createDirectoryWatcher(getDirectoryPath(fileName) || ".", dirPath, fallbackOptions);
       watcher.referenceCount++;
@@ -5450,14 +5453,31 @@ ${lanes.join("\n")}
       const watcher = fsWatch(
         dirName,
         1 /* Directory */,
-        (_eventName, relativeFileName, modifiedTime) => {
+        (eventName, relativeFileName) => {
           if (!isString(relativeFileName))
             return;
           const fileName = getNormalizedAbsolutePath(relativeFileName, dirName);
-          const callbacks = fileName && fileWatcherCallbacks.get(toCanonicalName(fileName));
+          const filePath = toCanonicalName(fileName);
+          const callbacks = fileName && fileWatcherCallbacks.get(filePath);
           if (callbacks) {
+            let currentModifiedTime;
+            let eventKind = 1 /* Changed */;
+            if (fileTimestamps) {
+              const existingTime = fileTimestamps.get(filePath);
+              if (eventName === "change") {
+                currentModifiedTime = getModifiedTime3(fileName) || missingFileModifiedTime;
+                if (currentModifiedTime.getTime() === existingTime.getTime())
+                  return;
+              }
+              currentModifiedTime || (currentModifiedTime = getModifiedTime3(fileName) || missingFileModifiedTime);
+              fileTimestamps.set(filePath, currentModifiedTime);
+              if (existingTime === missingFileModifiedTime)
+                eventKind = 0 /* Created */;
+              else if (currentModifiedTime === missingFileModifiedTime)
+                eventKind = 2 /* Deleted */;
+            }
             for (const fileCallback of callbacks) {
-              fileCallback(fileName, 1 /* Changed */, modifiedTime);
+              fileCallback(fileName, eventKind, currentModifiedTime);
             }
           }
         },
@@ -5849,7 +5869,7 @@ ${lanes.join("\n")}
           );
         case 5 /* UseFsEventsOnParentDirectory */:
           if (!nonPollingWatchFile) {
-            nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2);
+            nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2, getModifiedTime3, fsWatchWithTimestamp);
           }
           return nonPollingWatchFile(fileName, callback, pollingInterval, getFallbackOptions(options));
         default:
@@ -6024,7 +6044,7 @@ ${lanes.join("\n")}
           return watchPresentFileSystemEntryWithFsWatchFile();
         }
         try {
-          const presentWatcher = (!fsWatchWithTimestamp ? fsWatchWorker : fsWatchWorkerHandlingTimestamp)(
+          const presentWatcher = (entryKind === 1 /* Directory */ || !fsWatchWithTimestamp ? fsWatchWorker : fsWatchWorkerHandlingTimestamp)(
             fileOrDirectory,
             recursive,
             inodeWatching ? callbackChangingToMissingFileSystemEntry : callback
@@ -45450,13 +45470,21 @@ ${lanes.join("\n")}
       }
       const nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, getDirectoryPath(modulePath));
       const nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
-      if (nearestSourcePackageJson !== nearestTargetPackageJson) {
+      const ignoreCase = !hostUsesCaseSensitiveFileNames(host);
+      if (!packageJsonPathsAreEqual(nearestTargetPackageJson, nearestSourcePackageJson, ignoreCase)) {
         return maybeNonRelative;
       }
       return relativePath;
     }
     return isPathRelativeToParent(maybeNonRelative) || countPathComponents(relativePath) < countPathComponents(maybeNonRelative) ? relativePath : maybeNonRelative;
   }
+  function packageJsonPathsAreEqual(a, b, ignoreCase) {
+    if (a === b)
+      return true;
+    if (a === void 0 || b === void 0)
+      return false;
+    return comparePaths(a, b, ignoreCase) === 0 /* EqualTo */;
+  }
   function countPathComponents(path) {
     let count = 0;
     for (let i = startsWith(path, "./") ? 2 : 0; i < path.length; i++) {
@@ -50016,13 +50044,6 @@ ${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;
       }
@@ -50502,15 +50523,19 @@ ${lanes.join("\n")}
         return true;
       }
     }
-    function isEntityNameVisible(entityName, enclosingDeclaration) {
+    function getMeaningOfEntityNameReference(entityName) {
       let meaning;
       if (entityName.parent.kind === 186 /* TypeQuery */ || entityName.parent.kind === 233 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 167 /* ComputedPropertyName */) {
         meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
-      } else if (entityName.kind === 166 /* QualifiedName */ || entityName.kind === 211 /* PropertyAccessExpression */ || entityName.parent.kind === 271 /* ImportEqualsDeclaration */) {
+      } else if (entityName.kind === 166 /* QualifiedName */ || entityName.kind === 211 /* PropertyAccessExpression */ || entityName.parent.kind === 271 /* ImportEqualsDeclaration */ || entityName.parent.kind === 166 /* QualifiedName */ && entityName.parent.left === entityName || entityName.parent.kind === 211 /* PropertyAccessExpression */ && entityName.parent.expression === entityName || entityName.parent.kind === 212 /* ElementAccessExpression */ && entityName.parent.expression === entityName) {
         meaning = 1920 /* Namespace */;
       } else {
         meaning = 788968 /* Type */;
       }
+      return meaning;
+    }
+    function isEntityNameVisible(entityName, enclosingDeclaration) {
+      const meaning = getMeaningOfEntityNameReference(entityName);
       const firstIdentifier = getFirstIdentifier(entityName);
       const symbol = resolveName(
         enclosingDeclaration,
@@ -52571,9 +52596,10 @@ ${lanes.join("\n")}
           introducesError = true;
           return { introducesError, node };
         }
+        const meaning = getMeaningOfEntityNameReference(node);
         const sym = resolveEntityName(
           leftmost,
-          -1 /* All */,
+          meaning,
           /*ignoreErrors*/
           true,
           /*dontResolveAlias*/
@@ -52583,13 +52609,13 @@ ${lanes.join("\n")}
           if (isSymbolAccessible(
             sym,
             context.enclosingDeclaration,
-            -1 /* All */,
+            meaning,
             /*shouldComputeAliasesToMakeVisible*/
             false
           ).accessibility !== 0 /* Accessible */) {
             introducesError = true;
           } else {
-            context.tracker.trackSymbol(sym, context.enclosingDeclaration, -1 /* All */);
+            context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
             includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
           }
           if (isIdentifier(node)) {
@@ -57817,16 +57843,17 @@ ${lanes.join("\n")}
       const target = type.target ?? type;
       const typeVariable = getHomomorphicTypeVariable(target);
       if (typeVariable && !target.declaration.nameType) {
-        const constraint = getConstraintTypeFromMappedType(type);
-        if (constraint.flags & 4194304 /* Index */) {
-          const baseConstraint = getBaseConstraintOfType(constraint.type);
-          if (baseConstraint && everyType(baseConstraint, isArrayOrTupleType)) {
-            return instantiateType(target, prependTypeMapping(typeVariable, baseConstraint, type.mapper));
-          }
+        const modifiersType = getModifiersTypeFromMappedType(type);
+        const baseConstraint = isGenericMappedType(modifiersType) ? getApparentTypeOfMappedType(modifiersType) : getBaseConstraintOfType(modifiersType);
+        if (baseConstraint && everyType(baseConstraint, (t) => isArrayOrTupleType(t) || isArrayOrTupleOrIntersection(t))) {
+          return instantiateType(target, prependTypeMapping(typeVariable, baseConstraint, type.mapper));
         }
       }
       return type;
     }
+    function isArrayOrTupleOrIntersection(type) {
+      return !!(type.flags & 2097152 /* Intersection */) && every(type.types, isArrayOrTupleType);
+    }
     function isMappedTypeGenericIndexedAccess(type) {
       let objectType;
       return !!(type.flags & 8388608 /* IndexedAccess */ && getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ && !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) && !(getMappedTypeModifiers(objectType) & 8 /* ExcludeOptional */) && !objectType.declaration.nameType);
@@ -57980,13 +58007,13 @@ ${lanes.join("\n")}
     }
     function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
       var _a, _b, _c;
-      let property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? void 0 : _b.get(name) : void 0;
+      let property = skipObjectFunctionPropertyAugment ? (_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name) : (_b = type.propertyCache) == null ? void 0 : _b.get(name);
       if (!property) {
         property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
         if (property) {
           const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
           properties.set(name, property);
-          if (skipObjectFunctionPropertyAugment && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
+          if (skipObjectFunctionPropertyAugment && !(getCheckFlags(property) & 48 /* Partial */) && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
             const properties2 = type.propertyCache || (type.propertyCache = createSymbolTable());
             properties2.set(name, property);
           }
@@ -60465,7 +60492,7 @@ ${lanes.join("\n")}
         const typeVarIndex = typeSet[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
         const typeVariable = typeSet[typeVarIndex];
         const primitiveType = typeSet[1 - typeVarIndex];
-        if (typeVariable.flags & 8650752 /* TypeVariable */ && (primitiveType.flags & (402784252 /* Primitive */ | 67108864 /* NonPrimitive */) || includes & 16777216 /* IncludesEmptyObject */)) {
+        if (typeVariable.flags & 8650752 /* TypeVariable */ && (primitiveType.flags & (402784252 /* Primitive */ | 67108864 /* NonPrimitive */) && !isGenericStringLikeType(primitiveType) || includes & 16777216 /* IncludesEmptyObject */)) {
           const constraint = getBaseConstraintOfType(typeVariable);
           if (constraint && everyType(constraint, (t) => !!(t.flags & (402784252 /* Primitive */ | 67108864 /* NonPrimitive */)) || isEmptyAnonymousObjectType(t))) {
             if (isTypeStrictSubtypeOf(constraint, primitiveType)) {
@@ -60493,6 +60520,9 @@ ${lanes.join("\n")}
           } else if (every(typeSet, (t) => !!(t.flags & 1048576 /* Union */ && (t.types[0].flags & 65536 /* Null */ || t.types[1].flags & 65536 /* Null */)))) {
             removeFromEach(typeSet, 65536 /* Null */);
             result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
+          } else if (typeSet.length >= 4) {
+            const middle = Math.floor(typeSet.length / 2);
+            result = getIntersectionType([getIntersectionType(typeSet.slice(0, middle)), getIntersectionType(typeSet.slice(middle))], aliasSymbol, aliasTypeArguments);
           } else {
             if (!checkCrossProductUnion(typeSet)) {
               return errorType;
@@ -61073,6 +61103,9 @@ ${lanes.join("\n")}
     function isPatternLiteralType(type) {
       return !!(type.flags & 134217728 /* TemplateLiteral */) && every(type.types, isPatternLiteralPlaceholderType) || !!(type.flags & 268435456 /* StringMapping */) && isPatternLiteralPlaceholderType(type.type);
     }
+    function isGenericStringLikeType(type) {
+      return !!(type.flags & (134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */)) && !isPatternLiteralType(type);
+    }
     function isGenericType(type) {
       return !!getGenericObjectFlags(type);
     }
@@ -61095,7 +61128,7 @@ ${lanes.join("\n")}
         }
         return type.objectFlags & 12582912 /* IsGenericType */;
       }
-      return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
+      return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */) || isGenericStringLikeType(type) ? 8388608 /* IsGenericIndexType */ : 0);
     }
     function getSimplifiedType(type, writing) {
       return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) : type;
@@ -62194,29 +62227,28 @@ ${lanes.join("\n")}
       if (typeVariable) {
         const mappedTypeVariable = instantiateType(typeVariable, mapper);
         if (typeVariable !== mappedTypeVariable) {
-          return mapTypeWithAlias(
-            getReducedType(mappedTypeVariable),
-            (t) => {
-              if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
-                if (!type.declaration.nameType) {
-                  let constraint;
-                  if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) {
-                    return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
-                  }
-                  if (isTupleType(t)) {
-                    return instantiateMappedTupleType(t, type, typeVariable, mapper);
-                  }
-                }
-                return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
-              }
-              return t;
-            },
-            aliasSymbol,
-            aliasTypeArguments
-          );
+          return mapTypeWithAlias(getReducedType(mappedTypeVariable), instantiateConstituent, aliasSymbol, aliasTypeArguments);
         }
       }
       return instantiateType(getConstraintTypeFromMappedType(type), mapper) === wildcardType ? wildcardType : instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments);
+      function instantiateConstituent(t) {
+        if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
+          if (!type.declaration.nameType) {
+            let constraint;
+            if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) {
+              return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
+            }
+            if (isTupleType(t)) {
+              return instantiateMappedTupleType(t, type, typeVariable, mapper);
+            }
+            if (isArrayOrTupleOrIntersection(t)) {
+              return getIntersectionType(map(t.types, instantiateConstituent));
+            }
+          }
+          return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
+        }
+        return t;
+      }
     }
     function getModifiedReadonlyState(state, modifiers) {
       return modifiers & 1 /* IncludeReadonly */ ? true : modifiers & 2 /* ExcludeReadonly */ ? false : state;
@@ -68143,7 +68175,7 @@ ${lanes.join("\n")}
     function hasMatchingArgument(expression, reference) {
       if (expression.arguments) {
         for (const argument of expression.arguments) {
-          if (isOrContainsMatchingReference(reference, argument) || optionalChainContainsReference(argument, reference) || getCandidateDiscriminantPropertyAccess(argument, reference)) {
+          if (isOrContainsMatchingReference(reference, argument) || optionalChainContainsReference(argument, reference)) {
             return true;
           }
         }
@@ -68153,36 +68185,6 @@ ${lanes.join("\n")}
       }
       return false;
     }
-    function getCandidateDiscriminantPropertyAccess(expr, reference) {
-      if (isBindingPattern(reference) || isFunctionExpressionOrArrowFunction(reference) || isObjectLiteralMethod(reference)) {
-        if (isIdentifier(expr)) {
-          const symbol = getResolvedSymbol(expr);
-          const declaration = symbol.valueDeclaration;
-          if (declaration && (isBindingElement(declaration) || isParameter(declaration)) && reference === declaration.parent && !declaration.initializer && !declaration.dotDotDotToken) {
-            return declaration;
-          }
-        }
-      } else if (isAccessExpression(expr)) {
-        if (isMatchingReference(reference, expr.expression)) {
-          return expr;
-        }
-      } else if (isIdentifier(expr)) {
-        const symbol = getResolvedSymbol(expr);
-        if (isConstantVariable(symbol)) {
-          const declaration = symbol.valueDeclaration;
-          if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) && isMatchingReference(reference, declaration.initializer.expression)) {
-            return declaration.initializer;
-          }
-          if (isBindingElement(declaration) && !declaration.initializer) {
-            const parent2 = declaration.parent.parent;
-            if (isVariableDeclaration(parent2) && !parent2.type && parent2.initializer && (isIdentifier(parent2.initializer) || isAccessExpression(parent2.initializer)) && isMatchingReference(reference, parent2.initializer)) {
-              return declaration;
-            }
-          }
-        }
-      }
-      return void 0;
-    }
     function getFlowNodeId(flow) {
       if (!flow.id || flow.id < 0) {
         flow.id = nextFlowId;
@@ -69282,9 +69284,39 @@ ${lanes.join("\n")}
         }
         return result;
       }
+      function getCandidateDiscriminantPropertyAccess(expr) {
+        if (isBindingPattern(reference) || isFunctionExpressionOrArrowFunction(reference) || isObjectLiteralMethod(reference)) {
+          if (isIdentifier(expr)) {
+            const symbol = getResolvedSymbol(expr);
+            const declaration = symbol.valueDeclaration;
+            if (declaration && (isBindingElement(declaration) || isParameter(declaration)) && reference === declaration.parent && !declaration.initializer && !declaration.dotDotDotToken) {
+              return declaration;
+            }
+          }
+        } else if (isAccessExpression(expr)) {
+          if (isMatchingReference(reference, expr.expression)) {
+            return expr;
+          }
+        } else if (isIdentifier(expr)) {
+          const symbol = getResolvedSymbol(expr);
+          if (isConstantVariable(symbol)) {
+            const declaration = symbol.valueDeclaration;
+            if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) && isMatchingReference(reference, declaration.initializer.expression)) {
+              return declaration.initializer;
+            }
+            if (isBindingElement(declaration) && !declaration.initializer) {
+              const parent2 = declaration.parent.parent;
+              if (isVariableDeclaration(parent2) && !parent2.type && parent2.initializer && (isIdentifier(parent2.initializer) || isAccessExpression(parent2.initializer)) && isMatchingReference(reference, parent2.initializer)) {
+                return declaration;
+              }
+            }
+          }
+        }
+        return void 0;
+      }
       function getDiscriminantPropertyAccess(expr, computedType) {
         if (declaredType.flags & 1048576 /* Union */ || computedType.flags & 1048576 /* Union */) {
-          const access = getCandidateDiscriminantPropertyAccess(expr, reference);
+          const access = getCandidateDiscriminantPropertyAccess(expr);
           if (access) {
             const name = getAccessedPropertyName(access);
             if (name) {
@@ -75005,7 +75037,7 @@ ${lanes.join("\n")}
         }
         return resolveErrorCall(node);
       }
-      if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunctionOrConstructor)) {
+      if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
         skippedGenericFunction(node, checkMode);
         return resolvingSignature;
       }
@@ -75015,12 +75047,8 @@ ${lanes.join("\n")}
       }
       return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags);
     }
-    function isGenericFunctionReturningFunctionOrConstructor(signature) {
-      if (!signature.typeParameters) {
-        return false;
-      }
-      const returnType = getReturnTypeOfSignature(signature);
-      return isFunctionType(returnType) || isConstructorType(returnType);
+    function isGenericFunctionReturningFunction(signature) {
+      return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature)));
     }
     function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) {
       return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144 /* TypeParameter */) || !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & 1048576 /* Union */) && !(getReducedType(apparentFuncType).flags & 131072 /* Never */) && isTypeAssignableTo(funcType, globalFunctionType);
@@ -83177,7 +83205,7 @@ ${lanes.join("\n")}
         error2(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
       } else {
         const text = getTextOfPropertyName(member.name);
-        if (isNumericLiteralName(text)) {
+        if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
           error2(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
         }
       }
@@ -159652,7 +159680,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     function symbolAppearsToBeTypeOnly(symbol) {
       var _a;
-      return !(symbol.flags & 111551 /* Value */) && (!isInJSFile((_a = symbol.declarations) == null ? void 0 : _a[0]) || !!(symbol.flags & 788968 /* Type */));
+      const flags = getCombinedLocalAndExportSymbolFlags(skipAlias(symbol, typeChecker));
+      return !(flags & 111551 /* Value */) && (!isInJSFile((_a = symbol.declarations) == null ? void 0 : _a[0]) || !!(flags & 788968 /* Type */));
     }
   }
   function getLabelCompletionAtPosition(node) {
@@ -159948,10 +159977,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return isJsxExpression(parent2) && !isJsxElement(parent2.parent) && !isJsxFragment(parent2.parent) ? checker.getContextualTypeForJsxAttribute(parent2.parent) : void 0;
       default:
         const argInfo = ts_SignatureHelp_exports.getArgumentInfoForCompletions(previousToken, position, sourceFile, checker);
-        return argInfo ? (
-          // At `,`, treat this as the next argument after the comma.
-          checker.getContextualTypeForArgumentAtIndex(argInfo.invocation, argInfo.argumentIndex + (previousToken.kind === 28 /* CommaToken */ ? 1 : 0))
-        ) : isEqualityOperatorKind(previousToken.kind) && isBinaryExpression(parent2) && isEqualityOperatorKind(parent2.operatorToken.kind) ? (
+        return argInfo ? checker.getContextualTypeForArgumentAtIndex(argInfo.invocation, argInfo.argumentIndex) : isEqualityOperatorKind(previousToken.kind) && isBinaryExpression(parent2) && isEqualityOperatorKind(parent2.operatorToken.kind) ? (
           // completion at `x ===/**/` should be for the right side
           checker.getTypeAtLocation(parent2.left)
         ) : checker.getContextualType(previousToken, 4 /* Completions */) || checker.getContextualType(previousToken);
@@ -168515,12 +168541,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     if (!info)
       return void 0;
     const { list, argumentIndex } = info;
-    const argumentCount = getArgumentCount(
-      list,
-      /*ignoreTrailingComma*/
-      isInString(sourceFile, position, node),
-      checker
-    );
+    const argumentCount = getArgumentCount(checker, list);
     if (argumentIndex !== 0) {
       Debug.assertLessThan(argumentIndex, argumentCount);
     }
@@ -168532,7 +168553,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       return { list: getChildListThatStartsWithOpenerToken(node.parent, node, sourceFile), argumentIndex: 0 };
     } else {
       const list = findContainingList(node);
-      return list && { list, argumentIndex: getArgumentIndex(list, node, checker) };
+      return list && { list, argumentIndex: getArgumentIndex(checker, list, node) };
     }
   }
   function getImmediatelyContainingArgumentInfo(node, position, sourceFile, checker) {
@@ -168662,24 +168683,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       return isFunctionTypeNode(d) ? (_a = tryCast(d.parent, canHaveSymbol)) == null ? void 0 : _a.symbol : void 0;
     }) || s : s;
   }
-  function getArgumentIndex(argumentsList, node, checker) {
-    const args = argumentsList.getChildren();
-    let argumentIndex = 0;
-    for (let pos = 0; pos < length(args); pos++) {
-      const child = args[pos];
-      if (child === node) {
-        break;
-      }
-      if (isSpreadElement(child)) {
-        argumentIndex = argumentIndex + getSpreadElementCount(child, checker) + (pos > 0 ? pos : 0);
-      } else {
-        if (child.kind !== 28 /* CommaToken */) {
-          argumentIndex++;
-        }
-      }
-    }
-    return argumentIndex;
-  }
   function getSpreadElementCount(node, checker) {
     const spreadType = checker.getTypeAtLocation(node.expression);
     if (checker.isTupleType(spreadType)) {
@@ -168692,19 +168695,48 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return 0;
   }
-  function getArgumentCount(argumentsList, ignoreTrailingComma, checker) {
-    const listChildren = argumentsList.getChildren();
-    let argumentCount = 0;
-    for (const child of listChildren) {
+  function getArgumentIndex(checker, argumentsList, node) {
+    return getArgumentIndexOrCount(checker, argumentsList, node);
+  }
+  function getArgumentCount(checker, argumentsList) {
+    return getArgumentIndexOrCount(
+      checker,
+      argumentsList,
+      /*node*/
+      void 0
+    );
+  }
+  function getArgumentIndexOrCount(checker, argumentsList, node) {
+    const args = argumentsList.getChildren();
+    let argumentIndex = 0;
+    let skipComma = false;
+    for (const child of args) {
+      if (node && child === node) {
+        if (!skipComma && child.kind === 28 /* CommaToken */) {
+          argumentIndex++;
+        }
+        return argumentIndex;
+      }
       if (isSpreadElement(child)) {
-        argumentCount = argumentCount + getSpreadElementCount(child, checker);
+        argumentIndex += getSpreadElementCount(child, checker);
+        skipComma = true;
+        continue;
+      }
+      if (child.kind !== 28 /* CommaToken */) {
+        argumentIndex++;
+        skipComma = true;
+        continue;
       }
+      if (skipComma) {
+        skipComma = false;
+        continue;
+      }
+      argumentIndex++;
     }
-    argumentCount = argumentCount + countWhere(listChildren, (arg) => arg.kind !== 28 /* CommaToken */);
-    if (!ignoreTrailingComma && listChildren.length > 0 && last(listChildren).kind === 28 /* CommaToken */) {
-      argumentCount++;
+    if (node) {
+      return argumentIndex;
     }
-    return argumentCount;
+    return args.length && last(args).kind === 28 /* CommaToken */ ? argumentIndex + 1 : argumentIndex;
   }
   function getArgumentIndexForTemplatePiece(spanIndex, node, position, sourceFile) {
     Debug.assert(position >= node.getStart(), "Assumed 'position' could not occur before node.");
@@ -178292,7 +178324,16 @@ ${options.prefix}` : "\n" : options.prefix
         recursive ? watchedDirectoriesRecursive : watchedDirectories,
         path,
         callback,
-        (id) => ({ eventName: CreateDirectoryWatcherEvent, data: { id, path, recursive: !!recursive } })
+        (id) => ({
+          eventName: CreateDirectoryWatcherEvent,
+          data: {
+            id,
+            path,
+            recursive: !!recursive,
+            // Special case node_modules as we watch it for changes to closed script infos as well
+            ignoreUpdate: !path.endsWith("/node_modules") ? true : void 0
+          }
+        })
       );
     }
     function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path, callback, event) {
@@ -178319,24 +178360,28 @@ ${options.prefix}` : "\n" : options.prefix
         }
       };
     }
-    function onWatchChange({ id, path, eventType }) {
-      onFileWatcherCallback(id, path, eventType);
-      onDirectoryWatcherCallback(watchedDirectories, id, path, eventType);
-      onDirectoryWatcherCallback(watchedDirectoriesRecursive, id, path, eventType);
+    function onWatchChange(args) {
+      if (isArray(args))
+        args.forEach(onWatchChangeRequestArgs);
+      else
+        onWatchChangeRequestArgs(args);
     }
-    function onFileWatcherCallback(id, eventPath, eventType) {
-      var _a;
-      (_a = watchedFiles.idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
-        const eventKind = eventType === "create" ? 0 /* Created */ : eventType === "delete" ? 2 /* Deleted */ : 1 /* Changed */;
-        callback(eventPath, eventKind);
-      });
+    function onWatchChangeRequestArgs({ id, created, deleted, updated }) {
+      onWatchEventType(id, created, 0 /* Created */);
+      onWatchEventType(id, deleted, 2 /* Deleted */);
+      onWatchEventType(id, updated, 1 /* Changed */);
     }
-    function onDirectoryWatcherCallback({ idToCallbacks }, id, eventPath, eventType) {
-      var _a;
-      if (eventType === "update")
+    function onWatchEventType(id, paths, eventKind) {
+      if (!(paths == null ? void 0 : paths.length))
         return;
-      (_a = idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
-        callback(eventPath);
+      forEachCallback(watchedFiles, id, paths, (callback, eventPath) => callback(eventPath, eventKind));
+      forEachCallback(watchedDirectories, id, paths, (callback, eventPath) => callback(eventPath));
+      forEachCallback(watchedDirectoriesRecursive, id, paths, (callback, eventPath) => callback(eventPath));
+    }
+    function forEachCallback(hostWatcherMap, id, eventPaths, cb) {
+      var _a;
+      (_a = hostWatcherMap.idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
+        eventPaths.forEach((eventPath) => cb(callback, normalizeSlashes(eventPath)));
       });
     }
   }