typescript 5.1.0-dev.20230227 → 5.1.0-dev.20230302

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230227`;
+var version = `${versionMajorMinor}.0-dev.20230302`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -842,9 +842,6 @@ function multiMapRemove(key, value) {
     }
   }
 }
-function createUnderscoreEscapedMultiMap() {
-  return createMultiMap();
-}
 function createQueue(items) {
   const elements = (items == null ? void 0 : items.slice()) || [];
   let headIndex = 0;
@@ -902,10 +899,6 @@ function cast(value, test) {
 }
 function noop(_) {
 }
-var noopPush = {
-  push: noop,
-  length: 0
-};
 function returnFalse() {
   return false;
 }
@@ -7175,6 +7168,7 @@ var Diagnostics = {
   File_name_0_has_a_1_extension_looking_up_2_instead: diag(6262, 3 /* Message */, "File_name_0_has_a_1_extension_looking_up_2_instead_6262", "File name '{0}' has a '{1}' extension - looking up '{2}' instead."),
   Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set: diag(6263, 1 /* Error */, "Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set_6263", "Module '{0}' was resolved to '{1}', but '--allowArbitraryExtensions' is not set."),
   Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present: diag(6264, 3 /* Message */, "Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present_6264", "Enable importing files with any extension, provided a declaration file is present."),
+  Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder: diag(6265, 3 /* Message */, "Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_no_6265", "Resolving type reference directive for program that specifies custom typeRoots, skipping lookup in 'node_modules' folder."),
   Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, 3 /* Message */, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."),
   Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, 3 /* Message */, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."),
   Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, 3 /* Message */, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."),
@@ -7570,6 +7564,8 @@ var Diagnostics = {
   This_may_be_converted_to_an_async_function: diag(80006, 2 /* Suggestion */, "This_may_be_converted_to_an_async_function_80006", "This may be converted to an async function."),
   await_has_no_effect_on_the_type_of_this_expression: diag(80007, 2 /* Suggestion */, "await_has_no_effect_on_the_type_of_this_expression_80007", "'await' has no effect on the type of this expression."),
   Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers: diag(80008, 2 /* Suggestion */, "Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accur_80008", "Numeric literals with absolute values equal to 2^53 or greater are too large to be represented accurately as integers."),
+  JSDoc_typedef_may_be_converted_to_TypeScript_type: diag(80009, 2 /* Suggestion */, "JSDoc_typedef_may_be_converted_to_TypeScript_type_80009", "JSDoc typedef may be converted to TypeScript type."),
+  JSDoc_typedefs_may_be_converted_to_TypeScript_types: diag(80010, 2 /* Suggestion */, "JSDoc_typedefs_may_be_converted_to_TypeScript_types_80010", "JSDoc typedefs may be converted to TypeScript types."),
   Add_missing_super_call: diag(90001, 3 /* Message */, "Add_missing_super_call_90001", "Add missing 'super()' call"),
   Make_super_call_the_first_statement_in_the_constructor: diag(90002, 3 /* Message */, "Make_super_call_the_first_statement_in_the_constructor_90002", "Make 'super()' call the first statement in the constructor"),
   Change_extends_to_implements: diag(90003, 3 /* Message */, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"),
@@ -7784,6 +7780,8 @@ var Diagnostics = {
   Rename_param_tag_name_0_to_1: diag(95173, 3 /* Message */, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"),
   Use_0: diag(95174, 3 /* Message */, "Use_0_95174", "Use `{0}`."),
   Use_Number_isNaN_in_all_conditions: diag(95175, 3 /* Message */, "Use_Number_isNaN_in_all_conditions_95175", "Use `Number.isNaN` in all conditions."),
+  Convert_typedef_to_TypeScript_type: diag(95176, 3 /* Message */, "Convert_typedef_to_TypeScript_type_95176", "Convert typedef to TypeScript type."),
+  Convert_all_typedef_to_TypeScript_types: diag(95177, 3 /* Message */, "Convert_all_typedef_to_TypeScript_types_95177", "Convert all typedef to TypeScript types."),
   No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, 1 /* Error */, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
   Classes_may_not_have_a_field_named_constructor: diag(18006, 1 /* Error */, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
   JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, 1 /* Error */, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -36542,20 +36540,14 @@ function getEffectiveTypeRoots(options, host) {
     currentDirectory = host.getCurrentDirectory();
   }
   if (currentDirectory !== void 0) {
-    return getDefaultTypeRoots(currentDirectory, host);
+    return getDefaultTypeRoots(currentDirectory);
   }
 }
-function getDefaultTypeRoots(currentDirectory, host) {
-  if (!host.directoryExists) {
-    return [combinePaths(currentDirectory, nodeModulesAtTypes)];
-  }
+function getDefaultTypeRoots(currentDirectory) {
   let typeRoots;
   forEachAncestorDirectory(normalizePath(currentDirectory), (directory) => {
     const atTypes = combinePaths(directory, nodeModulesAtTypes);
-    if (host.directoryExists(atTypes)) {
-      (typeRoots || (typeRoots = [])).push(atTypes);
-    }
-    return void 0;
+    (typeRoots != null ? typeRoots : typeRoots = []).push(atTypes);
   });
   return typeRoots;
 }
@@ -36692,10 +36684,22 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
       }
       return firstDefined(typeRoots, (typeRoot) => {
         const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
-        const candidateDirectory = getDirectoryPath(candidate);
-        const directoryExists = directoryProbablyExists(candidateDirectory, host);
+        const directoryExists = directoryProbablyExists(typeRoot, host);
         if (!directoryExists && traceEnabled) {
-          trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);
+          trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
+        }
+        if (options.typeRoots) {
+          const resolvedFromFile = loadModuleFromFile(4 /* Declaration */, candidate, !directoryExists, moduleResolutionState);
+          if (resolvedFromFile) {
+            const packageDirectory = parseNodeModuleFromPath(resolvedFromFile.path);
+            const packageInfo = packageDirectory ? getPackageJsonInfo(
+              packageDirectory,
+              /*onlyRecordFailures*/
+              false,
+              moduleResolutionState
+            ) : void 0;
+            return resolvedTypeScriptOnly(withPackageId(packageInfo, resolvedFromFile));
+          }
         }
         return resolvedTypeScriptOnly(
           loadNodeModuleFromDirectory(
@@ -36715,33 +36719,37 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
   function secondaryLookup() {
     const initialLocationForSecondaryLookup = containingFile && getDirectoryPath(containingFile);
     if (initialLocationForSecondaryLookup !== void 0) {
-      if (traceEnabled) {
-        trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
-      }
       let result2;
-      if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
-        const searchResult = loadModuleFromNearestNodeModulesDirectory(
-          4 /* Declaration */,
-          typeReferenceDirectiveName,
-          initialLocationForSecondaryLookup,
-          moduleResolutionState,
-          /*cache*/
-          void 0,
-          /*redirectedReference*/
-          void 0
-        );
-        result2 = searchResult && searchResult.value;
-      } else {
-        const { path: candidate } = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName);
-        result2 = nodeLoadModuleByRelativeName(
-          4 /* Declaration */,
-          candidate,
-          /*onlyRecordFailures*/
-          false,
-          moduleResolutionState,
-          /*considerPackageJson*/
-          true
-        );
+      if (!options.typeRoots || !endsWith(containingFile, inferredTypesContainingFile)) {
+        if (traceEnabled) {
+          trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
+        }
+        if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
+          const searchResult = loadModuleFromNearestNodeModulesDirectory(
+            4 /* Declaration */,
+            typeReferenceDirectiveName,
+            initialLocationForSecondaryLookup,
+            moduleResolutionState,
+            /*cache*/
+            void 0,
+            /*redirectedReference*/
+            void 0
+          );
+          result2 = searchResult && searchResult.value;
+        } else {
+          const { path: candidate } = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName);
+          result2 = nodeLoadModuleByRelativeName(
+            4 /* Declaration */,
+            candidate,
+            /*onlyRecordFailures*/
+            false,
+            moduleResolutionState,
+            /*considerPackageJson*/
+            true
+          );
+        }
+      } else if (traceEnabled) {
+        trace(host, Diagnostics.Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder);
       }
       return resolvedTypeScriptOnly(result2);
     } else {
@@ -37535,6 +37543,9 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
         }
         resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
       }
+      if (extensions2 & 4 /* Declaration */) {
+        resolved2 != null ? resolved2 : resolved2 = resolveFromTypeRoot(moduleName, state2);
+      }
       return resolved2 && { value: resolved2.value && { resolved: resolved2.value, isExternalLibraryImport: true } };
     } else {
       const { path: candidate, parts } = normalizePathForCJSResolution(containingDirectory, moduleName);
@@ -37715,6 +37726,7 @@ function tryFile(fileName, onlyRecordFailures, state) {
   return forEach(state.compilerOptions.moduleSuffixes, (suffix) => tryFileLookup(fileNameNoExtension + suffix + ext, onlyRecordFailures, state));
 }
 function tryFileLookup(fileName, onlyRecordFailures, state) {
+  var _a2;
   if (!onlyRecordFailures) {
     if (state.host.fileExists(fileName)) {
       if (state.traceEnabled) {
@@ -37727,7 +37739,7 @@ function tryFileLookup(fileName, onlyRecordFailures, state) {
       }
     }
   }
-  state.failedLookupLocations.push(fileName);
+  (_a2 = state.failedLookupLocations) == null ? void 0 : _a2.push(fileName);
   return void 0;
 }
 function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson = true) {
@@ -37741,8 +37753,8 @@ function getTemporaryModuleResolutionState(packageJsonInfoCache, host, options)
     host,
     compilerOptions: options,
     traceEnabled: isTraceEnabled(options, host),
-    failedLookupLocations: noopPush,
-    affectingLocations: noopPush,
+    failedLookupLocations: void 0,
+    affectingLocations: void 0,
     packageJsonInfoCache,
     features: 0 /* None */,
     conditions: emptyArray,
@@ -37776,24 +37788,24 @@ function getVersionPathsOfPackageJsonInfo(packageJsonInfo, state) {
   return packageJsonInfo.contents.versionPaths || void 0;
 }
 function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
-  var _a2, _b, _c;
+  var _a2, _b, _c, _d, _e, _f, _g, _h;
   const { host, traceEnabled } = state;
   const packageJsonPath = combinePaths(packageDirectory, "package.json");
   if (onlyRecordFailures) {
-    state.failedLookupLocations.push(packageJsonPath);
+    (_a2 = state.failedLookupLocations) == null ? void 0 : _a2.push(packageJsonPath);
     return void 0;
   }
-  const existing = (_a2 = state.packageJsonInfoCache) == null ? void 0 : _a2.getPackageJsonInfo(packageJsonPath);
+  const existing = (_b = state.packageJsonInfoCache) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
   if (existing !== void 0) {
     if (typeof existing !== "boolean") {
       if (traceEnabled)
         trace(host, Diagnostics.File_0_exists_according_to_earlier_cached_lookups, packageJsonPath);
-      state.affectingLocations.push(packageJsonPath);
+      (_c = state.affectingLocations) == null ? void 0 : _c.push(packageJsonPath);
       return existing.packageDirectory === packageDirectory ? existing : { packageDirectory, contents: existing.contents };
     } else {
       if (existing && traceEnabled)
         trace(host, Diagnostics.File_0_does_not_exist_according_to_earlier_cached_lookups, packageJsonPath);
-      state.failedLookupLocations.push(packageJsonPath);
+      (_d = state.failedLookupLocations) == null ? void 0 : _d.push(packageJsonPath);
       return void 0;
     }
   }
@@ -37804,15 +37816,15 @@ function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
       trace(host, Diagnostics.Found_package_json_at_0, packageJsonPath);
     }
     const result = { packageDirectory, contents: { packageJsonContent, versionPaths: void 0, resolvedEntrypoints: void 0 } };
-    (_b = state.packageJsonInfoCache) == null ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
-    state.affectingLocations.push(packageJsonPath);
+    (_e = state.packageJsonInfoCache) == null ? void 0 : _e.setPackageJsonInfo(packageJsonPath, result);
+    (_f = state.affectingLocations) == null ? void 0 : _f.push(packageJsonPath);
     return result;
   } else {
     if (directoryExists && traceEnabled) {
       trace(host, Diagnostics.File_0_does_not_exist, packageJsonPath);
     }
-    (_c = state.packageJsonInfoCache) == null ? void 0 : _c.setPackageJsonInfo(packageJsonPath, directoryExists);
-    state.failedLookupLocations.push(packageJsonPath);
+    (_g = state.packageJsonInfoCache) == null ? void 0 : _g.setPackageJsonInfo(packageJsonPath, directoryExists);
+    (_h = state.failedLookupLocations) == null ? void 0 : _h.push(packageJsonPath);
   }
 }
 function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
@@ -38633,11 +38645,13 @@ function classicNameResolver(moduleName, containingFile, compilerOptions, host,
           state
         ));
       });
-      if (resolved2) {
+      if (resolved2)
         return resolved2;
-      }
       if (extensions & (1 /* TypeScript */ | 4 /* Declaration */)) {
-        return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
+        let resolved3 = loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
+        if (extensions & 4 /* Declaration */)
+          resolved3 != null ? resolved3 : resolved3 = resolveFromTypeRoot(moduleName, state);
+        return resolved3;
       }
     } else {
       const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
@@ -38651,6 +38665,31 @@ function classicNameResolver(moduleName, containingFile, compilerOptions, host,
     }
   }
 }
+function resolveFromTypeRoot(moduleName, state) {
+  if (!state.compilerOptions.typeRoots)
+    return;
+  for (const typeRoot of state.compilerOptions.typeRoots) {
+    const candidate = combinePaths(typeRoot, moduleName);
+    const directoryExists = directoryProbablyExists(typeRoot, state.host);
+    if (!directoryExists && state.traceEnabled) {
+      trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
+    }
+    const resolvedFromFile = loadModuleFromFile(4 /* Declaration */, candidate, !directoryExists, state);
+    if (resolvedFromFile) {
+      const packageDirectory = parseNodeModuleFromPath(resolvedFromFile.path);
+      const packageInfo = packageDirectory ? getPackageJsonInfo(
+        packageDirectory,
+        /*onlyRecordFailures*/
+        false,
+        state
+      ) : void 0;
+      return toSearchResult(withPackageId(packageInfo, resolvedFromFile));
+    }
+    const resolved = loadNodeModuleFromDirectory(4 /* Declaration */, candidate, !directoryExists, state);
+    if (resolved)
+      return toSearchResult(resolved);
+  }
+}
 function shouldAllowImportingTsExtension(compilerOptions, fromFileName) {
   return !!compilerOptions.allowImportingTsExtensions || fromFileName && isDeclarationFileName(fromFileName);
 }
@@ -47794,7 +47833,7 @@ function createTypeChecker(host) {
           }
         }
         const mayHaveNameCollisions = !(context.flags & 64 /* UseFullyQualifiedType */);
-        const seenNames = mayHaveNameCollisions ? createUnderscoreEscapedMultiMap() : void 0;
+        const seenNames = mayHaveNameCollisions ? createMultiMap() : void 0;
         const result = [];
         let i = 0;
         for (const type of types) {
@@ -51595,7 +51634,11 @@ function createTypeChecker(host) {
       const baseTypeVariable = getBaseTypeVariableOfClass(symbol);
       return baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type;
     } else {
-      return strictNullChecks && symbol.flags & 16777216 /* Optional */ ? getOptionalType(type) : type;
+      return strictNullChecks && symbol.flags & 16777216 /* Optional */ ? getOptionalType(
+        type,
+        /*isProperty*/
+        true
+      ) : type;
     }
   }
   function getTypeOfEnumMember(symbol) {
@@ -60075,7 +60118,7 @@ function createTypeChecker(host) {
               0 /* None */
             );
           }
-        } else if (result2 && isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => !!(getObjectFlags(t) & 262144 /* NonInferrableType */))) {
+        } else if (result2 && isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => t === target2 || !!(getObjectFlags(t) & 262144 /* NonInferrableType */))) {
           result2 &= propertiesRelatedTo(
             source2,
             target2,
@@ -60296,6 +60339,7 @@ function createTypeChecker(host) {
       } else if (targetFlags & 8388608 /* IndexedAccess */) {
         if (sourceFlags & 8388608 /* IndexedAccess */) {
           if (result2 = isRelatedTo(source2.objectType, target2.objectType, 3 /* Both */, reportErrors2)) {
+            instantiateType(source2.objectType, reportUnreliableMapper);
             result2 &= isRelatedTo(source2.indexType, target2.indexType, 3 /* Both */, reportErrors2);
           }
           if (result2) {
@@ -63441,7 +63485,7 @@ function createTypeChecker(host) {
     );
   }
   function isInAmbientOrTypeNode(node) {
-    return !!(node.flags & 16777216 /* Ambient */ || findAncestor(node, (n) => isInterfaceDeclaration(n) || isTypeLiteralNode(n)));
+    return !!(node.flags & 16777216 /* Ambient */ || findAncestor(node, (n) => isInterfaceDeclaration(n) || isTypeAliasDeclaration(n) || isTypeLiteralNode(n)));
   }
   function getFlowCacheKey(node, declaredType, initialType, flowContainer) {
     switch (node.kind) {
@@ -66589,6 +66633,16 @@ function createTypeChecker(host) {
         const symbol = getSymbolOfDeclaration(element);
         return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
       }
+      if (hasDynamicName(element)) {
+        const name = getNameOfDeclaration(element);
+        if (name && isComputedPropertyName(name)) {
+          const exprType = checkExpression(name.expression);
+          const propType = isTypeUsableAsPropertyName(exprType) && getTypeOfPropertyOfContextualType(type, getPropertyNameFromType(exprType));
+          if (propType) {
+            return propType;
+          }
+        }
+      }
       if (element.name) {
         const nameType = getLiteralTypeFromPropertyName(element.name);
         return mapType(
@@ -71362,7 +71416,7 @@ function createTypeChecker(host) {
   }
   function getNonArrayRestType(signature) {
     const restType = getEffectiveRestType(signature);
-    return restType && !isArrayType(restType) && !isTypeAny(restType) && (getReducedType(restType).flags & 131072 /* Never */) === 0 ? restType : void 0;
+    return restType && !isArrayType(restType) && !isTypeAny(restType) ? restType : void 0;
   }
   function getTypeOfFirstParameterOfSignature(signature) {
     return getTypeOfFirstParameterOfSignatureWithFallback(signature, neverType);
@@ -76176,6 +76230,9 @@ function createTypeChecker(host) {
       return;
     }
     if (isBindingPattern(node.name)) {
+      if (isInAmbientOrTypeNode(node)) {
+        return;
+      }
       const needCheckInitializer = hasOnlyExpressionInitializer(node) && node.initializer && node.parent.parent.kind !== 246 /* ForInStatement */;
       const needCheckWidenedType = !some(node.name.elements, not(isOmittedExpression));
       if (needCheckInitializer || needCheckWidenedType) {
@@ -85279,6 +85336,7 @@ function createDefaultValueCheck(flattenContext, value, defaultValue, location)
   );
 }
 function createDestructuringPropertyAccess(flattenContext, value, propertyName) {
+  const { factory: factory2 } = flattenContext.context;
   if (isComputedPropertyName(propertyName)) {
     const argumentExpression = ensureIdentifier(
       flattenContext,
@@ -85290,7 +85348,7 @@ function createDestructuringPropertyAccess(flattenContext, value, propertyName)
     );
     return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
   } else if (isStringOrNumericLiteralLike(propertyName)) {
-    const argumentExpression = factory.cloneNode(propertyName);
+    const argumentExpression = factory2.cloneNode(propertyName);
     return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
   } else {
     const name = flattenContext.context.factory.createIdentifier(idText(propertyName));
@@ -85360,28 +85418,29 @@ function processTaggedTemplateExpression(context, node, visitor, currentSourceFi
   if (level === 0 /* LiftRestriction */ && !hasInvalidEscape(template)) {
     return visitEachChild(node, visitor, context);
   }
+  const { factory: factory2 } = context;
   if (isNoSubstitutionTemplateLiteral(template)) {
-    cookedStrings.push(createTemplateCooked(template));
-    rawStrings.push(getRawLiteral(template, currentSourceFile));
+    cookedStrings.push(createTemplateCooked(factory2, template));
+    rawStrings.push(getRawLiteral(factory2, template, currentSourceFile));
   } else {
-    cookedStrings.push(createTemplateCooked(template.head));
-    rawStrings.push(getRawLiteral(template.head, currentSourceFile));
+    cookedStrings.push(createTemplateCooked(factory2, template.head));
+    rawStrings.push(getRawLiteral(factory2, template.head, currentSourceFile));
     for (const templateSpan of template.templateSpans) {
-      cookedStrings.push(createTemplateCooked(templateSpan.literal));
-      rawStrings.push(getRawLiteral(templateSpan.literal, currentSourceFile));
+      cookedStrings.push(createTemplateCooked(factory2, templateSpan.literal));
+      rawStrings.push(getRawLiteral(factory2, templateSpan.literal, currentSourceFile));
       templateArguments.push(Debug.checkDefined(visitNode(templateSpan.expression, visitor, isExpression)));
     }
   }
   const helperCall = context.getEmitHelperFactory().createTemplateObjectHelper(
-    factory.createArrayLiteralExpression(cookedStrings),
-    factory.createArrayLiteralExpression(rawStrings)
+    factory2.createArrayLiteralExpression(cookedStrings),
+    factory2.createArrayLiteralExpression(rawStrings)
   );
   if (isExternalModule(currentSourceFile)) {
-    const tempVar = factory.createUniqueName("templateObject");
+    const tempVar = factory2.createUniqueName("templateObject");
     recordTaggedTemplateString(tempVar);
-    templateArguments[0] = factory.createLogicalOr(
+    templateArguments[0] = factory2.createLogicalOr(
       tempVar,
-      factory.createAssignment(
+      factory2.createAssignment(
         tempVar,
         helperCall
       )
@@ -85389,17 +85448,17 @@ function processTaggedTemplateExpression(context, node, visitor, currentSourceFi
   } else {
     templateArguments[0] = helperCall;
   }
-  return factory.createCallExpression(
+  return factory2.createCallExpression(
     tag,
     /*typeArguments*/
     void 0,
     templateArguments
   );
 }
-function createTemplateCooked(template) {
-  return template.templateFlags ? factory.createVoidZero() : factory.createStringLiteral(template.text);
+function createTemplateCooked(factory2, template) {
+  return template.templateFlags ? factory2.createVoidZero() : factory2.createStringLiteral(template.text);
 }
-function getRawLiteral(node, currentSourceFile) {
+function getRawLiteral(factory2, node, currentSourceFile) {
   let text = node.rawText;
   if (text === void 0) {
     Debug.assertIsDefined(
@@ -85411,7 +85470,7 @@ function getRawLiteral(node, currentSourceFile) {
     text = text.substring(1, text.length - (isLast ? 1 : 2));
   }
   text = text.replace(/\r\n?/g, "\n");
-  return setTextRange(factory.createStringLiteral(text), node);
+  return setTextRange(factory2.createStringLiteral(text), node);
 }
 
 // src/compiler/transformers/ts.ts
@@ -88867,12 +88926,14 @@ function transformClassFields(context) {
         if (privateIdentifierInfo.kind === "f" /* Field */) {
           if (!privateIdentifierInfo.isStatic) {
             return createPrivateInstanceFieldInitializer(
+              factory2,
               receiver,
               visitNode(property.initializer, initializerVisitor, isExpression),
               privateIdentifierInfo.brandCheckIdentifier
             );
           } else {
             return createPrivateStaticFieldInitializer(
+              factory2,
               privateIdentifierInfo.variableName,
               visitNode(property.initializer, initializerVisitor, isExpression)
             );
@@ -88954,7 +89015,7 @@ function transformClassFields(context) {
     Debug.assert(weakSetName, "weakSetName should be set in private identifier environment");
     statements.push(
       factory2.createExpressionStatement(
-        createPrivateInstanceMethodInitializer(receiver, weakSetName)
+        createPrivateInstanceMethodInitializer(factory2, receiver, weakSetName)
       )
     );
   }
@@ -89407,25 +89468,25 @@ function transformClassFields(context) {
     return void 0;
   }
 }
-function createPrivateStaticFieldInitializer(variableName, initializer) {
-  return factory.createAssignment(
+function createPrivateStaticFieldInitializer(factory2, variableName, initializer) {
+  return factory2.createAssignment(
     variableName,
-    factory.createObjectLiteralExpression([
-      factory.createPropertyAssignment("value", initializer || factory.createVoidZero())
+    factory2.createObjectLiteralExpression([
+      factory2.createPropertyAssignment("value", initializer || factory2.createVoidZero())
     ])
   );
 }
-function createPrivateInstanceFieldInitializer(receiver, initializer, weakMapName) {
-  return factory.createCallExpression(
-    factory.createPropertyAccessExpression(weakMapName, "set"),
+function createPrivateInstanceFieldInitializer(factory2, receiver, initializer, weakMapName) {
+  return factory2.createCallExpression(
+    factory2.createPropertyAccessExpression(weakMapName, "set"),
     /*typeArguments*/
     void 0,
-    [receiver, initializer || factory.createVoidZero()]
+    [receiver, initializer || factory2.createVoidZero()]
   );
 }
-function createPrivateInstanceMethodInitializer(receiver, weakSetName) {
-  return factory.createCallExpression(
-    factory.createPropertyAccessExpression(weakSetName, "add"),
+function createPrivateInstanceMethodInitializer(factory2, receiver, weakSetName) {
+  return factory2.createCallExpression(
+    factory2.createPropertyAccessExpression(weakSetName, "add"),
     /*typeArguments*/
     void 0,
     [receiver]
@@ -89441,6 +89502,7 @@ function isPrivateIdentifierInExpression(node) {
 // src/compiler/transformers/typeSerializer.ts
 function createRuntimeTypeSerializer(context) {
   const {
+    factory: factory2,
     hoistVariableDeclaration
   } = context;
   const resolver = context.getEmitResolver();
@@ -89480,9 +89542,9 @@ function createRuntimeTypeSerializer(context) {
       case 260 /* ClassDeclaration */:
       case 228 /* ClassExpression */:
       case 171 /* MethodDeclaration */:
-        return factory.createIdentifier("Function");
+        return factory2.createIdentifier("Function");
       default:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
     }
   }
   function serializeParameterTypesOfNode(node, container) {
@@ -89503,7 +89565,7 @@ function createRuntimeTypeSerializer(context) {
         }
       }
     }
-    return factory.createArrayLiteralExpression(expressions);
+    return factory2.createArrayLiteralExpression(expressions);
   }
   function getParametersOfDecoratedDeclaration(node, container) {
     if (container && node.kind === 174 /* GetAccessor */) {
@@ -89518,39 +89580,39 @@ function createRuntimeTypeSerializer(context) {
     if (isFunctionLike(node) && node.type) {
       return serializeTypeNode(node.type);
     } else if (isAsyncFunction(node)) {
-      return factory.createIdentifier("Promise");
+      return factory2.createIdentifier("Promise");
     }
-    return factory.createVoidZero();
+    return factory2.createVoidZero();
   }
   function serializeTypeNode(node) {
     if (node === void 0) {
-      return factory.createIdentifier("Object");
+      return factory2.createIdentifier("Object");
     }
     node = skipTypeParentheses(node);
     switch (node.kind) {
       case 114 /* VoidKeyword */:
       case 155 /* UndefinedKeyword */:
       case 144 /* NeverKeyword */:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
       case 181 /* FunctionType */:
       case 182 /* ConstructorType */:
-        return factory.createIdentifier("Function");
+        return factory2.createIdentifier("Function");
       case 185 /* ArrayType */:
       case 186 /* TupleType */:
-        return factory.createIdentifier("Array");
+        return factory2.createIdentifier("Array");
       case 179 /* TypePredicate */:
-        return node.assertsModifier ? factory.createVoidZero() : factory.createIdentifier("Boolean");
+        return node.assertsModifier ? factory2.createVoidZero() : factory2.createIdentifier("Boolean");
       case 134 /* BooleanKeyword */:
-        return factory.createIdentifier("Boolean");
+        return factory2.createIdentifier("Boolean");
       case 200 /* TemplateLiteralType */:
       case 152 /* StringKeyword */:
-        return factory.createIdentifier("String");
+        return factory2.createIdentifier("String");
       case 149 /* ObjectKeyword */:
-        return factory.createIdentifier("Object");
+        return factory2.createIdentifier("Object");
       case 198 /* LiteralType */:
         return serializeLiteralOfLiteralTypeNode(node.literal);
       case 148 /* NumberKeyword */:
-        return factory.createIdentifier("Number");
+        return factory2.createIdentifier("Number");
       case 160 /* BigIntKeyword */:
         return getGlobalConstructor("BigInt", 7 /* ES2020 */);
       case 153 /* SymbolKeyword */:
@@ -89602,13 +89664,13 @@ function createRuntimeTypeSerializer(context) {
       default:
         return Debug.failBadSyntaxKind(node);
     }
-    return factory.createIdentifier("Object");
+    return factory2.createIdentifier("Object");
   }
   function serializeLiteralOfLiteralTypeNode(node) {
     switch (node.kind) {
       case 10 /* StringLiteral */:
       case 14 /* NoSubstitutionTemplateLiteral */:
-        return factory.createIdentifier("String");
+        return factory2.createIdentifier("String");
       case 221 /* PrefixUnaryExpression */: {
         const operand = node.operand;
         switch (operand.kind) {
@@ -89620,14 +89682,14 @@ function createRuntimeTypeSerializer(context) {
         }
       }
       case 8 /* NumericLiteral */:
-        return factory.createIdentifier("Number");
+        return factory2.createIdentifier("Number");
       case 9 /* BigIntLiteral */:
         return getGlobalConstructor("BigInt", 7 /* ES2020 */);
       case 110 /* TrueKeyword */:
       case 95 /* FalseKeyword */:
-        return factory.createIdentifier("Boolean");
+        return factory2.createIdentifier("Boolean");
       case 104 /* NullKeyword */:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
       default:
         return Debug.failBadSyntaxKind(node);
     }
@@ -89638,16 +89700,16 @@ function createRuntimeTypeSerializer(context) {
       typeNode = skipTypeParentheses(typeNode);
       if (typeNode.kind === 144 /* NeverKeyword */) {
         if (isIntersection)
-          return factory.createVoidZero();
+          return factory2.createVoidZero();
         continue;
       }
       if (typeNode.kind === 157 /* UnknownKeyword */) {
         if (!isIntersection)
-          return factory.createIdentifier("Object");
+          return factory2.createIdentifier("Object");
         continue;
       }
       if (typeNode.kind === 131 /* AnyKeyword */) {
-        return factory.createIdentifier("Object");
+        return factory2.createIdentifier("Object");
       }
       if (!strictNullChecks && (isLiteralTypeNode(typeNode) && typeNode.literal.kind === 104 /* NullKeyword */ || typeNode.kind === 155 /* UndefinedKeyword */)) {
         continue;
@@ -89658,13 +89720,13 @@ function createRuntimeTypeSerializer(context) {
       }
       if (serializedType) {
         if (!equateSerializedTypeNodes(serializedType, serializedConstituent)) {
-          return factory.createIdentifier("Object");
+          return factory2.createIdentifier("Object");
         }
       } else {
         serializedType = serializedConstituent;
       }
     }
-    return serializedType != null ? serializedType : factory.createVoidZero();
+    return serializedType != null ? serializedType : factory2.createVoidZero();
   }
   function equateSerializedTypeNodes(left, right) {
     return (
@@ -89698,48 +89760,48 @@ function createRuntimeTypeSerializer(context) {
     switch (kind) {
       case 0 /* Unknown */:
         if (findAncestor(node, (n) => n.parent && isConditionalTypeNode(n.parent) && (n.parent.trueType === n || n.parent.falseType === n))) {
-          return factory.createIdentifier("Object");
+          return factory2.createIdentifier("Object");
         }
         const serialized = serializeEntityNameAsExpressionFallback(node.typeName);
-        const temp = factory.createTempVariable(hoistVariableDeclaration);
-        return factory.createConditionalExpression(
-          factory.createTypeCheck(factory.createAssignment(temp, serialized), "function"),
+        const temp = factory2.createTempVariable(hoistVariableDeclaration);
+        return factory2.createConditionalExpression(
+          factory2.createTypeCheck(factory2.createAssignment(temp, serialized), "function"),
           /*questionToken*/
           void 0,
           temp,
           /*colonToken*/
           void 0,
-          factory.createIdentifier("Object")
+          factory2.createIdentifier("Object")
         );
       case 1 /* TypeWithConstructSignatureAndValue */:
         return serializeEntityNameAsExpression(node.typeName);
       case 2 /* VoidNullableOrNeverType */:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
       case 4 /* BigIntLikeType */:
         return getGlobalConstructor("BigInt", 7 /* ES2020 */);
       case 6 /* BooleanType */:
-        return factory.createIdentifier("Boolean");
+        return factory2.createIdentifier("Boolean");
       case 3 /* NumberLikeType */:
-        return factory.createIdentifier("Number");
+        return factory2.createIdentifier("Number");
       case 5 /* StringLikeType */:
-        return factory.createIdentifier("String");
+        return factory2.createIdentifier("String");
       case 7 /* ArrayLikeType */:
-        return factory.createIdentifier("Array");
+        return factory2.createIdentifier("Array");
       case 8 /* ESSymbolType */:
         return getGlobalConstructor("Symbol", 2 /* ES2015 */);
       case 10 /* TypeWithCallSignature */:
-        return factory.createIdentifier("Function");
+        return factory2.createIdentifier("Function");
       case 9 /* Promise */:
-        return factory.createIdentifier("Promise");
+        return factory2.createIdentifier("Promise");
       case 11 /* ObjectType */:
-        return factory.createIdentifier("Object");
+        return factory2.createIdentifier("Object");
       default:
         return Debug.assertNever(kind);
     }
   }
   function createCheckedValue(left, right) {
-    return factory.createLogicalAnd(
-      factory.createStrictInequality(factory.createTypeOfExpression(left), factory.createStringLiteral("undefined")),
+    return factory2.createLogicalAnd(
+      factory2.createStrictInequality(factory2.createTypeOfExpression(left), factory2.createStringLiteral("undefined")),
       right
     );
   }
@@ -89752,13 +89814,13 @@ function createRuntimeTypeSerializer(context) {
       return createCheckedValue(serializeEntityNameAsExpression(node.left), serializeEntityNameAsExpression(node));
     }
     const left = serializeEntityNameAsExpressionFallback(node.left);
-    const temp = factory.createTempVariable(hoistVariableDeclaration);
-    return factory.createLogicalAnd(
-      factory.createLogicalAnd(
+    const temp = factory2.createTempVariable(hoistVariableDeclaration);
+    return factory2.createLogicalAnd(
+      factory2.createLogicalAnd(
         left.left,
-        factory.createStrictInequality(factory.createAssignment(temp, left.right), factory.createVoidZero())
+        factory2.createStrictInequality(factory2.createAssignment(temp, left.right), factory2.createVoidZero())
       ),
-      factory.createPropertyAccessExpression(temp, node.right)
+      factory2.createPropertyAccessExpression(temp, node.right)
     );
   }
   function serializeEntityNameAsExpression(node) {
@@ -89773,21 +89835,21 @@ function createRuntimeTypeSerializer(context) {
     }
   }
   function serializeQualifiedNameAsExpression(node) {
-    return factory.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right);
+    return factory2.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right);
   }
   function getGlobalConstructorWithFallback(name) {
-    return factory.createConditionalExpression(
-      factory.createTypeCheck(factory.createIdentifier(name), "function"),
+    return factory2.createConditionalExpression(
+      factory2.createTypeCheck(factory2.createIdentifier(name), "function"),
       /*questionToken*/
       void 0,
-      factory.createIdentifier(name),
+      factory2.createIdentifier(name),
       /*colonToken*/
       void 0,
-      factory.createIdentifier("Object")
+      factory2.createIdentifier("Object")
     );
   }
   function getGlobalConstructor(name, minLanguageVersion) {
-    return languageVersion < minLanguageVersion ? getGlobalConstructorWithFallback(name) : factory.createIdentifier(name);
+    return languageVersion < minLanguageVersion ? getGlobalConstructorWithFallback(name) : factory2.createIdentifier(name);
   }
 }
 
@@ -104618,7 +104680,7 @@ function transformDeclarations(context) {
     }
     const newParam = factory2.updateParameterDeclaration(
       p,
-      maskModifiers(p, modifierMask),
+      maskModifiers(factory2, p, modifierMask),
       p.dotDotDotToken,
       filterBindingPatternInitializersAndRenamings(p.name),
       resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(57 /* QuestionToken */) : void 0,
@@ -105732,8 +105794,8 @@ function isAlwaysType(node) {
   }
   return false;
 }
-function maskModifiers(node, modifierMask, modifierAdditions) {
-  return factory.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
+function maskModifiers(factory2, node, modifierMask, modifierAdditions) {
+  return factory2.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
 }
 function maskModifierFlags(node, modifierMask = 258047 /* All */ ^ 4 /* Public */, modifierAdditions = 0 /* None */) {
   let flags = getEffectiveModifierFlags(node) & modifierMask | modifierAdditions;
@@ -118522,7 +118584,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     return toWatch && directoryWatchesOfFailedLookups.has(toWatch.dirPath) ? toWatch.dirPath : void 0;
   }
   function createTypeRootsWatch(typeRootPath, typeRoot) {
-    return resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
+    return canWatchTypeRootPath(typeRootPath) ? resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
       const fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory);
       if (cachedDirectoryStructureHost) {
         cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
@@ -118533,7 +118595,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       if (dirPath) {
         scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
       }
-    }, 1 /* Recursive */);
+    }, 1 /* Recursive */) : noopFileWatcher;
   }
   function updateTypeRootsWatch() {
     const options = resolutionHost.getCompilationSettings();
@@ -118541,7 +118603,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       closeTypeRootsWatch();
       return;
     }
-    const typeRoots = getEffectiveTypeRoots(options, { directoryExists: directoryExistsForTypeRootWatch, getCurrentDirectory });
+    const typeRoots = getEffectiveTypeRoots(options, { getCurrentDirectory });
     if (typeRoots) {
       mutateMap(
         typeRootsWatches,
@@ -118555,7 +118617,9 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       closeTypeRootsWatch();
     }
   }
-  function directoryExistsForTypeRootWatch(nodeTypesDirectory) {
+  function canWatchTypeRootPath(nodeTypesDirectory) {
+    if (resolutionHost.getCompilationSettings().typeRoots)
+      return true;
     const dir = getDirectoryPath(getDirectoryPath(nodeTypesDirectory));
     const dirPath = resolutionHost.toPath(dir);
     return dirPath === rootPath || canWatchDirectoryOrFile(dirPath);