@typescript-deploys/pr-build 5.0.0-pr-51387-10 → 5.0.0-pr-51387-49

package/lib/tsserver.js

@@ -452,6 +452,7 @@ var ts = (() => {
     createFunctionTypeNode: () => createFunctionTypeNode,
     createGetAccessor: () => createGetAccessor,
     createGetCanonicalFileName: () => createGetCanonicalFileName,
+    createGetSourceFile: () => createGetSourceFile,
     createGetSymbolAccessibilityDiagnosticForNode: () => createGetSymbolAccessibilityDiagnosticForNode,
     createGetSymbolAccessibilityDiagnosticForNodeName: () => createGetSymbolAccessibilityDiagnosticForNodeName,
     createGetSymbolWalker: () => createGetSymbolWalker,
@@ -471,6 +472,8 @@ var ts = (() => {
     createIndexedAccessTypeNode: () => createIndexedAccessTypeNode,
     createInferTypeNode: () => createInferTypeNode,
     createInputFiles: () => createInputFiles,
+    createInputFilesWithFilePaths: () => createInputFilesWithFilePaths,
+    createInputFilesWithFileTexts: () => createInputFilesWithFileTexts,
     createInterfaceDeclaration: () => createInterfaceDeclaration,
     createIntersectionTypeNode: () => createIntersectionTypeNode,
     createJSDocAugmentsTag: () => createJSDocAugmentsTag,
@@ -671,6 +674,7 @@ var ts = (() => {
     createWatchStatusReporter: () => createWatchStatusReporter,
     createWhile: () => createWhile,
     createWith: () => createWith,
+    createWriteFileMeasuringIO: () => createWriteFileMeasuringIO,
     createYield: () => createYield,
     declarationNameToString: () => declarationNameToString,
     decodeMappings: () => decodeMappings,
@@ -2623,7 +2627,6 @@ var ts = (() => {
     projectContainsInfoDirectly: () => projectContainsInfoDirectly,
     protocol: () => ts_server_protocol_exports,
     removeSorted: () => removeSorted,
-    setDynamicImport: () => setDynamicImport,
     stringifyIndented: () => stringifyIndented,
     toEvent: () => toEvent,
     toNormalizedPath: () => toNormalizedPath,
@@ -2633,7 +2636,7 @@ var ts = (() => {
 
   // src/compiler/corePublic.ts
   var versionMajorMinor = "5.0";
-  var version = `${versionMajorMinor}.0-insiders.20221102`;
+  var version = `${versionMajorMinor}.0-insiders.20221107`;
   var Comparison = /* @__PURE__ */ ((Comparison3) => {
     Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
     Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -5030,6 +5033,7 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
       })(BoxCharacter || (BoxCharacter = {}));
       let Connection;
       ((Connection2) => {
+        Connection2[Connection2["None"] = 0] = "None";
         Connection2[Connection2["Up"] = 1] = "Up";
         Connection2[Connection2["Down"] = 2] = "Down";
         Connection2[Connection2["Left"] = 4] = "Left";
@@ -10065,7 +10069,7 @@ ${lanes.join("\n")}
     The_0_operator_cannot_be_applied_to_type_symbol: diag(2469, 1 /* Error */, "The_0_operator_cannot_be_applied_to_type_symbol_2469", "The '{0}' operator cannot be applied to type 'symbol'."),
     Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: diag(2472, 1 /* Error */, "Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher_2472", "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher."),
     Enum_declarations_must_all_be_const_or_non_const: diag(2473, 1 /* Error */, "Enum_declarations_must_all_be_const_or_non_const_2473", "Enum declarations must all be const or non-const."),
-    const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values: diag(2474, 1 /* Error */, "const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values_2474", "const enum member initializers can only contain literal values and other computed enum values."),
+    const_enum_member_initializers_must_be_constant_expressions: diag(2474, 1 /* Error */, "const_enum_member_initializers_must_be_constant_expressions_2474", "const enum member initializers must be constant expressions."),
     const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query: diag(2475, 1 /* Error */, "const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_im_2475", "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query."),
     A_const_enum_member_can_only_be_accessed_using_a_string_literal: diag(2476, 1 /* Error */, "A_const_enum_member_can_only_be_accessed_using_a_string_literal_2476", "A const enum member can only be accessed using a string literal."),
     const_enum_member_initializer_was_evaluated_to_a_non_finite_value: diag(2477, 1 /* Error */, "const_enum_member_initializer_was_evaluated_to_a_non_finite_value_2477", "'const' enum member initializer was evaluated to a non-finite value."),
@@ -10121,7 +10125,6 @@ ${lanes.join("\n")}
     Object_is_possibly_undefined: diag(2532, 1 /* Error */, "Object_is_possibly_undefined_2532", "Object is possibly 'undefined'."),
     Object_is_possibly_null_or_undefined: diag(2533, 1 /* Error */, "Object_is_possibly_null_or_undefined_2533", "Object is possibly 'null' or 'undefined'."),
     A_function_returning_never_cannot_have_a_reachable_end_point: diag(2534, 1 /* Error */, "A_function_returning_never_cannot_have_a_reachable_end_point_2534", "A function returning 'never' cannot have a reachable end point."),
-    Enum_type_0_has_members_with_initializers_that_are_not_literals: diag(2535, 1 /* Error */, "Enum_type_0_has_members_with_initializers_that_are_not_literals_2535", "Enum type '{0}' has members with initializers that are not literals."),
     Type_0_cannot_be_used_to_index_type_1: diag(2536, 1 /* Error */, "Type_0_cannot_be_used_to_index_type_1_2536", "Type '{0}' cannot be used to index type '{1}'."),
     Type_0_has_no_matching_index_signature_for_type_1: diag(2537, 1 /* Error */, "Type_0_has_no_matching_index_signature_for_type_1_2537", "Type '{0}' has no matching index signature for type '{1}'."),
     Type_0_cannot_be_used_as_an_index_type: diag(2538, 1 /* Error */, "Type_0_cannot_be_used_as_an_index_type_2538", "Type '{0}' cannot be used as an index type."),
@@ -11364,7 +11367,7 @@ ${lanes.join("\n")}
     An_optional_chain_cannot_contain_private_identifiers: diag(18030, 1 /* Error */, "An_optional_chain_cannot_contain_private_identifiers_18030", "An optional chain cannot contain private identifiers."),
     The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents: diag(18031, 1 /* Error */, "The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituent_18031", "The intersection '{0}' was reduced to 'never' because property '{1}' has conflicting types in some constituents."),
     The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some: diag(18032, 1 /* Error */, "The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_pr_18032", "The intersection '{0}' was reduced to 'never' because property '{1}' exists in multiple constituents and is private in some."),
-    Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhaustiveness_checks_consider_using_an_object_literal_instead: diag(18033, 1 /* Error */, "Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhau_18033", "Only numeric enums can have computed members, but this expression has type '{0}'. If you do not need exhaustiveness checks, consider using an object literal instead."),
+    Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values: diag(18033, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values_18033", "Type '{0}' is not assignable to type '{1}' as required for computed enum member values."),
     Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compiler_option_is_specified_e_g_Fragment: diag(18034, 3 /* Message */, "Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compi_18034", "Specify the JSX fragment factory function to use when targeting 'react' JSX emit with 'jsxFactory' compiler option is specified, e.g. 'Fragment'."),
     Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(18035, 1 /* Error */, "Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name_18035", "Invalid value for 'jsxFragmentFactory'. '{0}' is not a valid identifier or qualified-name."),
     Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator: diag(18036, 1 /* Error */, "Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_dec_18036", "Class decorators can't be used with static private identifier. Consider removing the experimental decorator."),
@@ -24887,69 +24890,83 @@ ${lanes.join("\n")}
     node.helpers = map(bundleFileInfo.sources && bundleFileInfo.sources.helpers, (name) => getAllUnscopedEmitHelpers().get(name));
     return node;
   }
-  function createInputFiles(javascriptTextOrReadFileText, declarationTextOrJavascriptPath, javascriptMapPath, javascriptMapTextOrDeclarationPath, declarationMapPath, declarationMapTextOrBuildInfoPath, javascriptPath, declarationPath, buildInfoPath, buildInfo, oldFileOfCurrentEmit) {
+  function createInputFiles(javascriptTextOrReadFileText, declarationTextOrJavascriptPath, javascriptMapPath, javascriptMapTextOrDeclarationPath, declarationMapPath, declarationMapTextOrBuildInfoPath) {
+    return !isString(javascriptTextOrReadFileText) ? createInputFilesWithFilePaths(
+      javascriptTextOrReadFileText,
+      declarationTextOrJavascriptPath,
+      javascriptMapPath,
+      javascriptMapTextOrDeclarationPath,
+      declarationMapPath,
+      declarationMapTextOrBuildInfoPath
+    ) : createInputFilesWithFileTexts(
+      void 0,
+      javascriptTextOrReadFileText,
+      javascriptMapPath,
+      javascriptMapTextOrDeclarationPath,
+      void 0,
+      declarationTextOrJavascriptPath,
+      declarationMapPath,
+      declarationMapTextOrBuildInfoPath
+    );
+  }
+  function createInputFilesWithFilePaths(readFileText, javascriptPath, javascriptMapPath, declarationPath, declarationMapPath, buildInfoPath, host, options) {
     const node = parseNodeFactory.createInputFiles();
-    if (!isString(javascriptTextOrReadFileText)) {
-      const cache = new Map();
-      const textGetter = (path) => {
-        if (path === void 0)
-          return void 0;
-        let value = cache.get(path);
-        if (value === void 0) {
-          value = javascriptTextOrReadFileText(path);
-          cache.set(path, value !== void 0 ? value : false);
-        }
-        return value !== false ? value : void 0;
-      };
-      const definedTextGetter = (path) => {
-        const result = textGetter(path);
-        return result !== void 0 ? result : `/* Input file ${path} was missing */\r
+    node.javascriptPath = javascriptPath;
+    node.javascriptMapPath = javascriptMapPath;
+    node.declarationPath = declarationPath;
+    node.declarationMapPath = declarationMapPath;
+    node.buildInfoPath = buildInfoPath;
+    const cache = new Map();
+    const textGetter = (path) => {
+      if (path === void 0)
+        return void 0;
+      let value = cache.get(path);
+      if (value === void 0) {
+        value = readFileText(path);
+        cache.set(path, value !== void 0 ? value : false);
+      }
+      return value !== false ? value : void 0;
+    };
+    const definedTextGetter = (path) => {
+      const result = textGetter(path);
+      return result !== void 0 ? result : `/* Input file ${path} was missing */\r
 `;
-      };
-      let buildInfo2;
-      const getAndCacheBuildInfo = (getText) => {
-        var _a2;
-        if (buildInfo2 === void 0) {
-          const result = getText();
-          buildInfo2 = result !== void 0 ? (_a2 = getBuildInfo(node.buildInfoPath, result)) != null ? _a2 : false : false;
+    };
+    let buildInfo;
+    const getAndCacheBuildInfo = () => {
+      var _a2, _b;
+      if (buildInfo === void 0 && buildInfoPath) {
+        if (host == null ? void 0 : host.getBuildInfo) {
+          buildInfo = (_a2 = host.getBuildInfo(buildInfoPath, options.configFilePath)) != null ? _a2 : false;
+        } else {
+          const result = textGetter(buildInfoPath);
+          buildInfo = result !== void 0 ? (_b = getBuildInfo(buildInfoPath, result)) != null ? _b : false : false;
         }
-        return buildInfo2 || void 0;
-      };
-      node.javascriptPath = declarationTextOrJavascriptPath;
-      node.javascriptMapPath = javascriptMapPath;
-      node.declarationPath = Debug.checkDefined(javascriptMapTextOrDeclarationPath);
-      node.declarationMapPath = declarationMapPath;
-      node.buildInfoPath = declarationMapTextOrBuildInfoPath;
-      Object.defineProperties(node, {
-        javascriptText: { get() {
-          return definedTextGetter(declarationTextOrJavascriptPath);
-        } },
-        javascriptMapText: { get() {
-          return textGetter(javascriptMapPath);
-        } },
-        declarationText: { get() {
-          return definedTextGetter(Debug.checkDefined(javascriptMapTextOrDeclarationPath));
-        } },
-        declarationMapText: { get() {
-          return textGetter(declarationMapPath);
-        } },
-        buildInfo: { get() {
-          return getAndCacheBuildInfo(() => textGetter(declarationMapTextOrBuildInfoPath));
-        } }
-      });
-    } else {
-      node.javascriptText = javascriptTextOrReadFileText;
-      node.javascriptMapPath = javascriptMapPath;
-      node.javascriptMapText = javascriptMapTextOrDeclarationPath;
-      node.declarationText = declarationTextOrJavascriptPath;
-      node.declarationMapPath = declarationMapPath;
-      node.declarationMapText = declarationMapTextOrBuildInfoPath;
-      node.javascriptPath = javascriptPath;
-      node.declarationPath = declarationPath;
-      node.buildInfoPath = buildInfoPath;
-      node.buildInfo = buildInfo;
-      node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
-    }
+      }
+      return buildInfo || void 0;
+    };
+    Object.defineProperties(node, {
+      javascriptText: { get: () => definedTextGetter(javascriptPath) },
+      javascriptMapText: { get: () => textGetter(javascriptMapPath) },
+      declarationText: { get: () => definedTextGetter(Debug.checkDefined(declarationPath)) },
+      declarationMapText: { get: () => textGetter(declarationMapPath) },
+      buildInfo: { get: getAndCacheBuildInfo }
+    });
+    return node;
+  }
+  function createInputFilesWithFileTexts(javascriptPath, javascriptText, javascriptMapPath, javascriptMapText, declarationPath, declarationText, declarationMapPath, declarationMapText, buildInfoPath, buildInfo, oldFileOfCurrentEmit) {
+    const node = parseNodeFactory.createInputFiles();
+    node.javascriptPath = javascriptPath;
+    node.javascriptText = javascriptText;
+    node.javascriptMapPath = javascriptMapPath;
+    node.javascriptMapText = javascriptMapText;
+    node.declarationPath = declarationPath;
+    node.declarationText = declarationText;
+    node.declarationMapPath = declarationMapPath;
+    node.declarationMapText = declarationMapText;
+    node.buildInfoPath = buildInfoPath;
+    node.buildInfo = buildInfo;
+    node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
     return node;
   }
   var SourceMapSource2;
@@ -42991,7 +43008,6 @@ ${lanes.join("\n")}
     const Signature15 = objectAllocator.getSignatureConstructor();
     let typeCount = 0;
     let symbolCount = 0;
-    let enumCount = 0;
     let totalInstantiationCount = 0;
     let instantiationCount = 0;
     let instantiationDepth = 0;
@@ -44822,7 +44838,7 @@ ${lanes.join("\n")}
       }
     }
     function isSameScopeDescendentOf(initial, parent2, stopAt) {
-      return !!parent2 && !!findAncestor(initial, (n) => n === parent2 || (n === stopAt || isFunctionLike(n) && !getImmediatelyInvokedFunctionExpression(n) ? "quit" : false));
+      return !!parent2 && !!findAncestor(initial, (n) => n === parent2 || (n === stopAt || isFunctionLike(n) && (!getImmediatelyInvokedFunctionExpression(n) || isAsyncFunction(n)) ? "quit" : false));
     }
     function getAnyImportSyntax(node) {
       switch (node.kind) {
@@ -46095,6 +46111,11 @@ ${lanes.join("\n")}
       (_a2 = tracing) == null ? void 0 : _a2.recordType(result);
       return result;
     }
+    function createTypeWithSymbol(flags, symbol) {
+      const result = createType(flags);
+      result.symbol = symbol;
+      return result;
+    }
     function createOriginType(flags) {
       return new Type27(checker, flags);
     }
@@ -46105,9 +46126,8 @@ ${lanes.join("\n")}
       return type;
     }
     function createObjectType(objectFlags, symbol) {
-      const type = createType(524288 /* Object */);
+      const type = createTypeWithSymbol(524288 /* Object */, symbol);
       type.objectFlags = objectFlags;
-      type.symbol = symbol;
       type.members = void 0;
       type.properties = void 0;
       type.callSignatures = void 0;
@@ -46119,10 +46139,7 @@ ${lanes.join("\n")}
       return getUnionType(arrayFrom(typeofNEFacts.keys(), getStringLiteralType));
     }
     function createTypeParameter(symbol) {
-      const type = createType(262144 /* TypeParameter */);
-      if (symbol)
-        type.symbol = symbol;
-      return type;
+      return createTypeWithSymbol(262144 /* TypeParameter */, symbol);
     }
     function isReservedMemberName(name) {
       return name.charCodeAt(0) === 95 /* _ */ && name.charCodeAt(1) === 95 /* _ */ && name.charCodeAt(2) !== 95 /* _ */ && name.charCodeAt(2) !== 64 /* at */ && name.charCodeAt(2) !== 35 /* hash */;
@@ -46713,29 +46730,29 @@ ${lanes.join("\n")}
           context.approximateLength += 7;
           return factory.createKeywordTypeNode(134 /* BooleanKeyword */);
         }
-        if (type.flags & 1024 /* EnumLiteral */ && !(type.flags & 1048576 /* Union */)) {
-          const parentSymbol = getParentOfSymbol(type.symbol);
-          const parentName = symbolToTypeNode(parentSymbol, context, 788968 /* Type */);
-          if (getDeclaredTypeOfSymbol(parentSymbol) === type) {
-            return parentName;
-          }
-          const memberName = symbolName(type.symbol);
-          if (isIdentifierText(memberName, 0 /* ES3 */)) {
-            return appendReferenceToType(
-              parentName,
-              factory.createTypeReferenceNode(memberName, void 0)
-            );
-          }
-          if (isImportTypeNode(parentName)) {
-            parentName.isTypeOf = true;
-            return factory.createIndexedAccessTypeNode(parentName, factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
-          } else if (isTypeReferenceNode(parentName)) {
-            return factory.createIndexedAccessTypeNode(factory.createTypeQueryNode(parentName.typeName), factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
-          } else {
-            return Debug.fail("Unhandled type node kind returned from `symbolToTypeNode`.");
-          }
-        }
         if (type.flags & 1056 /* EnumLike */) {
+          if (type.symbol.flags & 8 /* EnumMember */) {
+            const parentSymbol = getParentOfSymbol(type.symbol);
+            const parentName = symbolToTypeNode(parentSymbol, context, 788968 /* Type */);
+            if (getDeclaredTypeOfSymbol(parentSymbol) === type) {
+              return parentName;
+            }
+            const memberName = symbolName(type.symbol);
+            if (isIdentifierText(memberName, 0 /* ES3 */)) {
+              return appendReferenceToType(
+                parentName,
+                factory.createTypeReferenceNode(memberName, void 0)
+              );
+            }
+            if (isImportTypeNode(parentName)) {
+              parentName.isTypeOf = true;
+              return factory.createIndexedAccessTypeNode(parentName, factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
+            } else if (isTypeReferenceNode(parentName)) {
+              return factory.createIndexedAccessTypeNode(factory.createTypeQueryNode(parentName.typeName), factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
+            } else {
+              return Debug.fail("Unhandled type node kind returned from `symbolToTypeNode`.");
+            }
+          }
           return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
         }
         if (type.flags & 128 /* StringLiteral */) {
@@ -51074,91 +51091,36 @@ ${lanes.join("\n")}
       }
       return links.declaredType;
     }
-    function isStringConcatExpression(expr) {
-      if (isStringLiteralLike(expr)) {
-        return true;
-      } else if (expr.kind === 223 /* BinaryExpression */) {
-        return isStringConcatExpression(expr.left) && isStringConcatExpression(expr.right);
-      }
-      return false;
-    }
-    function isLiteralEnumMember(member) {
-      const expr = member.initializer;
-      if (!expr) {
-        return !(member.flags & 16777216 /* Ambient */);
-      }
-      switch (expr.kind) {
-        case 10 /* StringLiteral */:
-        case 8 /* NumericLiteral */:
-        case 14 /* NoSubstitutionTemplateLiteral */:
-          return true;
-        case 221 /* PrefixUnaryExpression */:
-          return expr.operator === 40 /* MinusToken */ && expr.operand.kind === 8 /* NumericLiteral */;
-        case 79 /* Identifier */:
-          return nodeIsMissing(expr) || !!getSymbolOfNode(member.parent).exports.get(expr.escapedText);
-        case 223 /* BinaryExpression */:
-          return isStringConcatExpression(expr);
-        default:
-          return false;
-      }
-    }
-    function getEnumKind(symbol) {
-      const links = getSymbolLinks(symbol);
-      if (links.enumKind !== void 0) {
-        return links.enumKind;
-      }
-      let hasNonLiteralMember = false;
-      if (symbol.declarations) {
-        for (const declaration of symbol.declarations) {
-          if (declaration.kind === 263 /* EnumDeclaration */) {
-            for (const member of declaration.members) {
-              if (member.initializer && isStringLiteralLike(member.initializer)) {
-                return links.enumKind = 1 /* Literal */;
-              }
-              if (!isLiteralEnumMember(member)) {
-                hasNonLiteralMember = true;
-              }
-            }
-          }
-        }
-      }
-      return links.enumKind = hasNonLiteralMember ? 0 /* Numeric */ : 1 /* Literal */;
-    }
     function getBaseTypeOfEnumLiteralType(type) {
       return type.flags & 1024 /* EnumLiteral */ && !(type.flags & 1048576 /* Union */) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
     }
     function getDeclaredTypeOfEnum(symbol) {
       const links = getSymbolLinks(symbol);
-      if (links.declaredType) {
-        return links.declaredType;
-      }
-      if (getEnumKind(symbol) === 1 /* Literal */) {
-        enumCount++;
+      if (!links.declaredType) {
         const memberTypeList = [];
         if (symbol.declarations) {
           for (const declaration of symbol.declarations) {
             if (declaration.kind === 263 /* EnumDeclaration */) {
               for (const member of declaration.members) {
-                const value = getEnumMemberValue(member);
-                const memberType = getFreshTypeOfLiteralType(getEnumLiteralType(value !== void 0 ? value : 0, enumCount, getSymbolOfNode(member)));
-                getSymbolLinks(getSymbolOfNode(member)).declaredType = memberType;
-                memberTypeList.push(getRegularTypeOfLiteralType(memberType));
+                if (hasBindableName(member)) {
+                  const memberSymbol = getSymbolOfNode(member);
+                  const value = getEnumMemberValue(member);
+                  const memberType = value !== void 0 ? getFreshTypeOfLiteralType(getEnumLiteralType(value, getSymbolId(symbol), memberSymbol)) : createTypeWithSymbol(32 /* Enum */, memberSymbol);
+                  getSymbolLinks(memberSymbol).declaredType = memberType;
+                  memberTypeList.push(getRegularTypeOfLiteralType(memberType));
+                }
               }
             }
           }
         }
-        if (memberTypeList.length) {
-          const enumType2 = getUnionType(memberTypeList, 1 /* Literal */, symbol, void 0);
-          if (enumType2.flags & 1048576 /* Union */) {
-            enumType2.flags |= 1024 /* EnumLiteral */;
-            enumType2.symbol = symbol;
-          }
-          return links.declaredType = enumType2;
+        const enumType = memberTypeList.length ? getUnionType(memberTypeList, 1 /* Literal */, symbol, void 0) : createTypeWithSymbol(32 /* Enum */, symbol);
+        if (enumType.flags & 1048576 /* Union */) {
+          enumType.flags |= 1024 /* EnumLiteral */;
+          enumType.symbol = symbol;
         }
+        links.declaredType = enumType;
       }
-      const enumType = createType(32 /* Enum */);
-      enumType.symbol = symbol;
-      return links.declaredType = enumType;
+      return links.declaredType;
     }
     function getDeclaredTypeOfEnumMember(symbol) {
       const links = getSymbolLinks(symbol);
@@ -53410,8 +53372,7 @@ ${lanes.join("\n")}
       return type;
     }
     function cloneTypeReference(source) {
-      const type = createType(source.flags);
-      type.symbol = source.symbol;
+      const type = createTypeWithSymbol(source.flags, source.symbol);
       type.objectFlags = source.objectFlags;
       type.target = source.target;
       type.resolvedTypeArguments = source.resolvedTypeArguments;
@@ -54959,8 +54920,7 @@ ${lanes.join("\n")}
       return result;
     }
     function createStringMappingType(symbol, type) {
-      const result = createType(268435456 /* StringMapping */);
-      result.symbol = symbol;
+      const result = createTypeWithSymbol(268435456 /* StringMapping */, symbol);
       result.type = type;
       return result;
     }
@@ -55774,8 +55734,7 @@ ${lanes.join("\n")}
       return info.isReadonly !== readonly ? createIndexInfo(info.keyType, info.type, readonly, info.declaration) : info;
     }
     function createLiteralType(flags, value, symbol, regularType) {
-      const type = createType(flags);
-      type.symbol = symbol;
+      const type = createTypeWithSymbol(flags, symbol);
       type.value = value;
       type.regularType = regularType || type;
       return type;
@@ -55812,8 +55771,7 @@ ${lanes.join("\n")}
     }
     function getEnumLiteralType(value, enumId, symbol) {
       let type;
-      const qualifier = typeof value === "string" ? "@" : "#";
-      const key = enumId + qualifier + value;
+      const key = `${enumId}${typeof value === "string" ? "@" : "#"}${value}`;
       const flags = 1024 /* EnumLiteral */ | (typeof value === "string" ? 128 /* StringLiteral */ : 256 /* NumberLiteral */);
       return enumLiteralTypes.get(key) || (enumLiteralTypes.set(key, type = createLiteralType(flags, value, symbol)), type);
     }
@@ -55828,8 +55786,7 @@ ${lanes.join("\n")}
       return links.resolvedType;
     }
     function createUniqueESSymbolType(symbol) {
-      const type = createType(8192 /* UniqueESSymbol */);
-      type.symbol = symbol;
+      const type = createTypeWithSymbol(8192 /* UniqueESSymbol */, symbol);
       type.escapedName = `__@${type.symbol.escapedName}@${getSymbolId(type.symbol)}`;
       return type;
     }
@@ -57070,19 +57027,20 @@ ${lanes.join("\n")}
     function isStringIndexSignatureOnlyType(type) {
       return type.flags & 524288 /* Object */ && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, stringType) || type.flags & 3145728 /* UnionOrIntersection */ && every(type.types, isStringIndexSignatureOnlyType) || false;
     }
-    function isEnumTypeRelatedTo(sourceSymbol, targetSymbol, errorReporter) {
+    function isEnumTypeRelatedTo(source, target, errorReporter) {
+      const sourceSymbol = source.flags & 8 /* EnumMember */ ? getParentOfSymbol(source) : source;
+      const targetSymbol = target.flags & 8 /* EnumMember */ ? getParentOfSymbol(target) : target;
       if (sourceSymbol === targetSymbol) {
         return true;
       }
+      if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256 /* RegularEnum */) || !(targetSymbol.flags & 256 /* RegularEnum */)) {
+        return false;
+      }
       const id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol);
       const entry = enumRelation.get(id);
       if (entry !== void 0 && !(!(entry & 4 /* Reported */) && entry & 2 /* Failed */ && errorReporter)) {
         return !!(entry & 1 /* Succeeded */);
       }
-      if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256 /* RegularEnum */) || !(targetSymbol.flags & 256 /* RegularEnum */)) {
-        enumRelation.set(id, 2 /* Failed */ | 4 /* Reported */);
-        return false;
-      }
       const targetEnumType = getTypeOfSymbol(targetSymbol);
       for (const property of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
         if (property.flags & 8 /* EnumMember */) {
@@ -57126,12 +57084,12 @@ ${lanes.join("\n")}
         return true;
       if (s & 12288 /* ESSymbolLike */ && t & 4096 /* ESSymbol */)
         return true;
-      if (s & 32 /* Enum */ && t & 32 /* Enum */ && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
+      if (s & 32 /* Enum */ && t & 32 /* Enum */ && source.symbol.escapedName === target.symbol.escapedName && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
         return true;
       if (s & 1024 /* EnumLiteral */ && t & 1024 /* EnumLiteral */) {
         if (s & 1048576 /* Union */ && t & 1048576 /* Union */ && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
           return true;
-        if (s & 2944 /* Literal */ && t & 2944 /* Literal */ && source.value === target.value && isEnumTypeRelatedTo(getParentOfSymbol(source.symbol), getParentOfSymbol(target.symbol), errorReporter))
+        if (s & 2944 /* Literal */ && t & 2944 /* Literal */ && source.value === target.value && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
           return true;
       }
       if (s & 32768 /* Undefined */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & (32768 /* Undefined */ | 16384 /* Void */)))
@@ -58627,28 +58585,30 @@ ${lanes.join("\n")}
             }
             const sourceTypeArguments = getTypeArguments(source2);
             const targetTypeArguments = getTypeArguments(target2);
-            const startCount = Math.min(isTupleType(source2) ? getStartElementCount(source2.target, 11 /* NonRest */) : 0, getStartElementCount(target2.target, 11 /* NonRest */));
-            const endCount = Math.min(isTupleType(source2) ? getEndElementCount(source2.target, 11 /* NonRest */) : 0, targetRestFlag ? getEndElementCount(target2.target, 11 /* NonRest */) : 0);
+            const targetStartCount = getStartElementCount(target2.target, 11 /* NonRest */);
+            const targetEndCount = getEndElementCount(target2.target, 11 /* NonRest */);
+            const targetHasRestElement = target2.target.hasRestElement;
             let canExcludeDiscriminants = !!excludedProperties;
-            for (let i = 0; i < targetArity; i++) {
-              const sourceIndex = i < targetArity - endCount ? i : i + sourceArity - targetArity;
-              const sourceFlags = isTupleType(source2) && (i < startCount || i >= targetArity - endCount) ? source2.target.elementFlags[sourceIndex] : 4 /* Rest */;
-              const targetFlags = target2.target.elementFlags[i];
+            for (let sourcePosition = 0; sourcePosition < sourceArity; sourcePosition++) {
+              const sourceFlags = isTupleType(source2) ? source2.target.elementFlags[sourcePosition] : 4 /* Rest */;
+              const sourcePositionFromEnd = sourceArity - 1 - sourcePosition;
+              const targetPosition = targetHasRestElement && sourcePosition >= targetStartCount ? targetArity - 1 - Math.min(sourcePositionFromEnd, targetEndCount) : sourcePosition;
+              const targetFlags = target2.target.elementFlags[targetPosition];
               if (targetFlags & 8 /* Variadic */ && !(sourceFlags & 8 /* Variadic */)) {
                 if (reportErrors2) {
-                  reportError(Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target, i);
+                  reportError(Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target, targetPosition);
                 }
                 return 0 /* False */;
               }
               if (sourceFlags & 8 /* Variadic */ && !(targetFlags & 12 /* Variable */)) {
                 if (reportErrors2) {
-                  reportError(Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target, sourceIndex, i);
+                  reportError(Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target, sourcePosition, targetPosition);
                 }
                 return 0 /* False */;
               }
               if (targetFlags & 1 /* Required */ && !(sourceFlags & 1 /* Required */)) {
                 if (reportErrors2) {
-                  reportError(Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target, i);
+                  reportError(Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target, targetPosition);
                 }
                 return 0 /* False */;
               }
@@ -58656,20 +58616,20 @@ ${lanes.join("\n")}
                 if (sourceFlags & 12 /* Variable */ || targetFlags & 12 /* Variable */) {
                   canExcludeDiscriminants = false;
                 }
-                if (canExcludeDiscriminants && (excludedProperties == null ? void 0 : excludedProperties.has("" + i))) {
+                if (canExcludeDiscriminants && (excludedProperties == null ? void 0 : excludedProperties.has("" + sourcePosition))) {
                   continue;
                 }
               }
-              const sourceType = !isTupleType(source2) ? sourceTypeArguments[0] : i < startCount || i >= targetArity - endCount ? removeMissingType(sourceTypeArguments[sourceIndex], !!(sourceFlags & targetFlags & 2 /* Optional */)) : getElementTypeOfSliceOfTupleType(source2, startCount, endCount) || neverType;
-              const targetType = targetTypeArguments[i];
+              const sourceType = removeMissingType(sourceTypeArguments[sourcePosition], !!(sourceFlags & targetFlags & 2 /* Optional */));
+              const targetType = targetTypeArguments[targetPosition];
               const targetCheckType = sourceFlags & 8 /* Variadic */ && targetFlags & 4 /* Rest */ ? createArrayType(targetType) : removeMissingType(targetType, !!(targetFlags & 2 /* Optional */));
               const related = isRelatedTo(sourceType, targetCheckType, 3 /* Both */, reportErrors2, void 0, intersectionState);
               if (!related) {
                 if (reportErrors2 && (targetArity > 1 || sourceArity > 1)) {
-                  if (i < startCount || i >= targetArity - endCount || sourceArity - startCount - endCount === 1) {
-                    reportIncompatibleError(Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, sourceIndex, i);
+                  if (targetHasRestElement && sourcePosition >= targetStartCount && sourcePositionFromEnd >= targetEndCount && targetStartCount !== sourceArity - targetEndCount - 1) {
+                    reportIncompatibleError(Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, targetStartCount, sourceArity - targetEndCount - 1, targetPosition);
                   } else {
-                    reportIncompatibleError(Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, startCount, sourceArity - endCount - 1, i);
+                    reportIncompatibleError(Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, sourcePosition, targetPosition);
                   }
                 }
                 return 0 /* False */;
@@ -60249,10 +60209,7 @@ ${lanes.join("\n")}
             return;
           }
           source = getUnionType(sources);
-        } else if (target.flags & 2097152 /* Intersection */ && some(
-          target.types,
-          (t) => !!getInferenceInfoForType(t) || isGenericMappedType(t) && !!getInferenceInfoForType(getHomomorphicTypeVariable(t) || neverType)
-        )) {
+        } else if (target.flags & 2097152 /* Intersection */ && !every(target.types, isNonGenericObjectType)) {
           if (!(source.flags & 1048576 /* Union */)) {
             const [sources, targets] = inferFromMatchingTypes(source.flags & 2097152 /* Intersection */ ? source.types : [source], target.types, isTypeIdenticalTo);
             if (sources.length === 0 || targets.length === 0) {
@@ -67481,7 +67438,7 @@ ${lanes.join("\n")}
           if (symbol && symbol.flags & 2097152 /* Alias */) {
             symbol = resolveAlias(symbol);
           }
-          return !!(symbol && getAllSymbolFlags(symbol) & 384 /* Enum */ && getEnumKind(symbol) === 1 /* Literal */);
+          return !!(symbol && getAllSymbolFlags(symbol) & 384 /* Enum */);
       }
       return false;
     }
@@ -69406,7 +69363,7 @@ ${lanes.join("\n")}
       }
     }
     function checkExpressionCached(node, checkMode) {
-      if (checkMode && checkMode !== 0 /* Normal */) {
+      if (checkMode) {
         return checkExpression(node, checkMode);
       }
       const links = getNodeLinks(node);
@@ -70423,9 +70380,6 @@ ${lanes.join("\n")}
               symbol.escapedName
             );
           }
-          if (type.flags & 32 /* Enum */ && symbol.flags & 8 /* EnumMember */) {
-            error(node, Diagnostics.Enum_type_0_has_members_with_initializers_that_are_not_literals, typeToString(type));
-          }
         }
       }
     }
@@ -73749,7 +73703,7 @@ ${lanes.join("\n")}
       if (member.initializer) {
         return computeConstantValue(member);
       }
-      if (member.parent.flags & 16777216 /* Ambient */ && !isEnumConst(member.parent) && getEnumKind(getSymbolOfNode(member.parent)) === 0 /* Numeric */) {
+      if (member.parent.flags & 16777216 /* Ambient */ && !isEnumConst(member.parent)) {
         return void 0;
       }
       if (autoValue !== void 0) {
@@ -73759,134 +73713,140 @@ ${lanes.join("\n")}
       return void 0;
     }
     function computeConstantValue(member) {
-      const enumKind = getEnumKind(getSymbolOfNode(member.parent));
       const isConstEnum = isEnumConst(member.parent);
       const initializer = member.initializer;
-      const value = enumKind === 1 /* Literal */ && !isLiteralEnumMember(member) ? void 0 : evaluate(initializer);
+      const value = evaluate(initializer, member);
       if (value !== void 0) {
         if (isConstEnum && typeof value === "number" && !isFinite(value)) {
           error(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 (enumKind === 1 /* Literal */) {
-        error(initializer, Diagnostics.Computed_values_are_not_permitted_in_an_enum_with_string_valued_members);
-        return 0;
       } else if (isConstEnum) {
-        error(initializer, Diagnostics.const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values);
+        error(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
       } else if (member.parent.flags & 16777216 /* Ambient */) {
         error(initializer, Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);
       } else {
-        const source = checkExpression(initializer);
-        if (!isTypeAssignableToKind(source, 296 /* NumberLike */)) {
-          error(initializer, Diagnostics.Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhaustiveness_checks_consider_using_an_object_literal_instead, typeToString(source));
-        } else {
-          checkTypeAssignableTo(source, getDeclaredTypeOfSymbol(getSymbolOfNode(member.parent)), initializer, void 0);
-        }
+        checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
       }
       return value;
-      function evaluate(expr) {
-        switch (expr.kind) {
-          case 221 /* PrefixUnaryExpression */:
-            const value2 = evaluate(expr.operand);
-            if (typeof value2 === "number") {
-              switch (expr.operator) {
-                case 39 /* PlusToken */:
-                  return value2;
-                case 40 /* MinusToken */:
-                  return -value2;
-                case 54 /* TildeToken */:
-                  return ~value2;
-              }
+    }
+    function evaluate(expr, location2) {
+      switch (expr.kind) {
+        case 221 /* PrefixUnaryExpression */:
+          const value = evaluate(expr.operand, location2);
+          if (typeof value === "number") {
+            switch (expr.operator) {
+              case 39 /* PlusToken */:
+                return value;
+              case 40 /* MinusToken */:
+                return -value;
+              case 54 /* TildeToken */:
+                return ~value;
             }
-            break;
-          case 223 /* BinaryExpression */:
-            const left = evaluate(expr.left);
-            const right = evaluate(expr.right);
-            if (typeof left === "number" && typeof right === "number") {
-              switch (expr.operatorToken.kind) {
-                case 51 /* BarToken */:
-                  return left | right;
-                case 50 /* AmpersandToken */:
-                  return left & right;
-                case 48 /* GreaterThanGreaterThanToken */:
-                  return left >> right;
-                case 49 /* GreaterThanGreaterThanGreaterThanToken */:
-                  return left >>> right;
-                case 47 /* LessThanLessThanToken */:
-                  return left << right;
-                case 52 /* CaretToken */:
-                  return left ^ right;
-                case 41 /* AsteriskToken */:
-                  return left * right;
-                case 43 /* SlashToken */:
-                  return left / right;
-                case 39 /* PlusToken */:
-                  return left + right;
-                case 40 /* MinusToken */:
-                  return left - right;
-                case 44 /* PercentToken */:
-                  return left % right;
-                case 42 /* AsteriskAsteriskToken */:
-                  return left ** right;
+          }
+          break;
+        case 223 /* BinaryExpression */:
+          const left = evaluate(expr.left, location2);
+          const right = evaluate(expr.right, location2);
+          if (typeof left === "number" && typeof right === "number") {
+            switch (expr.operatorToken.kind) {
+              case 51 /* BarToken */:
+                return left | right;
+              case 50 /* AmpersandToken */:
+                return left & right;
+              case 48 /* GreaterThanGreaterThanToken */:
+                return left >> right;
+              case 49 /* GreaterThanGreaterThanGreaterThanToken */:
+                return left >>> right;
+              case 47 /* LessThanLessThanToken */:
+                return left << right;
+              case 52 /* CaretToken */:
+                return left ^ right;
+              case 41 /* AsteriskToken */:
+                return left * right;
+              case 43 /* SlashToken */:
+                return left / right;
+              case 39 /* PlusToken */:
+                return left + right;
+              case 40 /* MinusToken */:
+                return left - right;
+              case 44 /* PercentToken */:
+                return left % right;
+              case 42 /* AsteriskAsteriskToken */:
+                return left ** right;
+            }
+          } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 39 /* PlusToken */) {
+            return "" + left + right;
+          }
+          break;
+        case 10 /* StringLiteral */:
+        case 14 /* NoSubstitutionTemplateLiteral */:
+          return expr.text;
+        case 225 /* TemplateExpression */:
+          return evaluateTemplateExpression(expr, location2);
+        case 8 /* NumericLiteral */:
+          checkGrammarNumericLiteral(expr);
+          return +expr.text;
+        case 214 /* ParenthesizedExpression */:
+          return evaluate(expr.expression, location2);
+        case 79 /* Identifier */:
+          if (isInfinityOrNaNString(expr.escapedText)) {
+            return +expr.escapedText;
+          }
+        case 208 /* PropertyAccessExpression */:
+          if (isEntityNameExpression(expr)) {
+            const symbol = resolveEntityName(expr, 111551 /* Value */, true);
+            if (symbol) {
+              if (symbol.flags & 8 /* EnumMember */) {
+                return evaluateEnumMember(expr, symbol, location2);
               }
-            } else if (typeof left === "string" && typeof right === "string" && expr.operatorToken.kind === 39 /* PlusToken */) {
-              return left + right;
-            }
-            break;
-          case 10 /* StringLiteral */:
-          case 14 /* NoSubstitutionTemplateLiteral */:
-            return expr.text;
-          case 8 /* NumericLiteral */:
-            checkGrammarNumericLiteral(expr);
-            return +expr.text;
-          case 214 /* ParenthesizedExpression */:
-            return evaluate(expr.expression);
-          case 79 /* Identifier */:
-            const identifier = expr;
-            if (isInfinityOrNaNString(identifier.escapedText)) {
-              return +identifier.escapedText;
-            }
-            return nodeIsMissing(expr) ? 0 : evaluateEnumMember(expr, getSymbolOfNode(member.parent), identifier.escapedText);
-          case 209 /* ElementAccessExpression */:
-          case 208 /* PropertyAccessExpression */:
-            if (isConstantMemberAccess(expr)) {
-              const type = getTypeOfExpression(expr.expression);
-              if (type.symbol && type.symbol.flags & 384 /* Enum */) {
-                let name;
-                if (expr.kind === 208 /* PropertyAccessExpression */) {
-                  name = expr.name.escapedText;
-                } else {
-                  name = escapeLeadingUnderscores(cast(expr.argumentExpression, isLiteralExpression).text);
+              if (isConstVariable(symbol)) {
+                const declaration = symbol.valueDeclaration;
+                if (declaration && !declaration.type && declaration.initializer && declaration !== location2 && isBlockScopedNameDeclaredBeforeUse(declaration, location2)) {
+                  return evaluate(declaration.initializer, declaration);
                 }
-                return evaluateEnumMember(expr, type.symbol, name);
               }
             }
-            break;
-        }
-        return void 0;
-      }
-      function evaluateEnumMember(expr, enumSymbol, name) {
-        const memberSymbol = enumSymbol.exports.get(name);
-        if (memberSymbol) {
-          const declaration = memberSymbol.valueDeclaration;
-          if (declaration !== member) {
-            if (declaration && isBlockScopedNameDeclaredBeforeUse(declaration, member) && isEnumDeclaration(declaration.parent)) {
-              return getEnumMemberValue(declaration);
+          }
+          break;
+        case 209 /* ElementAccessExpression */:
+          const root = expr.expression;
+          if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
+            const rootSymbol = resolveEntityName(root, 111551 /* Value */, true);
+            if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
+              const name = escapeLeadingUnderscores(expr.argumentExpression.text);
+              const member = rootSymbol.exports.get(name);
+              if (member) {
+                return evaluateEnumMember(expr, member, location2);
+              }
             }
-            error(expr, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
-            return 0;
-          } else {
-            error(expr, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(memberSymbol));
           }
-        }
+          break;
+      }
+      return void 0;
+    }
+    function evaluateEnumMember(expr, symbol, location2) {
+      const declaration = symbol.valueDeclaration;
+      if (!declaration || declaration === location2) {
+        error(expr, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(symbol));
         return void 0;
       }
+      if (!isBlockScopedNameDeclaredBeforeUse(declaration, location2)) {
+        error(expr, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
+        return 0;
+      }
+      return getEnumMemberValue(declaration);
     }
-    function isConstantMemberAccess(node) {
-      const type = getTypeOfExpression(node);
-      if (type === errorType) {
-        return false;
+    function evaluateTemplateExpression(expr, location2) {
+      let result = expr.head.text;
+      for (const span of expr.templateSpans) {
+        const value = evaluate(span.expression, location2);
+        if (value === void 0) {
+          return void 0;
+        }
+        result += value;
+        result += span.literal.text;
       }
-      return node.kind === 79 /* Identifier */ || node.kind === 208 /* PropertyAccessExpression */ && isConstantMemberAccess(node.expression) || node.kind === 209 /* ElementAccessExpression */ && isConstantMemberAccess(node.expression) && isStringLiteralLike(node.argumentExpression);
+      return result;
     }
     function checkEnumDeclaration(node) {
       addLazyDiagnostic(() => checkEnumDeclarationWorker(node));
@@ -73932,6 +73892,9 @@ ${lanes.join("\n")}
       if (isPrivateIdentifier(node.name)) {
         error(node, Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier);
       }
+      if (node.initializer) {
+        checkExpression(node.initializer);
+      }
     }
     function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
       const declarations = symbol.declarations;
@@ -97349,17 +97312,19 @@ ${lanes.join("\n")}
     });
   }
   function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
+    var _a2, _b;
+    (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Emit, "emitUsingBuildInfo", {}, true);
+    ts_performance_exports.mark("beforeEmit");
+    const result = emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers);
+    ts_performance_exports.mark("afterEmit");
+    ts_performance_exports.measure("Emit", "beforeEmit", "afterEmit");
+    (_b = tracing) == null ? void 0 : _b.pop();
+    return result;
+  }
+  function emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers) {
     const createHash = maybeBind(host, host.createHash);
     const { buildInfoPath, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath } = getOutputPathsForBundle(config.options, false);
-    let buildInfo;
-    if (host.getBuildInfo) {
-      buildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath);
-    } else {
-      const buildInfoText = host.readFile(buildInfoPath);
-      if (!buildInfoText)
-        return buildInfoPath;
-      buildInfo = getBuildInfo(buildInfoPath, buildInfoText);
-    }
+    const buildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath);
     if (!buildInfo)
       return buildInfoPath;
     if (!buildInfo.bundle || !buildInfo.bundle.js || declarationFilePath && !buildInfo.bundle.dts)
@@ -97385,21 +97350,21 @@ ${lanes.join("\n")}
     if (declarationMapPath && computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash)
       return declarationMapPath;
     const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
-    const ownPrependInput = createInputFiles(
+    const ownPrependInput = createInputFilesWithFileTexts(
+      jsFilePath,
       jsFileText,
-      declarationText,
       sourceMapFilePath,
       sourceMapText,
+      declarationFilePath,
+      declarationText,
       declarationMapPath,
       declarationMapText,
-      jsFilePath,
-      declarationFilePath,
       buildInfoPath,
       buildInfo,
       true
     );
     const outputFiles = [];
-    const prependNodes = createPrependNodes(config.projectReferences, getCommandLine, (f) => host.readFile(f));
+    const prependNodes = createPrependNodes(config.projectReferences, getCommandLine, (f) => host.readFile(f), host);
     const sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle, buildInfoDirectory, host);
     let changedDtsText;
     let changedDtsData;
@@ -102073,14 +102038,12 @@ ${lanes.join("\n")}
   function createCompilerHost(options, setParentNodes) {
     return createCompilerHostWorker(options, setParentNodes);
   }
-  function createCompilerHostWorker(options, setParentNodes, system = sys) {
-    const existingDirectories = new Map();
-    const getCanonicalFileName = createGetCanonicalFileName(system.useCaseSensitiveFileNames);
-    function getSourceFile(fileName, languageVersionOrOptions, onError) {
+  function createGetSourceFile(readFile, getCompilerOptions, setParentNodes) {
+    return (fileName, languageVersionOrOptions, onError) => {
       let text;
       try {
         mark("beforeIORead");
-        text = compilerHost.readFile(fileName);
+        text = readFile(fileName, getCompilerOptions().charset);
         mark("afterIORead");
         measure("I/O Read", "beforeIORead", "afterIORead");
       } catch (e) {
@@ -102090,27 +102053,19 @@ ${lanes.join("\n")}
         text = "";
       }
       return text !== void 0 ? createSourceFile(fileName, text, languageVersionOrOptions, setParentNodes) : void 0;
-    }
-    function directoryExists(directoryPath) {
-      if (existingDirectories.has(directoryPath)) {
-        return true;
-      }
-      if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) {
-        existingDirectories.set(directoryPath, true);
-        return true;
-      }
-      return false;
-    }
-    function writeFile2(fileName, data, writeByteOrderMark, onError) {
+    };
+  }
+  function createWriteFileMeasuringIO(actualWriteFile, createDirectory, directoryExists) {
+    return (fileName, data, writeByteOrderMark, onError) => {
       try {
         mark("beforeIOWrite");
         writeFileEnsuringDirectories(
           fileName,
           data,
           writeByteOrderMark,
-          (path, data2, writeByteOrderMark2) => system.writeFile(path, data2, writeByteOrderMark2),
-          (path) => (compilerHost.createDirectory || system.createDirectory)(path),
-          (path) => directoryExists(path)
+          actualWriteFile,
+          createDirectory,
+          directoryExists
         );
         mark("afterIOWrite");
         measure("I/O Write", "beforeIOWrite", "afterIOWrite");
@@ -102119,6 +102074,20 @@ ${lanes.join("\n")}
           onError(e.message);
         }
       }
+    };
+  }
+  function createCompilerHostWorker(options, setParentNodes, system = sys) {
+    const existingDirectories = new Map();
+    const getCanonicalFileName = createGetCanonicalFileName(system.useCaseSensitiveFileNames);
+    function directoryExists(directoryPath) {
+      if (existingDirectories.has(directoryPath)) {
+        return true;
+      }
+      if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) {
+        existingDirectories.set(directoryPath, true);
+        return true;
+      }
+      return false;
     }
     function getDefaultLibLocation() {
       return getDirectoryPath(normalizePath(system.getExecutingFilePath()));
@@ -102126,10 +102095,14 @@ ${lanes.join("\n")}
     const newLine = getNewLineCharacter(options, () => system.newLine);
     const realpath = system.realpath && ((path) => system.realpath(path));
     const compilerHost = {
-      getSourceFile,
+      getSourceFile: createGetSourceFile((fileName) => compilerHost.readFile(fileName), () => options, setParentNodes),
       getDefaultLibLocation,
       getDefaultLibFileName: (options2) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options2)),
-      writeFile: writeFile2,
+      writeFile: createWriteFileMeasuringIO(
+        (path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),
+        (path) => (compilerHost.createDirectory || system.createDirectory)(path),
+        (path) => directoryExists(path)
+      ),
       getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
       useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
       getCanonicalFileName,
@@ -103500,7 +103473,8 @@ ${lanes.join("\n")}
           const path = toPath3(fileName);
           const sourceFile = getSourceFileByPath(path);
           return sourceFile ? sourceFile.text : filesByName.has(path) ? void 0 : host.readFile(path);
-        }
+        },
+        host
       );
     }
     function isSourceFileFromExternalLibrary(file) {
@@ -105286,7 +105260,7 @@ ${lanes.join("\n")}
       trace: host.trace ? (s) => host.trace(s) : void 0
     };
   }
-  function createPrependNodes(projectReferences, getCommandLine, readFile) {
+  function createPrependNodes(projectReferences, getCommandLine, readFile, host) {
     if (!projectReferences)
       return emptyArray;
     let nodes;
@@ -105298,7 +105272,7 @@ ${lanes.join("\n")}
         if (!out)
           continue;
         const { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath } = getOutputPathsForBundle(resolvedRefOpts.options, true);
-        const node = createInputFiles(readFile, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath);
+        const node = createInputFilesWithFilePaths(readFile, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath, host, resolvedRefOpts.options);
         (nodes || (nodes = [])).push(node);
       }
     }
@@ -105500,7 +105474,8 @@ ${lanes.join("\n")}
     function create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
       var _a2, _b, _c;
       const fileInfos = new Map();
-      const referencedMap = newProgram.getCompilerOptions().module !== 0 /* None */ ? createManyToManyPathMap() : void 0;
+      const options = newProgram.getCompilerOptions();
+      const referencedMap = options.module !== 0 /* None */ && !outFile(options) ? createManyToManyPathMap() : void 0;
       const exportedModulesMap = referencedMap ? createManyToManyPathMap() : void 0;
       const useOldState = canReuseOldState(referencedMap, oldState);
       newProgram.getTypeChecker();
@@ -105953,7 +105928,7 @@ ${lanes.join("\n")}
       const seenEmittedFiles = state.seenEmittedFiles || (state.seenEmittedFiles = new Map());
       for (let i = state.affectedFilesPendingEmitIndex; i < affectedFilesPendingEmit.length; i++) {
         const affectedFile = Debug.checkDefined(state.program).getSourceFileByPath(affectedFilesPendingEmit[i]);
-        if (affectedFile) {
+        if (affectedFile && sourceFileMayBeEmitted(affectedFile, state.program)) {
           const seenKind = seenEmittedFiles.get(affectedFile.resolvedPath);
           const emitKind = Debug.checkDefined(Debug.checkDefined(state.affectedFilesPendingEmitKind).get(affectedFile.resolvedPath));
           if (seenKind === void 0 || seenKind < emitKind) {
@@ -106258,6 +106233,9 @@ ${lanes.join("\n")}
       const seenFiles = new Set();
       for (const path of state.affectedFilesPendingEmit.slice(state.affectedFilesPendingEmitIndex).sort(compareStringsCaseSensitive)) {
         if (tryAddToSet(seenFiles, path)) {
+          const file = state.program.getSourceFileByPath(path);
+          if (!sourceFileMayBeEmitted(file, state.program))
+            continue;
           const fileId = toFileId(path), emitKind = state.affectedFilesPendingEmitKind.get(path);
           (affectedFilesPendingEmit || (affectedFilesPendingEmit = [])).push(
             emitKind === 1 /* Full */ ? fileId : [fileId]
@@ -108043,24 +108021,18 @@ ${lanes.join("\n")}
     const useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
     const hostGetNewLine = memoize(() => host.getNewLine());
     return {
-      getSourceFile: (fileName, languageVersionOrOptions, onError) => {
-        let text;
-        try {
-          mark("beforeIORead");
-          text = host.readFile(fileName, getCompilerOptions().charset);
-          mark("afterIORead");
-          measure("I/O Read", "beforeIORead", "afterIORead");
-        } catch (e) {
-          if (onError) {
-            onError(e.message);
-          }
-          text = "";
-        }
-        return text !== void 0 ? createSourceFile(fileName, text, languageVersionOrOptions) : void 0;
-      },
+      getSourceFile: createGetSourceFile(
+        (fileName, encoding) => host.readFile(fileName, encoding),
+        getCompilerOptions,
+        void 0
+      ),
       getDefaultLibLocation: maybeBind(host, host.getDefaultLibLocation),
       getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
-      writeFile: writeFile2,
+      writeFile: createWriteFileMeasuringIO(
+        (path, data, writeByteOrderMark) => host.writeFile(path, data, writeByteOrderMark),
+        (path) => host.createDirectory(path),
+        (path) => host.directoryExists(path)
+      ),
       getCurrentDirectory: memoize(() => host.getCurrentDirectory()),
       useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
       getCanonicalFileName: createGetCanonicalFileName(useCaseSensitiveFileNames),
@@ -108077,25 +108049,6 @@ ${lanes.join("\n")}
       disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
       storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
     };
-    function writeFile2(fileName, text, writeByteOrderMark, onError) {
-      try {
-        mark("beforeIOWrite");
-        writeFileEnsuringDirectories(
-          fileName,
-          text,
-          writeByteOrderMark,
-          (path, data, writeByteOrderMark2) => host.writeFile(path, data, writeByteOrderMark2),
-          (path) => host.createDirectory(path),
-          (path) => host.directoryExists(path)
-        );
-        mark("afterIOWrite");
-        measure("I/O Write", "beforeIOWrite", "afterIOWrite");
-      } catch (e) {
-        if (onError) {
-          onError(e.message);
-        }
-      }
-    }
   }
   function setGetSourceFileAsHashVersioned(compilerHost, host) {
     const originalGetSourceFile = compilerHost.getSourceFile;
@@ -109606,7 +109559,7 @@ ${lanes.join("\n")}
       return emitDiagnostics;
     }
     function emitBundle(writeFileCallback, customTransformers) {
-      var _a2, _b;
+      var _a2, _b, _c, _d;
       Debug.assert(kind === 1 /* UpdateBundle */);
       if (state.options.dry) {
         reportStatus(state, Diagnostics.A_non_dry_build_would_update_output_of_project_0, project);
@@ -109618,6 +109571,7 @@ ${lanes.join("\n")}
         reportStatus(state, Diagnostics.Updating_output_of_project_0, project);
       const { compilerHost } = state;
       state.projectCompilerOptions = config.options;
+      (_b = (_a2 = state.host).beforeEmitBundle) == null ? void 0 : _b.call(_a2, config);
       const outputFiles = emitUsingBuildInfo(
         config,
         compilerHost,
@@ -109625,7 +109579,7 @@ ${lanes.join("\n")}
           const refName = resolveProjectName(state, ref.path);
           return parseConfigFile(state, refName, toResolvedConfigFilePath(state, refName));
         },
-        customTransformers || ((_b = (_a2 = state.host).getCustomTransformers) == null ? void 0 : _b.call(_a2, project))
+        customTransformers || ((_d = (_c = state.host).getCustomTransformers) == null ? void 0 : _d.call(_c, project))
       );
       if (isString(outputFiles)) {
         reportStatus(state, Diagnostics.Cannot_update_output_of_project_0_because_there_was_error_reading_file_1, project, relName(state, outputFiles));
@@ -111601,6 +111555,7 @@ ${lanes.join("\n")}
     createFunctionTypeNode: () => createFunctionTypeNode,
     createGetAccessor: () => createGetAccessor,
     createGetCanonicalFileName: () => createGetCanonicalFileName,
+    createGetSourceFile: () => createGetSourceFile,
     createGetSymbolAccessibilityDiagnosticForNode: () => createGetSymbolAccessibilityDiagnosticForNode,
     createGetSymbolAccessibilityDiagnosticForNodeName: () => createGetSymbolAccessibilityDiagnosticForNodeName,
     createGetSymbolWalker: () => createGetSymbolWalker,
@@ -111620,6 +111575,8 @@ ${lanes.join("\n")}
     createIndexedAccessTypeNode: () => createIndexedAccessTypeNode,
     createInferTypeNode: () => createInferTypeNode,
     createInputFiles: () => createInputFiles,
+    createInputFilesWithFilePaths: () => createInputFilesWithFilePaths,
+    createInputFilesWithFileTexts: () => createInputFilesWithFileTexts,
     createInterfaceDeclaration: () => createInterfaceDeclaration,
     createIntersectionTypeNode: () => createIntersectionTypeNode,
     createJSDocAugmentsTag: () => createJSDocAugmentsTag,
@@ -111820,6 +111777,7 @@ ${lanes.join("\n")}
     createWatchStatusReporter: () => createWatchStatusReporter,
     createWhile: () => createWhile,
     createWith: () => createWith,
+    createWriteFileMeasuringIO: () => createWriteFileMeasuringIO,
     createYield: () => createYield,
     declarationNameToString: () => declarationNameToString,
     decodeMappings: () => decodeMappings,
@@ -120777,7 +120735,7 @@ ${lanes.join("\n")}
       return !!(this.flags & 3145728 /* UnionOrIntersection */);
     }
     isLiteral() {
-      return !!(this.flags & 384 /* StringOrNumberLiteral */);
+      return !!(this.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */ | 2048 /* BigIntLiteral */));
     }
     isStringLiteral() {
       return !!(this.flags & 128 /* StringLiteral */);
@@ -160789,12 +160747,6 @@ ${e.message}`;
       });
     }
   };
-  var dynamicImport = async (_id) => {
-    throw new Error("Dynamic import not implemented");
-  };
-  function setDynamicImport(fn) {
-    dynamicImport = fn;
-  }
   function createWebSystem(host, args, getExecutingFilePath) {
     const returnEmptyString = () => "";
     const getExecutingDirectoryPath = memoize(() => memoize(() => ensureTrailingDirectorySeparator(getDirectoryPath(getExecutingFilePath()))));
@@ -160831,7 +160783,7 @@ ${e.message}`;
         }
         const scriptPath = combinePaths(packageRoot, browser);
         try {
-          const { default: module2 } = await dynamicImport(scriptPath);
+          const { default: module2 } = await import(scriptPath);
           return { module: module2, error: void 0 };
         } catch (e) {
           return { module: void 0, error: e };