@typescript-deploys/pr-build 5.4.0-pr-56640-15 → 5.4.0-pr-56736-6

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20231207`;
+var version = `${versionMajorMinor}.0-insiders.20231211`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -7794,7 +7794,9 @@ var Diagnostics = {
   Compiler_option_0_cannot_be_given_an_empty_string: diag(18051, 1 /* Error */, "Compiler_option_0_cannot_be_given_an_empty_string_18051", "Compiler option '{0}' cannot be given an empty string."),
   Non_abstract_class_0_does_not_implement_all_abstract_members_of_1: diag(18052, 1 /* Error */, "Non_abstract_class_0_does_not_implement_all_abstract_members_of_1_18052", "Non-abstract class '{0}' does not implement all abstract members of '{1}'"),
   Its_type_0_is_not_a_valid_JSX_element_type: diag(18053, 1 /* Error */, "Its_type_0_is_not_a_valid_JSX_element_type_18053", "Its type '{0}' is not a valid JSX element type."),
-  await_using_statements_cannot_be_used_inside_a_class_static_block: diag(18054, 1 /* Error */, "await_using_statements_cannot_be_used_inside_a_class_static_block_18054", "'await using' statements cannot be used inside a class static block.")
+  await_using_statements_cannot_be_used_inside_a_class_static_block: diag(18054, 1 /* Error */, "await_using_statements_cannot_be_used_inside_a_class_static_block_18054", "'await using' statements cannot be used inside a class static block."),
+  A_member_initializer_in_a_enum_declaration_for_a_string_value_must_be_a_string_literal_when_isolatedModules_is_enabled: diag(18055, 1 /* Error */, "A_member_initializer_in_a_enum_declaration_for_a_string_value_must_be_a_string_literal_when_isolated_18055", "A member initializer in a enum declaration for a string value must be a string literal when 'isolatedModules' is enabled."),
+  Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled: diag(18056, 1 /* Error */, "Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is__18056", "Enum member following a non-literal numeric member must have an initializer when 'isolatedModules' is enabled.")
 };
 
 // src/compiler/scanner.ts
@@ -16362,38 +16364,231 @@ function getSetExternalModuleIndicator(options) {
       return callback;
   }
 }
-function getEmitScriptTarget(compilerOptions) {
-  return compilerOptions.target ?? (compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 1 /* ES5 */);
-}
-function getEmitModuleKind(compilerOptions) {
-  return typeof compilerOptions.module === "number" ? compilerOptions.module : getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
+function createComputedCompilerOptions(options) {
+  return options;
 }
+var computedOptions = createComputedCompilerOptions({
+  target: {
+    dependencies: ["module"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.target ?? (compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 1 /* ES5 */);
+    }
+  },
+  module: {
+    dependencies: ["target"],
+    computeValue: (compilerOptions) => {
+      return typeof compilerOptions.module === "number" ? compilerOptions.module : computedOptions.target.computeValue(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
+    }
+  },
+  moduleResolution: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      let moduleResolution = compilerOptions.moduleResolution;
+      if (moduleResolution === void 0) {
+        switch (computedOptions.module.computeValue(compilerOptions)) {
+          case 1 /* CommonJS */:
+            moduleResolution = 2 /* Node10 */;
+            break;
+          case 100 /* Node16 */:
+            moduleResolution = 3 /* Node16 */;
+            break;
+          case 199 /* NodeNext */:
+            moduleResolution = 99 /* NodeNext */;
+            break;
+          default:
+            moduleResolution = 1 /* Classic */;
+            break;
+        }
+      }
+      return moduleResolution;
+    }
+  },
+  moduleDetection: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.moduleDetection || (computedOptions.module.computeValue(compilerOptions) === 100 /* Node16 */ || computedOptions.module.computeValue(compilerOptions) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
+    }
+  },
+  isolatedModules: {
+    dependencies: ["verbatimModuleSyntax"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.isolatedModules || compilerOptions.verbatimModuleSyntax);
+    }
+  },
+  esModuleInterop: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.esModuleInterop !== void 0) {
+        return compilerOptions.esModuleInterop;
+      }
+      switch (computedOptions.module.computeValue(compilerOptions)) {
+        case 100 /* Node16 */:
+        case 199 /* NodeNext */:
+          return true;
+      }
+      return false;
+    }
+  },
+  allowSyntheticDefaultImports: {
+    dependencies: ["module", "target", "moduleResolution"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.allowSyntheticDefaultImports !== void 0) {
+        return compilerOptions.allowSyntheticDefaultImports;
+      }
+      return computedOptions.esModuleInterop.computeValue(compilerOptions) || computedOptions.module.computeValue(compilerOptions) === 4 /* System */ || computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */;
+    }
+  },
+  resolvePackageJsonExports: {
+    dependencies: ["moduleResolution"],
+    computeValue: (compilerOptions) => {
+      const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions);
+      if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
+        return false;
+      }
+      if (compilerOptions.resolvePackageJsonExports !== void 0) {
+        return compilerOptions.resolvePackageJsonExports;
+      }
+      switch (moduleResolution) {
+        case 3 /* Node16 */:
+        case 99 /* NodeNext */:
+        case 100 /* Bundler */:
+          return true;
+      }
+      return false;
+    }
+  },
+  resolvePackageJsonImports: {
+    dependencies: ["moduleResolution", "resolvePackageJsonExports"],
+    computeValue: (compilerOptions) => {
+      const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions);
+      if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
+        return false;
+      }
+      if (compilerOptions.resolvePackageJsonExports !== void 0) {
+        return compilerOptions.resolvePackageJsonExports;
+      }
+      switch (moduleResolution) {
+        case 3 /* Node16 */:
+        case 99 /* NodeNext */:
+        case 100 /* Bundler */:
+          return true;
+      }
+      return false;
+    }
+  },
+  resolveJsonModule: {
+    dependencies: ["moduleResolution", "module", "target"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.resolveJsonModule !== void 0) {
+        return compilerOptions.resolveJsonModule;
+      }
+      return computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */;
+    }
+  },
+  declaration: {
+    dependencies: ["composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.declaration || compilerOptions.composite);
+    }
+  },
+  preserveConstEnums: {
+    dependencies: ["isolatedModules", "verbatimModuleSyntax"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.preserveConstEnums || computedOptions.isolatedModules.computeValue(compilerOptions));
+    }
+  },
+  incremental: {
+    dependencies: ["composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.incremental || compilerOptions.composite);
+    }
+  },
+  declarationMap: {
+    dependencies: ["declaration", "composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.declarationMap && computedOptions.declaration.computeValue(compilerOptions));
+    }
+  },
+  allowJs: {
+    dependencies: ["checkJs"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
+    }
+  },
+  useDefineForClassFields: {
+    dependencies: ["target", "module"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.useDefineForClassFields === void 0 ? computedOptions.target.computeValue(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
+    }
+  },
+  noImplicitAny: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "noImplicitAny");
+    }
+  },
+  noImplicitThis: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "noImplicitThis");
+    }
+  },
+  strictNullChecks: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictNullChecks");
+    }
+  },
+  strictFunctionTypes: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictFunctionTypes");
+    }
+  },
+  strictBindCallApply: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictBindCallApply");
+    }
+  },
+  strictPropertyInitialization: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
+    }
+  },
+  alwaysStrict: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "alwaysStrict");
+    }
+  },
+  useUnknownInCatchVariables: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
+    }
+  }
+});
+var getEmitScriptTarget = computedOptions.target.computeValue;
+var getEmitModuleKind = computedOptions.module.computeValue;
+var getEmitModuleResolutionKind = computedOptions.moduleResolution.computeValue;
+var getEmitModuleDetectionKind = computedOptions.moduleDetection.computeValue;
+var getIsolatedModules = computedOptions.isolatedModules.computeValue;
+var getESModuleInterop = computedOptions.esModuleInterop.computeValue;
+var getAllowSyntheticDefaultImports = computedOptions.allowSyntheticDefaultImports.computeValue;
+var getResolvePackageJsonExports = computedOptions.resolvePackageJsonExports.computeValue;
+var getResolvePackageJsonImports = computedOptions.resolvePackageJsonImports.computeValue;
+var getResolveJsonModule = computedOptions.resolveJsonModule.computeValue;
+var getEmitDeclarations = computedOptions.declaration.computeValue;
+var shouldPreserveConstEnums = computedOptions.preserveConstEnums.computeValue;
+var isIncrementalCompilation = computedOptions.incremental.computeValue;
+var getAreDeclarationMapsEnabled = computedOptions.declarationMap.computeValue;
+var getAllowJSCompilerOption = computedOptions.allowJs.computeValue;
+var getUseDefineForClassFields = computedOptions.useDefineForClassFields.computeValue;
 function emitModuleKindIsNonNodeESM(moduleKind) {
   return moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */;
 }
-function getEmitModuleResolutionKind(compilerOptions) {
-  let moduleResolution = compilerOptions.moduleResolution;
-  if (moduleResolution === void 0) {
-    switch (getEmitModuleKind(compilerOptions)) {
-      case 1 /* CommonJS */:
-        moduleResolution = 2 /* Node10 */;
-        break;
-      case 100 /* Node16 */:
-        moduleResolution = 3 /* Node16 */;
-        break;
-      case 199 /* NodeNext */:
-        moduleResolution = 99 /* NodeNext */;
-        break;
-      default:
-        moduleResolution = 1 /* Classic */;
-        break;
-    }
-  }
-  return moduleResolution;
-}
-function getEmitModuleDetectionKind(options) {
-  return options.moduleDetection || (getEmitModuleKind(options) === 100 /* Node16 */ || getEmitModuleKind(options) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
-}
 function hasJsonModuleEmitEnabled(options) {
   switch (getEmitModuleKind(options)) {
     case 1 /* CommonJS */:
@@ -16409,81 +16604,21 @@ function hasJsonModuleEmitEnabled(options) {
       return false;
   }
 }
-function getIsolatedModules(options) {
-  return !!(options.isolatedModules || options.verbatimModuleSyntax);
-}
 function unreachableCodeIsError(options) {
   return options.allowUnreachableCode === false;
 }
 function unusedLabelIsError(options) {
   return options.allowUnusedLabels === false;
 }
-function getAreDeclarationMapsEnabled(options) {
-  return !!(getEmitDeclarations(options) && options.declarationMap);
-}
-function getESModuleInterop(compilerOptions) {
-  if (compilerOptions.esModuleInterop !== void 0) {
-    return compilerOptions.esModuleInterop;
-  }
-  switch (getEmitModuleKind(compilerOptions)) {
-    case 100 /* Node16 */:
-    case 199 /* NodeNext */:
-      return true;
-  }
-  return void 0;
-}
-function getAllowSyntheticDefaultImports(compilerOptions) {
-  if (compilerOptions.allowSyntheticDefaultImports !== void 0) {
-    return compilerOptions.allowSyntheticDefaultImports;
-  }
-  return getESModuleInterop(compilerOptions) || getEmitModuleKind(compilerOptions) === 4 /* System */ || getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */;
-}
 function moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution) {
   return moduleResolution >= 3 /* Node16 */ && moduleResolution <= 99 /* NodeNext */ || moduleResolution === 100 /* Bundler */;
 }
 function shouldResolveJsRequire(compilerOptions) {
   return !!compilerOptions.noDtsResolution || getEmitModuleResolutionKind(compilerOptions) !== 100 /* Bundler */;
 }
-function getResolvePackageJsonExports(compilerOptions) {
-  const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
-  if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
-    return false;
-  }
-  if (compilerOptions.resolvePackageJsonExports !== void 0) {
-    return compilerOptions.resolvePackageJsonExports;
-  }
-  switch (moduleResolution) {
-    case 3 /* Node16 */:
-    case 99 /* NodeNext */:
-    case 100 /* Bundler */:
-      return true;
-  }
-  return false;
-}
-function getResolveJsonModule(compilerOptions) {
-  if (compilerOptions.resolveJsonModule !== void 0) {
-    return compilerOptions.resolveJsonModule;
-  }
-  return getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */;
-}
-function getEmitDeclarations(compilerOptions) {
-  return !!(compilerOptions.declaration || compilerOptions.composite);
-}
-function shouldPreserveConstEnums(compilerOptions) {
-  return !!(compilerOptions.preserveConstEnums || getIsolatedModules(compilerOptions));
-}
-function isIncrementalCompilation(options) {
-  return !!(options.incremental || options.composite);
-}
 function getStrictOptionValue(compilerOptions, flag) {
   return compilerOptions[flag] === void 0 ? !!compilerOptions.strict : !!compilerOptions[flag];
 }
-function getAllowJSCompilerOption(compilerOptions) {
-  return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
-}
-function getUseDefineForClassFields(compilerOptions) {
-  return compilerOptions.useDefineForClassFields === void 0 ? getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
-}
 function getEmitStandardClassFields(compilerOptions) {
   return compilerOptions.useDefineForClassFields !== false && getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */;
 }
@@ -18839,8 +18974,10 @@ function createNodeFactory(flags, baseFactory2) {
     return update(updated, original);
   }
   function createNumericLiteral(value, numericLiteralFlags = 0 /* None */) {
+    const text = typeof value === "number" ? value + "" : value;
+    Debug.assert(text.charCodeAt(0) !== 45 /* minus */, "Negative numbers should be created in combination with createPrefixUnaryExpression");
     const node = createBaseDeclaration(9 /* NumericLiteral */);
-    node.text = typeof value === "number" ? value + "" : value;
+    node.text = text;
     node.numericLiteralFlags = numericLiteralFlags;
     if (numericLiteralFlags & 384 /* BinaryOrOctalSpecifier */)
       node.transformFlags |= 1024 /* ContainsES2015 */;
@@ -35893,7 +36030,8 @@ function convertToTSConfig(configParseResult, configFileName, host) {
     ),
     (f) => getRelativePathFromFile(getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName)
   );
-  const optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames });
+  const pathOptions = { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames };
+  const optionMap = serializeCompilerOptions(configParseResult.options, pathOptions);
   const watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
   const config = {
     compilerOptions: {
@@ -35918,6 +36056,18 @@ function convertToTSConfig(configParseResult, configFileName, host) {
     } : {},
     compileOnSave: !!configParseResult.compileOnSave ? true : void 0
   };
+  const providedKeys = new Set(optionMap.keys());
+  const impliedCompilerOptions = {};
+  for (const option in computedOptions) {
+    if (!providedKeys.has(option) && some(computedOptions[option].dependencies, (dep) => providedKeys.has(dep))) {
+      const implied = computedOptions[option].computeValue(configParseResult.options);
+      const defaultValue = computedOptions[option].computeValue({});
+      if (implied !== defaultValue) {
+        impliedCompilerOptions[option] = computedOptions[option].computeValue(configParseResult.options);
+      }
+    }
+  }
+  assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
   return config;
 }
 function optionMapToObject(optionMap) {
@@ -57112,7 +57262,7 @@ function createTypeChecker(host) {
   function removeConstrainedTypeVariables(types) {
     const typeVariables = [];
     for (const type of types) {
-      if (getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
+      if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
         const index = type.types[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
         pushIfUnique(typeVariables, type.types[index]);
       }
@@ -57120,7 +57270,7 @@ function createTypeChecker(host) {
     for (const typeVariable of typeVariables) {
       const primitives = [];
       for (const type of types) {
-        if (getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
+        if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
           const index = type.types[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
           if (type.types[index] === typeVariable) {
             insertType(primitives, type.types[1 - index]);
@@ -57133,7 +57283,7 @@ function createTypeChecker(host) {
         while (i > 0) {
           i--;
           const type = types[i];
-          if (getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
+          if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
             const index = type.types[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
             if (type.types[index] === typeVariable && containsType(primitives, type.types[1 - index])) {
               orderedRemoveItemAt(types, i);
@@ -58301,7 +58451,9 @@ function createTypeChecker(host) {
       if (checkType === wildcardType || extendsType === wildcardType) {
         return wildcardType;
       }
-      const checkTuples = isSimpleTupleType(root.node.checkType) && isSimpleTupleType(root.node.extendsType) && length(root.node.checkType.elements) === length(root.node.extendsType.elements);
+      const checkTypeNode = skipTypeParentheses(root.node.checkType);
+      const extendsTypeNode = skipTypeParentheses(root.node.extendsType);
+      const checkTuples = isSimpleTupleType(checkTypeNode) && isSimpleTupleType(extendsTypeNode) && length(checkTypeNode.elements) === length(extendsTypeNode.elements);
       const checkTypeDeferred = isDeferredType(checkType, checkTuples);
       let combinedMapper;
       if (root.inferTypeParameters) {
@@ -64305,16 +64457,6 @@ function createTypeChecker(host) {
       } else if (target.flags & 134217728 /* TemplateLiteral */) {
         inferToTemplateLiteralType(source, target);
       } else {
-        if (isGenericMappedType(source) && isGenericMappedType(target)) {
-          invokeOnce(source, target, (source2, target2) => {
-            inferFromTypes(getConstraintTypeFromMappedType(source2), getConstraintTypeFromMappedType(target2));
-            inferFromTypes(getTemplateTypeFromMappedType(source2), getTemplateTypeFromMappedType(target2));
-            const sourceNameType = getNameTypeFromMappedType(source2);
-            const targetNameType = getNameTypeFromMappedType(target2);
-            if (sourceNameType && targetNameType)
-              inferFromTypes(sourceNameType, targetNameType);
-          });
-        }
         source = getReducedType(source);
         if (!(priority & 512 /* NoConstraints */ && source.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */))) {
           const apparentSource = getApparentType(source);
@@ -75738,7 +75880,7 @@ function createTypeChecker(host) {
       const modifiers = getTypeParameterModifiers(typeParameter) & (8192 /* In */ | 16384 /* Out */);
       if (modifiers) {
         const symbol = getSymbolOfDeclaration(node.parent);
-        if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
+        if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (4 /* Reference */ | 16 /* Anonymous */ | 32 /* Mapped */))) {
           error(node, Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types);
         } else if (modifiers === 8192 /* In */ || modifiers === 16384 /* Out */) {
           (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.CheckTypes, "checkTypeParameterDeferred", { parent: getTypeId(getDeclaredTypeOfSymbol(symbol)), id: getTypeId(typeParameter) });
@@ -80046,14 +80188,16 @@ function createTypeChecker(host) {
     if (!(nodeLinks2.flags & 1024 /* EnumValuesComputed */)) {
       nodeLinks2.flags |= 1024 /* EnumValuesComputed */;
       let autoValue = 0;
+      let previous;
       for (const member of node.members) {
-        const value = computeMemberValue(member, autoValue);
+        const value = computeMemberValue(member, autoValue, previous);
         getNodeLinks(member).enumMemberValue = value;
         autoValue = typeof value === "number" ? value + 1 : void 0;
+        previous = member;
       }
     }
   }
-  function computeMemberValue(member, autoValue) {
+  function computeMemberValue(member, autoValue, previous) {
     if (isComputedNonLiteralName(member.name)) {
       error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
     } else {
@@ -80068,11 +80212,17 @@ function createTypeChecker(host) {
     if (member.parent.flags & 33554432 /* Ambient */ && !isEnumConst(member.parent)) {
       return void 0;
     }
-    if (autoValue !== void 0) {
-      return autoValue;
+    if (autoValue === void 0) {
+      error(member.name, Diagnostics.Enum_member_must_have_initializer);
+      return void 0;
     }
-    error(member.name, Diagnostics.Enum_member_must_have_initializer);
-    return void 0;
+    if (compilerOptions.isolatedModules && (previous == null ? void 0 : previous.initializer) && !evaluatesToNumericLiteral(previous.initializer)) {
+      error(
+        member.name,
+        Diagnostics.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled
+      );
+    }
+    return autoValue;
   }
   function computeConstantValue(member) {
     const isConstEnum = isEnumConst(member.parent);
@@ -80084,6 +80234,11 @@ function createTypeChecker(host) {
           initializer,
           isNaN(value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value
         );
+      } else if (compilerOptions.isolatedModules && typeof value === "string" && !evaluatesToStringLiteral(initializer)) {
+        error(
+          initializer,
+          Diagnostics.A_member_initializer_in_a_enum_declaration_for_a_string_value_must_be_a_string_literal_when_isolatedModules_is_enabled
+        );
       }
     } else if (isConstEnum) {
       error(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
@@ -80094,6 +80249,37 @@ function createTypeChecker(host) {
     }
     return value;
   }
+  function evaluatesToNumericLiteral(expr) {
+    switch (expr.kind) {
+      case 224 /* PrefixUnaryExpression */:
+        return evaluatesToNumericLiteral(expr.operand);
+      case 226 /* BinaryExpression */:
+        return evaluatesToNumericLiteral(expr.left) && evaluatesToNumericLiteral(expr.right);
+      case 217 /* ParenthesizedExpression */:
+        return evaluatesToNumericLiteral(expr.expression);
+      case 9 /* NumericLiteral */:
+        return true;
+    }
+    return false;
+  }
+  function evaluatesToStringLiteral(expr) {
+    switch (expr.kind) {
+      case 226 /* BinaryExpression */:
+        const left = expr.left;
+        const right = expr.right;
+        const leftIsNumeric = evaluatesToNumericLiteral(left);
+        const rightIsNumeric = evaluatesToNumericLiteral(right);
+        return !(leftIsNumeric && rightIsNumeric) && (evaluatesToStringLiteral(left) || leftIsNumeric) && (evaluatesToStringLiteral(right) || rightIsNumeric) && expr.operatorToken.kind === 40 /* PlusToken */;
+      case 228 /* TemplateExpression */:
+        return expr.templateSpans.every((span) => evaluatesToStringLiteral(span.expression));
+      case 217 /* ParenthesizedExpression */:
+        return evaluatesToStringLiteral(expr.expression);
+      case 11 /* StringLiteral */:
+      case 15 /* NoSubstitutionTemplateLiteral */:
+        return true;
+    }
+    return false;
+  }
   function evaluate(expr, location) {
     switch (expr.kind) {
       case 224 /* PrefixUnaryExpression */:
@@ -82657,7 +82843,7 @@ function createTypeChecker(host) {
     if (enumResult)
       return enumResult;
     const literalValue = type.value;
-    return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "number" ? factory.createNumericLiteral(literalValue) : factory.createStringLiteral(literalValue);
+    return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "string" ? factory.createStringLiteral(literalValue) : literalValue < 0 ? factory.createPrefixUnaryExpression(41 /* MinusToken */, factory.createNumericLiteral(-literalValue)) : factory.createNumericLiteral(literalValue);
   }
   function createLiteralConstValue(node, tracker) {
     const type = getTypeOfSymbol(getSymbolOfDeclaration(node));
@@ -89086,7 +89272,7 @@ function transformTypeScript(context) {
   function transformEnumMemberDeclarationValue(member) {
     const value = resolver.getConstantValue(member);
     if (value !== void 0) {
-      return typeof value === "string" ? factory2.createStringLiteral(value) : factory2.createNumericLiteral(value);
+      return typeof value === "string" ? factory2.createStringLiteral(value) : value < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-value)) : factory2.createNumericLiteral(value);
     } else {
       enableSubstitutionForNonQualifiedEnumMembers();
       if (member.initializer) {
@@ -89616,7 +89802,7 @@ function transformTypeScript(context) {
     const constantValue = tryGetConstEnumValue(node);
     if (constantValue !== void 0) {
       setConstantValue(node, constantValue);
-      const substitute = typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : constantValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(Math.abs(constantValue))) : factory2.createNumericLiteral(constantValue);
+      const substitute = typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : constantValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-constantValue)) : factory2.createNumericLiteral(constantValue);
       if (!compilerOptions.removeComments) {
         const originalNode = getOriginalNode(node, isAccessExpression);
         addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, ` ${safeMultiLineComment(getTextOfNode(originalNode))} `);
@@ -103406,7 +103592,7 @@ function transformGenerators(context) {
       if (labelExpressions === void 0) {
         labelExpressions = [];
       }
-      const expression = factory2.createNumericLiteral(-1);
+      const expression = factory2.createNumericLiteral(Number.MAX_SAFE_INTEGER);
       if (labelExpressions[label] === void 0) {
         labelExpressions[label] = [expression];
       } else {
@@ -109281,7 +109467,8 @@ function transformDeclarations(context) {
             if (shouldStripInternal(m))
               return;
             const constValue = resolver.getConstantValue(m);
-            return preserveJsDoc(factory2.updateEnumMember(m, m.name, constValue !== void 0 ? typeof constValue === "string" ? factory2.createStringLiteral(constValue) : factory2.createNumericLiteral(constValue) : void 0), m);
+            const newInitializer = constValue === void 0 ? void 0 : typeof constValue === "string" ? factory2.createStringLiteral(constValue) : constValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-constValue)) : factory2.createNumericLiteral(constValue);
+            return preserveJsDoc(factory2.updateEnumMember(m, m.name, newInitializer), m);
           }))
         ));
       }
@@ -111171,6 +111358,8 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       );
     if (hint === 3 /* MappedTypeParameter */)
       return emitMappedTypeParameter(cast(node, isTypeParameterDeclaration));
+    if (hint === 7 /* ImportTypeNodeAttributes */)
+      return emitImportTypeNodeAttributes(cast(node, isImportAttributes));
     if (hint === 5 /* EmbeddedStatement */) {
       Debug.assertNode(node, isEmptyStatement);
       return emitEmptyStatement(
@@ -112147,15 +112336,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     if (node.attributes) {
       writePunctuation(",");
       writeSpace();
-      writePunctuation("{");
-      writeSpace();
-      writeKeyword(node.attributes.token === 132 /* AssertKeyword */ ? "assert" : "with");
-      writePunctuation(":");
-      writeSpace();
-      const elements = node.attributes.elements;
-      emitList(node.attributes, elements, 526226 /* ImportAttributes */);
-      writeSpace();
-      writePunctuation("}");
+      pipelineEmit(7 /* ImportTypeNodeAttributes */, node.attributes);
     }
     writePunctuation(")");
     if (node.qualifier) {
@@ -113217,6 +113398,17 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     }
     writeTrailingSemicolon();
   }
+  function emitImportTypeNodeAttributes(node) {
+    writePunctuation("{");
+    writeSpace();
+    writeKeyword(node.token === 132 /* AssertKeyword */ ? "assert" : "with");
+    writePunctuation(":");
+    writeSpace();
+    const elements = node.elements;
+    emitList(node, elements, 526226 /* ImportAttributes */);
+    writeSpace();
+    writePunctuation("}");
+  }
   function emitImportAttributes(node) {
     emitTokenWithComment(node.token, node.pos, writeKeyword, node);
     writeSpace();