typescript 5.5.0-dev.20240402 → 5.5.0-dev.20240405

package/lib/typescript.js

@@ -163,6 +163,7 @@ __export(typescript_exports, {
   SignatureKind: () => SignatureKind,
   SmartSelectionRange: () => ts_SmartSelectionRange_exports,
   SnippetKind: () => SnippetKind,
+  StatisticType: () => StatisticType,
   StructureIsReused: () => StructureIsReused,
   SymbolAccessibility: () => SymbolAccessibility,
   SymbolDisplay: () => ts_SymbolDisplay_exports,
@@ -411,6 +412,7 @@ __export(typescript_exports, {
   createExternalHelpersImportDeclarationIfNeeded: () => createExternalHelpersImportDeclarationIfNeeded,
   createFileDiagnostic: () => createFileDiagnostic,
   createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain,
+  createFlowNode: () => createFlowNode,
   createForOfBindingStatement: () => createForOfBindingStatement,
   createGetCanonicalFileName: () => createGetCanonicalFileName,
   createGetSourceFile: () => createGetSourceFile,
@@ -542,7 +544,9 @@ __export(typescript_exports, {
   escapeSnippetText: () => escapeSnippetText,
   escapeString: () => escapeString,
   escapeTemplateSubstitution: () => escapeTemplateSubstitution,
+  evaluatorResult: () => evaluatorResult,
   every: () => every,
+  executeCommandLine: () => executeCommandLine,
   expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression,
   explainFiles: () => explainFiles,
   explainIfFileIsRedirectAndImpliedFormat: () => explainIfFileIsRedirectAndImpliedFormat,
@@ -908,6 +912,7 @@ __export(typescript_exports, {
   getNewLineOrDefaultFromHost: () => getNewLineOrDefaultFromHost,
   getNewTargetContainer: () => getNewTargetContainer,
   getNextJSDocCommentLocation: () => getNextJSDocCommentLocation,
+  getNodeChildren: () => getNodeChildren,
   getNodeForGeneratedName: () => getNodeForGeneratedName,
   getNodeId: () => getNodeId,
   getNodeKind: () => getNodeKind,
@@ -1230,6 +1235,7 @@ __export(typescript_exports, {
   isBooleanLiteral: () => isBooleanLiteral,
   isBreakOrContinueStatement: () => isBreakOrContinueStatement,
   isBreakStatement: () => isBreakStatement,
+  isBuild: () => isBuild,
   isBuildInfoFile: () => isBuildInfoFile,
   isBuilderProgram: () => isBuilderProgram2,
   isBundle: () => isBundle,
@@ -1761,7 +1767,6 @@ __export(typescript_exports, {
   isSuperProperty: () => isSuperProperty,
   isSupportedSourceFileName: () => isSupportedSourceFileName,
   isSwitchStatement: () => isSwitchStatement,
-  isSyntacticallyString: () => isSyntacticallyString,
   isSyntaxList: () => isSyntaxList,
   isSyntheticExpression: () => isSyntheticExpression,
   isSyntheticReference: () => isSyntheticReference,
@@ -2093,6 +2098,7 @@ __export(typescript_exports, {
   setInternalEmitFlags: () => setInternalEmitFlags,
   setLocalizedDiagnosticMessages: () => setLocalizedDiagnosticMessages,
   setModuleDefaultHelper: () => setModuleDefaultHelper,
+  setNodeChildren: () => setNodeChildren,
   setNodeFlags: () => setNodeFlags,
   setObjectAllocator: () => setObjectAllocator,
   setOriginalNode: () => setOriginalNode,
@@ -2287,6 +2293,7 @@ __export(typescript_exports, {
   unorderedRemoveItem: () => unorderedRemoveItem,
   unorderedRemoveItemAt: () => unorderedRemoveItemAt,
   unreachableCodeIsError: () => unreachableCodeIsError,
+  unsetNodeChildren: () => unsetNodeChildren,
   unusedLabelIsError: () => unusedLabelIsError,
   unwrapInnermostStatementOfLabel: () => unwrapInnermostStatementOfLabel,
   updateErrorForNoInputFiles: () => updateErrorForNoInputFiles,
@@ -2328,7 +2335,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240402`;
+var version = `${versionMajorMinor}.0-dev.20240405`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4392,6 +4399,7 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
         attachFlowNodeDebugInfoWorker(flowNode);
       }
     }
+    return flowNode;
   }
   Debug2.attachFlowNodeDebugInfo = attachFlowNodeDebugInfo;
   let nodeArrayProto;
@@ -4667,7 +4675,7 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
       return !!(f.flags & 128 /* SwitchClause */);
     }
     function hasAntecedents(f) {
-      return !!(f.flags & 12 /* Label */) && !!f.antecedents;
+      return !!(f.flags & 12 /* Label */) && !!f.antecedent;
     }
     function hasAntecedent(f) {
       return !!(f.flags & hasAntecedentFlags);
@@ -4716,7 +4724,7 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
         links[id] = graphNode = { id, flowNode: flowNode2, edges: [], text: "", lane: -1, endLane: -1, level: -1, circular: false };
         nodes.push(graphNode);
         if (hasAntecedents(flowNode2)) {
-          for (const antecedent of flowNode2.antecedents) {
+          for (const antecedent of flowNode2.antecedent) {
             buildGraphEdge(graphNode, antecedent, seen);
           }
         } else if (hasAntecedent(flowNode2)) {
@@ -4774,7 +4782,7 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
         node.endLane = lane;
       }
     }
-    function getHeader(flags) {
+    function getHeader2(flags) {
       if (flags & 2 /* Start */)
         return "Start";
       if (flags & 4 /* BranchLabel */)
@@ -4809,18 +4817,15 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
       );
     }
     function renderFlowNode(flowNode2, circular) {
-      let text = getHeader(flowNode2.flags);
+      let text = getHeader2(flowNode2.flags);
       if (circular) {
         text = `${text}#${getDebugFlowNodeId(flowNode2)}`;
       }
-      if (hasNode(flowNode2)) {
-        if (flowNode2.node) {
-          text += ` (${getNodeText(flowNode2.node)})`;
-        }
-      } else if (isFlowSwitchClause(flowNode2)) {
+      if (isFlowSwitchClause(flowNode2)) {
         const clauses = [];
-        for (let i = flowNode2.clauseStart; i < flowNode2.clauseEnd; i++) {
-          const clause = flowNode2.switchStatement.caseBlock.clauses[i];
+        const { switchStatement, clauseStart, clauseEnd } = flowNode2.node;
+        for (let i = clauseStart; i < clauseEnd; i++) {
+          const clause = switchStatement.caseBlock.clauses[i];
           if (isDefaultClause(clause)) {
             clauses.push("default");
           } else {
@@ -4828,6 +4833,10 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
           }
         }
         text += ` (${clauses.join(", ")})`;
+      } else if (hasNode(flowNode2)) {
+        if (flowNode2.node) {
+          text += ` (${getNodeText(flowNode2.node)})`;
+        }
       }
       return circular === "circularity" ? `Circular(${text})` : text;
     }
@@ -15549,8 +15558,11 @@ function getTokenPosOfNode(node, sourceFile, includeJsDoc) {
   if (includeJsDoc && hasJSDocNodes(node)) {
     return getTokenPosOfNode(node.jsDoc[0], sourceFile);
   }
-  if (node.kind === 352 /* SyntaxList */ && node._children.length > 0) {
-    return getTokenPosOfNode(node._children[0], sourceFile, includeJsDoc);
+  if (node.kind === 352 /* SyntaxList */) {
+    const first2 = firstOrUndefined(getNodeChildren(node));
+    if (first2) {
+      return getTokenPosOfNode(first2, sourceFile, includeJsDoc);
+    }
   }
   return skipTrivia(
     (sourceFile || getSourceFileOfNode(node)).text,
@@ -21926,79 +21938,81 @@ function replaceFirstStar(s, replacement) {
 function getNameFromImportAttribute(node) {
   return isIdentifier(node.name) ? node.name.escapedText : escapeLeadingUnderscores(node.name.text);
 }
-function isSyntacticallyString(expr) {
-  expr = skipOuterExpressions(expr);
-  switch (expr.kind) {
-    case 226 /* BinaryExpression */:
-      const left = expr.left;
-      const right = expr.right;
-      return expr.operatorToken.kind === 40 /* PlusToken */ && (isSyntacticallyString(left) || isSyntacticallyString(right));
-    case 228 /* TemplateExpression */:
-    case 11 /* StringLiteral */:
-    case 15 /* NoSubstitutionTemplateLiteral */:
-      return true;
-  }
-  return false;
+function evaluatorResult(value, isSyntacticallyString = false, resolvedOtherFiles = false) {
+  return { value, isSyntacticallyString, resolvedOtherFiles };
 }
 function createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameExpression }) {
   function evaluate(expr, location) {
+    let isSyntacticallyString = false;
+    let resolvedOtherFiles = false;
+    expr = skipParentheses(expr);
     switch (expr.kind) {
       case 224 /* PrefixUnaryExpression */:
-        const value = evaluate(expr.operand, location);
-        if (typeof value === "number") {
+        const result = evaluate(expr.operand, location);
+        resolvedOtherFiles = result.resolvedOtherFiles;
+        if (typeof result.value === "number") {
           switch (expr.operator) {
             case 40 /* PlusToken */:
-              return value;
+              return evaluatorResult(result.value, isSyntacticallyString, resolvedOtherFiles);
             case 41 /* MinusToken */:
-              return -value;
+              return evaluatorResult(-result.value, isSyntacticallyString, resolvedOtherFiles);
             case 55 /* TildeToken */:
-              return ~value;
+              return evaluatorResult(~result.value, isSyntacticallyString, resolvedOtherFiles);
           }
         }
         break;
-      case 226 /* BinaryExpression */:
+      case 226 /* BinaryExpression */: {
         const left = evaluate(expr.left, location);
         const right = evaluate(expr.right, location);
-        if (typeof left === "number" && typeof right === "number") {
+        isSyntacticallyString = (left.isSyntacticallyString || right.isSyntacticallyString) && expr.operatorToken.kind === 40 /* PlusToken */;
+        resolvedOtherFiles = left.resolvedOtherFiles || right.resolvedOtherFiles;
+        if (typeof left.value === "number" && typeof right.value === "number") {
           switch (expr.operatorToken.kind) {
             case 52 /* BarToken */:
-              return left | right;
+              return evaluatorResult(left.value | right.value, isSyntacticallyString, resolvedOtherFiles);
             case 51 /* AmpersandToken */:
-              return left & right;
+              return evaluatorResult(left.value & right.value, isSyntacticallyString, resolvedOtherFiles);
             case 49 /* GreaterThanGreaterThanToken */:
-              return left >> right;
+              return evaluatorResult(left.value >> right.value, isSyntacticallyString, resolvedOtherFiles);
             case 50 /* GreaterThanGreaterThanGreaterThanToken */:
-              return left >>> right;
+              return evaluatorResult(left.value >>> right.value, isSyntacticallyString, resolvedOtherFiles);
             case 48 /* LessThanLessThanToken */:
-              return left << right;
+              return evaluatorResult(left.value << right.value, isSyntacticallyString, resolvedOtherFiles);
             case 53 /* CaretToken */:
-              return left ^ right;
+              return evaluatorResult(left.value ^ right.value, isSyntacticallyString, resolvedOtherFiles);
             case 42 /* AsteriskToken */:
-              return left * right;
+              return evaluatorResult(left.value * right.value, isSyntacticallyString, resolvedOtherFiles);
             case 44 /* SlashToken */:
-              return left / right;
+              return evaluatorResult(left.value / right.value, isSyntacticallyString, resolvedOtherFiles);
             case 40 /* PlusToken */:
-              return left + right;
+              return evaluatorResult(left.value + right.value, isSyntacticallyString, resolvedOtherFiles);
             case 41 /* MinusToken */:
-              return left - right;
+              return evaluatorResult(left.value - right.value, isSyntacticallyString, resolvedOtherFiles);
             case 45 /* PercentToken */:
-              return left % right;
+              return evaluatorResult(left.value % right.value, isSyntacticallyString, resolvedOtherFiles);
             case 43 /* AsteriskAsteriskToken */:
-              return left ** right;
+              return evaluatorResult(left.value ** right.value, isSyntacticallyString, resolvedOtherFiles);
           }
-        } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
-          return "" + left + right;
+        } else if ((typeof left.value === "string" || typeof left.value === "number") && (typeof right.value === "string" || typeof right.value === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
+          return evaluatorResult(
+            "" + left.value + right.value,
+            isSyntacticallyString,
+            resolvedOtherFiles
+          );
         }
         break;
+      }
       case 11 /* StringLiteral */:
       case 15 /* NoSubstitutionTemplateLiteral */:
-        return expr.text;
+        return evaluatorResult(
+          expr.text,
+          /*isSyntacticallyString*/
+          true
+        );
       case 228 /* TemplateExpression */:
         return evaluateTemplateExpression(expr, location);
       case 9 /* NumericLiteral */:
-        return +expr.text;
-      case 217 /* ParenthesizedExpression */:
-        return evaluate(expr.expression, location);
+        return evaluatorResult(+expr.text);
       case 80 /* Identifier */:
         return evaluateEntityNameExpression(expr, location);
       case 211 /* PropertyAccessExpression */:
@@ -22009,19 +22023,36 @@ function createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameEx
       case 212 /* ElementAccessExpression */:
         return evaluateElementAccessExpression(expr, location);
     }
-    return void 0;
+    return evaluatorResult(
+      /*value*/
+      void 0,
+      isSyntacticallyString,
+      resolvedOtherFiles
+    );
   }
   function evaluateTemplateExpression(expr, location) {
     let result = expr.head.text;
+    let resolvedOtherFiles = false;
     for (const span of expr.templateSpans) {
-      const value = evaluate(span.expression, location);
-      if (value === void 0) {
-        return void 0;
+      const spanResult = evaluate(span.expression, location);
+      if (spanResult.value === void 0) {
+        return evaluatorResult(
+          /*value*/
+          void 0,
+          /*isSyntacticallyString*/
+          true
+        );
       }
-      result += value;
+      result += spanResult.value;
       result += span.literal.text;
+      resolvedOtherFiles || (resolvedOtherFiles = spanResult.resolvedOtherFiles);
     }
-    return result;
+    return evaluatorResult(
+      result,
+      /*isSyntacticallyString*/
+      true,
+      resolvedOtherFiles
+    );
   }
   return evaluate;
 }
@@ -26176,7 +26207,7 @@ function createNodeFactory(flags, baseFactory2) {
   }
   function createSyntaxList3(children) {
     const node = createBaseNode(352 /* SyntaxList */);
-    node._children = children;
+    setNodeChildren(node, children);
     return node;
   }
   function createNotEmittedStatement(original) {
@@ -29084,6 +29115,19 @@ function isSyntaxList(n) {
   return n.kind === 352 /* SyntaxList */;
 }
 
+// src/compiler/factory/nodeChildren.ts
+var nodeChildren = /* @__PURE__ */ new WeakMap();
+function getNodeChildren(node) {
+  return nodeChildren.get(node);
+}
+function setNodeChildren(node, children) {
+  nodeChildren.set(node, children);
+  return children;
+}
+function unsetNodeChildren(node) {
+  nodeChildren.delete(node);
+}
+
 // src/compiler/factory/utilities.ts
 function createEmptyExports(factory2) {
   return factory2.createExportDeclaration(
@@ -37756,9 +37800,7 @@ var IncrementalParser;
       if (aggressiveChecks && shouldCheckNode(node)) {
         text = oldText.substring(node.pos, node.end);
       }
-      if (node._children) {
-        node._children = void 0;
-      }
+      unsetNodeChildren(node);
       setTextRangePosEnd(node, node.pos + delta, node.end + delta);
       if (aggressiveChecks && shouldCheckNode(node)) {
         Debug.assert(text === newText.substring(node.pos, node.end));
@@ -37772,7 +37814,6 @@ var IncrementalParser;
       checkNodePositions(node, aggressiveChecks);
     }
     function visitArray2(array) {
-      array._children = void 0;
       setTextRangePosEnd(array, array.pos + delta, array.end + delta);
       for (const node of array) {
         visitNode3(node);
@@ -37844,7 +37885,7 @@ var IncrementalParser;
       const fullEnd = child.end;
       if (fullEnd >= changeStart) {
         child.intersectsChange = true;
-        child._children = void 0;
+        unsetNodeChildren(child);
         adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
         forEachChild(child, visitNode3, visitArray2);
         if (hasJSDocNodes(child)) {
@@ -37874,7 +37915,6 @@ var IncrementalParser;
       const fullEnd = array.end;
       if (fullEnd >= changeStart) {
         array.intersectsChange = true;
-        array._children = void 0;
         adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
         for (const node of array) {
           visitNode3(node);
@@ -44272,9 +44312,8 @@ var ContainerFlags = /* @__PURE__ */ ((ContainerFlags2) => {
   ContainerFlags2[ContainerFlags2["IsObjectLiteralOrClassExpressionMethodOrAccessor"] = 128] = "IsObjectLiteralOrClassExpressionMethodOrAccessor";
   return ContainerFlags2;
 })(ContainerFlags || {});
-function initFlowNode(node) {
-  Debug.attachFlowNodeDebugInfo(node);
-  return node;
+function createFlowNode(flags, node, antecedent) {
+  return Debug.attachFlowNodeDebugInfo({ flags, id: 0, node, antecedent });
 }
 var binder = /* @__PURE__ */ createBinder();
 function bindSourceFile(file, options) {
@@ -44308,14 +44347,27 @@ function createBinder() {
   var preSwitchCaseFlow;
   var activeLabelList;
   var hasExplicitReturn;
+  var hasFlowEffects;
   var emitFlags;
   var inStrictMode;
   var inAssignmentPattern = false;
   var symbolCount = 0;
   var Symbol47;
   var classifiableNames;
-  var unreachableFlow = { flags: 1 /* Unreachable */ };
-  var reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
+  var unreachableFlow = createFlowNode(
+    1 /* Unreachable */,
+    /*node*/
+    void 0,
+    /*antecedent*/
+    void 0
+  );
+  var reportedUnreachableFlow = createFlowNode(
+    1 /* Unreachable */,
+    /*node*/
+    void 0,
+    /*antecedent*/
+    void 0
+  );
   var bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
   return bindSourceFile2;
   function createDiagnosticForNode2(node, message, ...args) {
@@ -44367,6 +44419,7 @@ function createBinder() {
     currentExceptionTarget = void 0;
     activeLabelList = void 0;
     hasExplicitReturn = false;
+    hasFlowEffects = false;
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
   }
@@ -44634,7 +44687,13 @@ function createBinder() {
       const saveHasExplicitReturn = hasExplicitReturn;
       const isImmediatelyInvoked = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 1024 /* Async */) && !node.asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 175 /* ClassStaticBlockDeclaration */;
       if (!isImmediatelyInvoked) {
-        currentFlow = initFlowNode({ flags: 2 /* Start */ });
+        currentFlow = createFlowNode(
+          2 /* Start */,
+          /*node*/
+          void 0,
+          /*antecedent*/
+          void 0
+        );
         if (containerFlags & (16 /* IsFunctionExpression */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */)) {
           currentFlow.node = node;
         }
@@ -44824,8 +44883,8 @@ function createBinder() {
   function isNarrowingExpression(expr) {
     switch (expr.kind) {
       case 80 /* Identifier */:
-      case 81 /* PrivateIdentifier */:
       case 110 /* ThisKeyword */:
+        return true;
       case 211 /* PropertyAccessExpression */:
       case 212 /* ElementAccessExpression */:
         return containsNarrowableReference(expr);
@@ -44847,7 +44906,22 @@ function createBinder() {
     return false;
   }
   function isNarrowableReference(expr) {
-    return isDottedName(expr) || (isPropertyAccessExpression(expr) || isNonNullExpression(expr) || isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) || isBinaryExpression(expr) && expr.operatorToken.kind === 28 /* CommaToken */ && isNarrowableReference(expr.right) || isElementAccessExpression(expr) && (isStringOrNumericLiteralLike(expr.argumentExpression) || isEntityNameExpression(expr.argumentExpression)) && isNarrowableReference(expr.expression) || isAssignmentExpression(expr) && isNarrowableReference(expr.left);
+    switch (expr.kind) {
+      case 80 /* Identifier */:
+      case 110 /* ThisKeyword */:
+      case 108 /* SuperKeyword */:
+      case 236 /* MetaProperty */:
+        return true;
+      case 211 /* PropertyAccessExpression */:
+      case 217 /* ParenthesizedExpression */:
+      case 235 /* NonNullExpression */:
+        return isNarrowableReference(expr.expression);
+      case 212 /* ElementAccessExpression */:
+        return (isStringOrNumericLiteralLike(expr.argumentExpression) || isEntityNameExpression(expr.argumentExpression)) && isNarrowableReference(expr.expression);
+      case 226 /* BinaryExpression */:
+        return expr.operatorToken.kind === 28 /* CommaToken */ && isNarrowableReference(expr.right) || isAssignmentOperator(expr.operatorToken.kind) && isLeftHandSideExpression(expr.left);
+    }
+    return false;
   }
   function containsNarrowableReference(expr) {
     return isNarrowableReference(expr) || isOptionalChain(expr) && containsNarrowableReference(expr.expression);
@@ -44904,20 +44978,32 @@ function createBinder() {
     return containsNarrowableReference(expr);
   }
   function createBranchLabel() {
-    return initFlowNode({ flags: 4 /* BranchLabel */, antecedents: void 0 });
+    return createFlowNode(
+      4 /* BranchLabel */,
+      /*node*/
+      void 0,
+      /*antecedent*/
+      void 0
+    );
   }
   function createLoopLabel() {
-    return initFlowNode({ flags: 8 /* LoopLabel */, antecedents: void 0 });
+    return createFlowNode(
+      8 /* LoopLabel */,
+      /*node*/
+      void 0,
+      /*antecedent*/
+      void 0
+    );
   }
   function createReduceLabel(target, antecedents, antecedent) {
-    return initFlowNode({ flags: 1024 /* ReduceLabel */, target, antecedents, antecedent });
+    return createFlowNode(1024 /* ReduceLabel */, { target, antecedents }, antecedent);
   }
   function setFlowNodeReferenced(flow) {
     flow.flags |= flow.flags & 2048 /* Referenced */ ? 4096 /* Shared */ : 2048 /* Referenced */;
   }
   function addAntecedent(label, antecedent) {
-    if (!(antecedent.flags & 1 /* Unreachable */) && !contains(label.antecedents, antecedent)) {
-      (label.antecedents || (label.antecedents = [])).push(antecedent);
+    if (!(antecedent.flags & 1 /* Unreachable */) && !contains(label.antecedent, antecedent)) {
+      (label.antecedent || (label.antecedent = [])).push(antecedent);
       setFlowNodeReferenced(antecedent);
     }
   }
@@ -44935,15 +45021,16 @@ function createBinder() {
       return antecedent;
     }
     setFlowNodeReferenced(antecedent);
-    return initFlowNode({ flags, antecedent, node: expression });
+    return createFlowNode(flags, expression, antecedent);
   }
   function createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) {
     setFlowNodeReferenced(antecedent);
-    return initFlowNode({ flags: 128 /* SwitchClause */, antecedent, switchStatement, clauseStart, clauseEnd });
+    return createFlowNode(128 /* SwitchClause */, { switchStatement, clauseStart, clauseEnd }, antecedent);
   }
   function createFlowMutation(flags, antecedent, node) {
     setFlowNodeReferenced(antecedent);
-    const result = initFlowNode({ flags, antecedent, node });
+    hasFlowEffects = true;
+    const result = createFlowNode(flags, node, antecedent);
     if (currentExceptionTarget) {
       addAntecedent(currentExceptionTarget, result);
     }
@@ -44951,10 +45038,11 @@ function createBinder() {
   }
   function createFlowCall(antecedent, node) {
     setFlowNodeReferenced(antecedent);
-    return initFlowNode({ flags: 512 /* Call */, antecedent, node });
+    hasFlowEffects = true;
+    return createFlowNode(512 /* Call */, node, antecedent);
   }
   function finishFlowLabel(flow) {
-    const antecedents = flow.antecedents;
+    const antecedents = flow.antecedent;
     if (!antecedents) {
       return unreachableFlow;
     }
@@ -45108,6 +45196,7 @@ function createBinder() {
       }
     }
     currentFlow = unreachableFlow;
+    hasFlowEffects = true;
   }
   function findActiveLabel(name) {
     for (let label = activeLabelList; label; label = label.next) {
@@ -45122,6 +45211,7 @@ function createBinder() {
     if (flowLabel) {
       addAntecedent(flowLabel, currentFlow);
       currentFlow = unreachableFlow;
+      hasFlowEffects = true;
     }
   }
   function bindBreakOrContinueStatement(node) {
@@ -45161,19 +45251,19 @@ function createBinder() {
     currentExceptionTarget = saveExceptionTarget;
     if (node.finallyBlock) {
       const finallyLabel = createBranchLabel();
-      finallyLabel.antecedents = concatenate(concatenate(normalExitLabel.antecedents, exceptionLabel.antecedents), returnLabel.antecedents);
+      finallyLabel.antecedent = concatenate(concatenate(normalExitLabel.antecedent, exceptionLabel.antecedent), returnLabel.antecedent);
       currentFlow = finallyLabel;
       bind(node.finallyBlock);
       if (currentFlow.flags & 1 /* Unreachable */) {
         currentFlow = unreachableFlow;
       } else {
-        if (currentReturnTarget && returnLabel.antecedents) {
-          addAntecedent(currentReturnTarget, createReduceLabel(finallyLabel, returnLabel.antecedents, currentFlow));
+        if (currentReturnTarget && returnLabel.antecedent) {
+          addAntecedent(currentReturnTarget, createReduceLabel(finallyLabel, returnLabel.antecedent, currentFlow));
         }
-        if (currentExceptionTarget && exceptionLabel.antecedents) {
-          addAntecedent(currentExceptionTarget, createReduceLabel(finallyLabel, exceptionLabel.antecedents, currentFlow));
+        if (currentExceptionTarget && exceptionLabel.antecedent) {
+          addAntecedent(currentExceptionTarget, createReduceLabel(finallyLabel, exceptionLabel.antecedent, currentFlow));
         }
-        currentFlow = normalExitLabel.antecedents ? createReduceLabel(finallyLabel, normalExitLabel.antecedents, currentFlow) : unreachableFlow;
+        currentFlow = normalExitLabel.antecedent ? createReduceLabel(finallyLabel, normalExitLabel.antecedent, currentFlow) : unreachableFlow;
       }
     } else {
       currentFlow = finishFlowLabel(normalExitLabel);
@@ -45189,7 +45279,7 @@ function createBinder() {
     bind(node.caseBlock);
     addAntecedent(postSwitchLabel, currentFlow);
     const hasDefault = forEach(node.caseBlock.clauses, (c) => c.kind === 297 /* DefaultClause */);
-    node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents;
+    node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedent;
     if (!hasDefault) {
       addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0));
     }
@@ -45377,8 +45467,12 @@ function createBinder() {
       if (isLogicalOrCoalescingBinaryOperator(operator) || isLogicalOrCoalescingAssignmentOperator(operator)) {
         if (isTopLevelLogicalExpression(node)) {
           const postExpressionLabel = createBranchLabel();
+          const saveCurrentFlow = currentFlow;
+          const saveHasFlowEffects = hasFlowEffects;
+          hasFlowEffects = false;
           bindLogicalLikeExpression(node, postExpressionLabel, postExpressionLabel);
-          currentFlow = finishFlowLabel(postExpressionLabel);
+          currentFlow = hasFlowEffects ? finishFlowLabel(postExpressionLabel) : saveCurrentFlow;
+          hasFlowEffects || (hasFlowEffects = saveHasFlowEffects);
         } else {
           bindLogicalLikeExpression(node, currentTrueTarget, currentFalseTarget);
         }
@@ -45450,6 +45544,9 @@ function createBinder() {
     const trueLabel = createBranchLabel();
     const falseLabel = createBranchLabel();
     const postExpressionLabel = createBranchLabel();
+    const saveCurrentFlow = currentFlow;
+    const saveHasFlowEffects = hasFlowEffects;
+    hasFlowEffects = false;
     bindCondition(node.condition, trueLabel, falseLabel);
     currentFlow = finishFlowLabel(trueLabel);
     bind(node.questionToken);
@@ -45459,7 +45556,8 @@ function createBinder() {
     bind(node.colonToken);
     bind(node.whenFalse);
     addAntecedent(postExpressionLabel, currentFlow);
-    currentFlow = finishFlowLabel(postExpressionLabel);
+    currentFlow = hasFlowEffects ? finishFlowLabel(postExpressionLabel) : saveCurrentFlow;
+    hasFlowEffects || (hasFlowEffects = saveHasFlowEffects);
   }
   function bindInitializedVariableFlow(node) {
     const name = !isOmittedExpression(node) ? node.name : void 0;
@@ -45571,8 +45669,11 @@ function createBinder() {
   function bindOptionalChainFlow(node) {
     if (isTopLevelLogicalExpression(node)) {
       const postExpressionLabel = createBranchLabel();
+      const saveCurrentFlow = currentFlow;
+      const saveHasFlowEffects = hasFlowEffects;
       bindOptionalChain(node, postExpressionLabel, postExpressionLabel);
-      currentFlow = finishFlowLabel(postExpressionLabel);
+      currentFlow = hasFlowEffects ? finishFlowLabel(postExpressionLabel) : saveCurrentFlow;
+      hasFlowEffects || (hasFlowEffects = saveHasFlowEffects);
     } else {
       bindOptionalChain(node, currentTrueTarget, currentFalseTarget);
     }
@@ -45793,7 +45894,13 @@ function createBinder() {
       const host = typeAlias.parent.parent;
       container = getEnclosingContainer(host) || file;
       blockScopeContainer = getEnclosingBlockScopeContainer(host) || file;
-      currentFlow = initFlowNode({ flags: 2 /* Start */ });
+      currentFlow = createFlowNode(
+        2 /* Start */,
+        /*node*/
+        void 0,
+        /*antecedent*/
+        void 0
+      );
       parent2 = typeAlias;
       bind(typeAlias.typeExpression);
       const declName = getNameOfDeclaration(typeAlias);
@@ -45863,7 +45970,13 @@ function createBinder() {
       const enclosingBlockScopeContainer = host ? getEnclosingBlockScopeContainer(host) : void 0;
       container = enclosingContainer || file;
       blockScopeContainer = enclosingBlockScopeContainer || file;
-      currentFlow = initFlowNode({ flags: 2 /* Start */ });
+      currentFlow = createFlowNode(
+        2 /* Start */,
+        /*node*/
+        void 0,
+        /*antecedent*/
+        void 0
+      );
       parent2 = jsDocImportTag;
       bind(jsDocImportTag.importClause);
     }
@@ -48307,6 +48420,7 @@ function createTypeChecker(host) {
     isArgumentsSymbol: (symbol) => symbol === argumentsSymbol,
     isUnknownSymbol: (symbol) => symbol === unknownSymbol,
     getMergedSymbol,
+    symbolIsValue,
     getDiagnostics: getDiagnostics2,
     getGlobalDiagnostics,
     getRecursionIdentity,
@@ -52615,7 +52729,7 @@ function createTypeChecker(host) {
   }
   function getMeaningOfEntityNameReference(entityName) {
     let meaning;
-    if (entityName.parent.kind === 186 /* TypeQuery */ || entityName.parent.kind === 233 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 167 /* ComputedPropertyName */) {
+    if (entityName.parent.kind === 186 /* TypeQuery */ || entityName.parent.kind === 233 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 167 /* ComputedPropertyName */ || entityName.parent.kind === 182 /* TypePredicate */ && entityName.parent.parameterName === entityName) {
       meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
     } else if (entityName.kind === 166 /* QualifiedName */ || entityName.kind === 211 /* PropertyAccessExpression */ || entityName.parent.kind === 271 /* ImportEqualsDeclaration */ || entityName.parent.kind === 166 /* QualifiedName */ && entityName.parent.left === entityName || entityName.parent.kind === 211 /* PropertyAccessExpression */ && entityName.parent.expression === entityName || entityName.parent.kind === 212 /* ElementAccessExpression */ && entityName.parent.expression === entityName) {
       meaning = 1920 /* Namespace */;
@@ -53875,68 +53989,7 @@ function createTypeChecker(host) {
         /*skipUnionExpanding*/
         true
       )[0];
-      let cleanup;
-      if (context.enclosingDeclaration && signature.declaration && signature.declaration !== context.enclosingDeclaration && !isInJSFile(signature.declaration) && (some(expandedParams) || some(signature.typeParameters))) {
-        let pushFakeScope2 = function(kind2, addAll) {
-          Debug.assert(context.enclosingDeclaration);
-          let existingFakeScope;
-          if (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration === kind2) {
-            existingFakeScope = context.enclosingDeclaration;
-          } else if (context.enclosingDeclaration.parent && getNodeLinks(context.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === kind2) {
-            existingFakeScope = context.enclosingDeclaration.parent;
-          }
-          Debug.assertOptionalNode(existingFakeScope, isBlock);
-          const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
-          let newLocals;
-          addAll((name, symbol) => {
-            if (!locals.has(name)) {
-              newLocals = append(newLocals, name);
-              locals.set(name, symbol);
-            }
-          });
-          if (!newLocals)
-            return;
-          const oldCleanup = cleanup;
-          function undo() {
-            forEach(newLocals, (s) => locals.delete(s));
-            oldCleanup == null ? void 0 : oldCleanup();
-          }
-          if (existingFakeScope) {
-            cleanup = undo;
-          } else {
-            const fakeScope = parseNodeFactory.createBlock(emptyArray);
-            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind2;
-            fakeScope.locals = locals;
-            const saveEnclosingDeclaration = context.enclosingDeclaration;
-            setParent(fakeScope, saveEnclosingDeclaration);
-            context.enclosingDeclaration = fakeScope;
-            cleanup = () => {
-              context.enclosingDeclaration = saveEnclosingDeclaration;
-              undo();
-            };
-          }
-        };
-        var pushFakeScope = pushFakeScope2;
-        pushFakeScope2(
-          "params",
-          (add) => {
-            for (const param of expandedParams) {
-              add(param.escapedName, param);
-            }
-          }
-        );
-        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
-          pushFakeScope2(
-            "typeParams",
-            (add) => {
-              for (const typeParam of signature.typeParameters ?? emptyArray) {
-                const typeParamName = typeParameterToName(typeParam, context).escapedText;
-                add(typeParamName, typeParam.symbol);
-              }
-            }
-          );
-        }
-      }
+      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters);
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
@@ -54027,6 +54080,111 @@ function createTypeChecker(host) {
       cleanup == null ? void 0 : cleanup();
       return node;
     }
+    function isNewScopeNode(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) || isMappedTypeNode(node);
+    }
+    function getTypeParametersInScope(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).typeParameters : isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
+    }
+    function getParametersInScope(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getExpandedParameters(
+        getSignatureFromDeclaration(node),
+        /*skipUnionExpanding*/
+        true
+      )[0] : void 0;
+    }
+    function enterNewScope(context, declaration, expandedParams, typeParameters) {
+      let cleanup;
+      if (context.enclosingDeclaration && declaration && declaration !== context.enclosingDeclaration && !isInJSFile(declaration) && (some(expandedParams) || some(typeParameters))) {
+        let pushFakeScope2 = function(kind, addAll) {
+          Debug.assert(context.enclosingDeclaration);
+          let existingFakeScope;
+          if (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration === kind) {
+            existingFakeScope = context.enclosingDeclaration;
+          } else if (context.enclosingDeclaration.parent && getNodeLinks(context.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === kind) {
+            existingFakeScope = context.enclosingDeclaration.parent;
+          }
+          Debug.assertOptionalNode(existingFakeScope, isBlock);
+          const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
+          let newLocals;
+          addAll((name, symbol) => {
+            if (!locals.has(name)) {
+              newLocals = append(newLocals, name);
+              locals.set(name, symbol);
+            }
+          });
+          if (!newLocals)
+            return;
+          const oldCleanup = cleanup;
+          function undo() {
+            forEach(newLocals, (s) => locals.delete(s));
+            oldCleanup == null ? void 0 : oldCleanup();
+          }
+          if (existingFakeScope) {
+            cleanup = undo;
+          } else {
+            const fakeScope = parseNodeFactory.createBlock(emptyArray);
+            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind;
+            fakeScope.locals = locals;
+            const saveEnclosingDeclaration = context.enclosingDeclaration;
+            setParent(fakeScope, saveEnclosingDeclaration);
+            context.enclosingDeclaration = fakeScope;
+            cleanup = () => {
+              context.enclosingDeclaration = saveEnclosingDeclaration;
+              undo();
+            };
+          }
+        };
+        var pushFakeScope = pushFakeScope2;
+        pushFakeScope2(
+          "params",
+          (add) => {
+            for (const param of expandedParams ?? emptyArray) {
+              if (!forEach(param.declarations, (d) => {
+                if (isParameter(d) && isBindingPattern(d.name)) {
+                  bindPattern(d.name);
+                  return true;
+                }
+                return void 0;
+                function bindPattern(p) {
+                  forEach(p.elements, (e) => {
+                    switch (e.kind) {
+                      case 232 /* OmittedExpression */:
+                        return;
+                      case 208 /* BindingElement */:
+                        return bindElement(e);
+                      default:
+                        return Debug.assertNever(e);
+                    }
+                  });
+                }
+                function bindElement(e) {
+                  if (isBindingPattern(e.name)) {
+                    return bindPattern(e.name);
+                  }
+                  const symbol = getSymbolOfDeclaration(e);
+                  add(symbol.escapedName, symbol);
+                }
+              })) {
+                add(param.escapedName, param);
+              }
+            }
+          }
+        );
+        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+          pushFakeScope2(
+            "typeParams",
+            (add) => {
+              for (const typeParam of typeParameters ?? emptyArray) {
+                const typeParamName = typeParameterToName(typeParam, context).escapedText;
+                add(typeParamName, typeParam.symbol);
+              }
+            }
+          );
+        }
+        return cleanup;
+      }
+    }
     function tryGetThisParameterDeclaration(signature, context) {
       if (signature.thisParameter) {
         return symbolToParameterDeclaration(signature.thisParameter, context);
@@ -54645,6 +54803,9 @@ function createTypeChecker(host) {
       if (initial.typeParameterSymbolList) {
         initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
       }
+      if (initial.typeParameterNamesByTextNextNameCount) {
+        initial.typeParameterNamesByTextNextNameCount = new Map(initial.typeParameterNamesByTextNextNameCount);
+      }
       initial.tracker = new SymbolTrackerImpl(initial, initial.tracker.inner, initial.tracker.moduleResolverHost);
       return initial;
     }
@@ -54652,7 +54813,16 @@ function createTypeChecker(host) {
       return symbol.declarations && find(symbol.declarations, (s) => !!getNonlocalEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
     }
     function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
-      return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
+      if (!(getObjectFlags(type) & 4 /* Reference */))
+        return true;
+      if (!isTypeReferenceNode(existing))
+        return true;
+      void getTypeFromTypeReference(existing);
+      const symbol = getNodeLinks(existing).resolvedSymbol;
+      const existingTarget = symbol && getDeclaredTypeOfSymbol(symbol);
+      if (!existingTarget || existingTarget !== type.target)
+        return true;
+      return length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
     }
     function getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration) {
       while (getNodeLinks(enclosingDeclaration).fakeScopeForSignatureDeclaration) {
@@ -54735,7 +54905,28 @@ function createTypeChecker(host) {
         return { introducesError, node };
       }
       const meaning = getMeaningOfEntityNameReference(node);
-      const sym = resolveEntityName(
+      let sym;
+      if (isThisIdentifier(leftmost)) {
+        sym = getSymbolOfDeclaration(getThisContainer(
+          leftmost,
+          /*includeArrowFunctions*/
+          false,
+          /*includeClassComputedPropertyName*/
+          false
+        ));
+        if (isSymbolAccessible(
+          sym,
+          leftmost,
+          meaning,
+          /*shouldComputeAliasesToMakeVisible*/
+          false
+        ).accessibility !== 0 /* Accessible */) {
+          introducesError = true;
+          context.tracker.reportInaccessibleThisError();
+        }
+        return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
+      }
+      sym = resolveEntityName(
         leftmost,
         meaning,
         /*ignoreErrors*/
@@ -54744,27 +54935,44 @@ function createTypeChecker(host) {
         true
       );
       if (sym) {
-        if (isSymbolAccessible(
+        if (sym.flags & 1 /* FunctionScopedVariable */ && sym.valueDeclaration) {
+          if (isParameterDeclaration(sym.valueDeclaration)) {
+            return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
+          }
+        }
+        if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the curent context if they are are resolvable
+        !isDeclarationName(node) && isSymbolAccessible(
           sym,
           context.enclosingDeclaration,
           meaning,
           /*shouldComputeAliasesToMakeVisible*/
           false
         ).accessibility !== 0 /* Accessible */) {
-          if (!isDeclarationName(node)) {
-            introducesError = true;
-          }
+          introducesError = true;
         } else {
           context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
         }
-        if (isIdentifier(node)) {
+        return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
+      }
+      return { introducesError, node };
+      function attachSymbolToLeftmostIdentifier(node2) {
+        if (node2 === leftmost) {
           const type = getDeclaredTypeOfSymbol(sym);
-          const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node);
+          const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node2);
           name.symbol = sym;
-          return { introducesError, node: setTextRange(setEmitFlags(setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */), node) };
+          return setTextRange(setEmitFlags(setOriginalNode(name, node2), 16777216 /* NoAsciiEscaping */), node2);
         }
+        const updated = visitEachChild(
+          node2,
+          (c) => attachSymbolToLeftmostIdentifier(c),
+          /*context*/
+          void 0
+        );
+        if (updated !== node2) {
+          setTextRange(updated, node2);
+        }
+        return updated;
       }
-      return { introducesError, node };
     }
     function tryReuseExistingTypeNodeHelper(context, existing) {
       if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
@@ -54777,6 +54985,22 @@ function createTypeChecker(host) {
       }
       return transformed === existing ? setTextRange(factory.cloneNode(existing), existing) : transformed;
       function visitExistingNodeTreeSymbols(node) {
+        const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
+        const result = visitExistingNodeTreeSymbolsWorker(node);
+        onExitNewScope == null ? void 0 : onExitNewScope();
+        return result;
+      }
+      function onEnterNewScope(node) {
+        const oldContex = context;
+        context = cloneNodeBuilderContext(context);
+        const cleanup = enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
+        return onExitNewScope;
+        function onExitNewScope() {
+          cleanup == null ? void 0 : cleanup();
+          context = oldContex;
+        }
+      }
+      function visitExistingNodeTreeSymbolsWorker(node) {
         if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) {
           return factory.createKeywordTypeNode(133 /* AnyKeyword */);
         }
@@ -54909,11 +55133,12 @@ function createTypeChecker(host) {
           return visited;
         }
         if (isEntityName(node) || isEntityNameExpression(node)) {
+          if (isDeclarationName(node)) {
+            return node;
+          }
           const { introducesError, node: result } = trackExistingEntityName(node, context);
           hadError = hadError || introducesError;
-          if (result !== node) {
-            return result;
-          }
+          return result;
         }
         if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
           const visited = visitEachChild(
@@ -54927,6 +55152,21 @@ function createTypeChecker(host) {
           setEmitFlags(clone2, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
           return clone2;
         }
+        if (isConditionalTypeNode(node)) {
+          const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode);
+          const disposeScope = onEnterNewScope(node);
+          const extendType = visitNode(node.extendsType, visitExistingNodeTreeSymbols, isTypeNode);
+          const trueType2 = visitNode(node.trueType, visitExistingNodeTreeSymbols, isTypeNode);
+          disposeScope();
+          const falseType2 = visitNode(node.falseType, visitExistingNodeTreeSymbols, isTypeNode);
+          return factory.updateConditionalTypeNode(
+            node,
+            checkType,
+            extendType,
+            trueType2,
+            falseType2
+          );
+        }
         return visitEachChild(
           node,
           visitExistingNodeTreeSymbols,
@@ -57068,6 +57308,9 @@ function createTypeChecker(host) {
       }
     }
     if (isParameter(declaration)) {
+      if (!declaration.symbol) {
+        return;
+      }
       const func = declaration.parent;
       if (func.kind === 178 /* SetAccessor */ && hasBindableName(func)) {
         const getter = getDeclarationOfKind(getSymbolOfDeclaration(declaration.parent), 177 /* GetAccessor */);
@@ -58427,7 +58670,7 @@ function createTypeChecker(host) {
             for (const member of declaration.members) {
               if (hasBindableName(member)) {
                 const memberSymbol = getSymbolOfDeclaration(member);
-                const value = getEnumMemberValue(member);
+                const value = getEnumMemberValue(member).value;
                 const memberType = getFreshTypeOfLiteralType(
                   value !== void 0 ? getEnumLiteralType(value, getSymbolId(symbol), memberSymbol) : createComputedEnumType(memberSymbol)
                 );
@@ -65563,8 +65806,8 @@ function createTypeChecker(host) {
           }
           return false;
         }
-        const sourceValue = getEnumMemberValue(getDeclarationOfKind(sourceProperty, 306 /* EnumMember */));
-        const targetValue = getEnumMemberValue(getDeclarationOfKind(targetProperty, 306 /* EnumMember */));
+        const sourceValue = getEnumMemberValue(getDeclarationOfKind(sourceProperty, 306 /* EnumMember */)).value;
+        const targetValue = getEnumMemberValue(getDeclarationOfKind(targetProperty, 306 /* EnumMember */)).value;
         if (sourceValue !== targetValue) {
           const sourceIsString = typeof sourceValue === "string";
           const targetIsString = typeof targetValue === "string";
@@ -68142,6 +68385,9 @@ function createTypeChecker(host) {
       const resolved = resolveStructuredTypeMembers(type);
       return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 && resolved.indexInfos.length === 0 && resolved.properties.length > 0 && every(resolved.properties, (p) => !!(p.flags & 16777216 /* Optional */));
     }
+    if (type.flags & 33554432 /* Substitution */) {
+      return isWeakType(type.baseType);
+    }
     if (type.flags & 2097152 /* Intersection */) {
       return every(type.types, isWeakType);
     }
@@ -70443,7 +70689,7 @@ function createTypeChecker(host) {
     return false;
   }
   function getFlowNodeId(flow) {
-    if (!flow.id || flow.id < 0) {
+    if (flow.id <= 0) {
       flow.id = nextFlowId;
       nextFlowId++;
     }
@@ -71078,33 +71324,34 @@ function createTypeChecker(host) {
         }
         flow = flow.antecedent;
       } else if (flags & 4 /* BranchLabel */) {
-        return some(flow.antecedents, (f) => isReachableFlowNodeWorker(
+        return some(flow.antecedent, (f) => isReachableFlowNodeWorker(
           f,
           /*noCacheCheck*/
           false
         ));
       } else if (flags & 8 /* LoopLabel */) {
-        const antecedents = flow.antecedents;
+        const antecedents = flow.antecedent;
         if (antecedents === void 0 || antecedents.length === 0) {
           return false;
         }
         flow = antecedents[0];
       } else if (flags & 128 /* SwitchClause */) {
-        if (flow.clauseStart === flow.clauseEnd && isExhaustiveSwitchStatement(flow.switchStatement)) {
+        const data = flow.node;
+        if (data.clauseStart === data.clauseEnd && isExhaustiveSwitchStatement(data.switchStatement)) {
           return false;
         }
         flow = flow.antecedent;
       } else if (flags & 1024 /* ReduceLabel */) {
         lastFlowNode = void 0;
-        const target = flow.target;
-        const saveAntecedents = target.antecedents;
-        target.antecedents = flow.antecedents;
+        const target = flow.node.target;
+        const saveAntecedents = target.antecedent;
+        target.antecedent = flow.node.antecedents;
         const result = isReachableFlowNodeWorker(
           flow.antecedent,
           /*noCacheCheck*/
           false
         );
-        target.antecedents = saveAntecedents;
+        target.antecedent = saveAntecedents;
         return result;
       } else {
         return !(flags & 1 /* Unreachable */);
@@ -71134,23 +71381,23 @@ function createTypeChecker(host) {
         }
         flow = flow.antecedent;
       } else if (flags & 4 /* BranchLabel */) {
-        return every(flow.antecedents, (f) => isPostSuperFlowNode(
+        return every(flow.antecedent, (f) => isPostSuperFlowNode(
           f,
           /*noCacheCheck*/
           false
         ));
       } else if (flags & 8 /* LoopLabel */) {
-        flow = flow.antecedents[0];
+        flow = flow.antecedent[0];
       } else if (flags & 1024 /* ReduceLabel */) {
-        const target = flow.target;
-        const saveAntecedents = target.antecedents;
-        target.antecedents = flow.antecedents;
+        const target = flow.node.target;
+        const saveAntecedents = target.antecedent;
+        target.antecedent = flow.node.antecedents;
         const result = isPostSuperFlowNode(
           flow.antecedent,
           /*noCacheCheck*/
           false
         );
-        target.antecedents = saveAntecedents;
+        target.antecedent = saveAntecedents;
         return result;
       } else {
         return !!(flags & 1 /* Unreachable */);
@@ -71242,8 +71489,8 @@ function createTypeChecker(host) {
         } else if (flags & 128 /* SwitchClause */) {
           type = getTypeAtSwitchClause(flow);
         } else if (flags & 12 /* Label */) {
-          if (flow.antecedents.length === 1) {
-            flow = flow.antecedents[0];
+          if (flow.antecedent.length === 1) {
+            flow = flow.antecedent[0];
             continue;
           }
           type = flags & 4 /* BranchLabel */ ? getTypeAtFlowBranchLabel(flow) : getTypeAtFlowLoopLabel(flow);
@@ -71254,11 +71501,11 @@ function createTypeChecker(host) {
             continue;
           }
         } else if (flags & 1024 /* ReduceLabel */) {
-          const target = flow.target;
-          const saveAntecedents = target.antecedents;
-          target.antecedents = flow.antecedents;
+          const target = flow.node.target;
+          const saveAntecedents = target.antecedent;
+          target.antecedent = flow.node.antecedents;
           type = getTypeAtFlowNode(flow.antecedent);
-          target.antecedents = saveAntecedents;
+          target.antecedent = saveAntecedents;
         } else if (flags & 2 /* Start */) {
           const container = flow.node;
           if (container && container !== flowContainer && reference.kind !== 211 /* PropertyAccessExpression */ && reference.kind !== 212 /* ElementAccessExpression */ && !(reference.kind === 110 /* ThisKeyword */ && container.kind !== 219 /* ArrowFunction */)) {
@@ -71412,26 +71659,26 @@ function createTypeChecker(host) {
       return createFlowType(narrowedType, isIncomplete(flowType));
     }
     function getTypeAtSwitchClause(flow) {
-      const expr = skipParentheses(flow.switchStatement.expression);
+      const expr = skipParentheses(flow.node.switchStatement.expression);
       const flowType = getTypeAtFlowNode(flow.antecedent);
       let type = getTypeFromFlowType(flowType);
       if (isMatchingReference(reference, expr)) {
-        type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+        type = narrowTypeBySwitchOnDiscriminant(type, flow.node);
       } else if (expr.kind === 221 /* TypeOfExpression */ && isMatchingReference(reference, expr.expression)) {
-        type = narrowTypeBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+        type = narrowTypeBySwitchOnTypeOf(type, flow.node);
       } else if (expr.kind === 112 /* TrueKeyword */) {
-        type = narrowTypeBySwitchOnTrue(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+        type = narrowTypeBySwitchOnTrue(type, flow.node);
       } else {
         if (strictNullChecks) {
           if (optionalChainContainsReference(expr, reference)) {
-            type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, (t) => !(t.flags & (32768 /* Undefined */ | 131072 /* Never */)));
+            type = narrowTypeBySwitchOptionalChainContainment(type, flow.node, (t) => !(t.flags & (32768 /* Undefined */ | 131072 /* Never */)));
           } else if (expr.kind === 221 /* TypeOfExpression */ && optionalChainContainsReference(expr.expression, reference)) {
-            type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, (t) => !(t.flags & 131072 /* Never */ || t.flags & 128 /* StringLiteral */ && t.value === "undefined"));
+            type = narrowTypeBySwitchOptionalChainContainment(type, flow.node, (t) => !(t.flags & 131072 /* Never */ || t.flags & 128 /* StringLiteral */ && t.value === "undefined"));
           }
         }
         const access = getDiscriminantPropertyAccess(expr, type);
         if (access) {
-          type = narrowTypeBySwitchOnDiscriminantProperty(type, access, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+          type = narrowTypeBySwitchOnDiscriminantProperty(type, access, flow.node);
         }
       }
       return createFlowType(type, isIncomplete(flowType));
@@ -71441,8 +71688,8 @@ function createTypeChecker(host) {
       let subtypeReduction = false;
       let seenIncomplete = false;
       let bypassFlow;
-      for (const antecedent of flow.antecedents) {
-        if (!bypassFlow && antecedent.flags & 128 /* SwitchClause */ && antecedent.clauseStart === antecedent.clauseEnd) {
+      for (const antecedent of flow.antecedent) {
+        if (!bypassFlow && antecedent.flags & 128 /* SwitchClause */ && antecedent.node.clauseStart === antecedent.node.clauseEnd) {
           bypassFlow = antecedent;
           continue;
         }
@@ -71462,7 +71709,7 @@ function createTypeChecker(host) {
       if (bypassFlow) {
         const flowType = getTypeAtFlowNode(bypassFlow);
         const type = getTypeFromFlowType(flowType);
-        if (!(type.flags & 131072 /* Never */) && !contains(antecedentTypes, type) && !isExhaustiveSwitchStatement(bypassFlow.switchStatement)) {
+        if (!(type.flags & 131072 /* Never */) && !contains(antecedentTypes, type) && !isExhaustiveSwitchStatement(bypassFlow.node.switchStatement)) {
           if (type === declaredType && declaredType === initialType) {
             return type;
           }
@@ -71500,7 +71747,7 @@ function createTypeChecker(host) {
       const antecedentTypes = [];
       let subtypeReduction = false;
       let firstAntecedentType;
-      for (const antecedent of flow.antecedents) {
+      for (const antecedent of flow.antecedent) {
         let flowType;
         if (!firstAntecedentType) {
           flowType = firstAntecedentType = getTypeAtFlowNode(antecedent);
@@ -71624,15 +71871,15 @@ function createTypeChecker(host) {
       }
       return narrowTypeByDiscriminant(type, access, (t) => narrowTypeByEquality(t, operator, value, assumeTrue));
     }
-    function narrowTypeBySwitchOnDiscriminantProperty(type, access, switchStatement, clauseStart, clauseEnd) {
-      if (clauseStart < clauseEnd && type.flags & 1048576 /* Union */ && getKeyPropertyName(type) === getAccessedPropertyName(access)) {
-        const clauseTypes = getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd);
+    function narrowTypeBySwitchOnDiscriminantProperty(type, access, data) {
+      if (data.clauseStart < data.clauseEnd && type.flags & 1048576 /* Union */ && getKeyPropertyName(type) === getAccessedPropertyName(access)) {
+        const clauseTypes = getSwitchClauseTypes(data.switchStatement).slice(data.clauseStart, data.clauseEnd);
         const candidate = getUnionType(map(clauseTypes, (t) => getConstituentTypeForKeyType(type, t) || unknownType));
         if (candidate !== unknownType) {
           return candidate;
         }
       }
-      return narrowTypeByDiscriminant(type, access, (t) => narrowTypeBySwitchOnDiscriminant(t, switchStatement, clauseStart, clauseEnd));
+      return narrowTypeByDiscriminant(type, access, (t) => narrowTypeBySwitchOnDiscriminant(t, data));
     }
     function narrowTypeByTruthiness(type, expr, assumeTrue) {
       if (isMatchingReference(reference, expr)) {
@@ -71877,11 +72124,11 @@ function createTypeChecker(host) {
     function narrowTypeByLiteralExpression(type, literal, assumeTrue) {
       return assumeTrue ? narrowTypeByTypeName(type, literal.text) : getAdjustedTypeWithFacts(type, typeofNEFacts.get(literal.text) || 32768 /* TypeofNEHostObject */);
     }
-    function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
+    function narrowTypeBySwitchOptionalChainContainment(type, { switchStatement, clauseStart, clauseEnd }, clauseCheck) {
       const everyClauseChecks = clauseStart !== clauseEnd && every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
       return everyClauseChecks ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
     }
-    function narrowTypeBySwitchOnDiscriminant(type, switchStatement, clauseStart, clauseEnd) {
+    function narrowTypeBySwitchOnDiscriminant(type, { switchStatement, clauseStart, clauseEnd }) {
       const switchTypes = getSwitchClauseTypes(switchStatement);
       if (!switchTypes.length) {
         return type;
@@ -71954,7 +72201,7 @@ function createTypeChecker(host) {
         )
       ));
     }
-    function narrowTypeBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
+    function narrowTypeBySwitchOnTypeOf(type, { switchStatement, clauseStart, clauseEnd }) {
       const witnesses = getSwitchClauseTypeOfWitnesses(switchStatement);
       if (!witnesses) {
         return type;
@@ -71968,7 +72215,7 @@ function createTypeChecker(host) {
       const clauseWitnesses = witnesses.slice(clauseStart, clauseEnd);
       return getUnionType(map(clauseWitnesses, (text) => text ? narrowTypeByTypeName(type, text) : neverType));
     }
-    function narrowTypeBySwitchOnTrue(type, switchStatement, clauseStart, clauseEnd) {
+    function narrowTypeBySwitchOnTrue(type, { switchStatement, clauseStart, clauseEnd }) {
       const defaultIndex = findIndex(switchStatement.caseBlock.clauses, (clause) => clause.kind === 297 /* DefaultClause */);
       const hasDefaultClause = clauseStart === clauseEnd || defaultIndex >= clauseStart && defaultIndex < clauseEnd;
       for (let i = 0; i < clauseStart; i++) {
@@ -75110,7 +75357,11 @@ function createTypeChecker(host) {
       if (getPropertyOfObjectType(targetType, name) || getApplicableIndexInfoForName(targetType, name) || isLateBoundName(name) && getIndexInfoOfType(targetType, stringType) || isComparingJsxAttributes && isHyphenatedJsxName(name)) {
         return true;
       }
-    } else if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
+    }
+    if (targetType.flags & 33554432 /* Substitution */) {
+      return isKnownProperty(targetType.baseType, name, isComparingJsxAttributes);
+    }
+    if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
       for (const t of targetType.types) {
         if (isKnownProperty(t, name, isComparingJsxAttributes)) {
           return true;
@@ -75120,7 +75371,7 @@ function createTypeChecker(host) {
     return false;
   }
   function isExcessPropertyCheckTarget(type) {
-    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
+    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 33554432 /* Substitution */ && isExcessPropertyCheckTarget(type.baseType) || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
   }
   function checkJsxExpression(node, checkMode) {
     checkGrammarJsxExpression(node);
@@ -79258,20 +79509,19 @@ function createTypeChecker(host) {
     });
   }
   function checkIfExpressionRefinesParameter(func, expr, param, initType) {
-    const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || { flags: 2 /* Start */ };
-    const trueCondition = {
-      flags: 32 /* TrueCondition */,
-      node: expr,
-      antecedent
-    };
+    const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || createFlowNode(
+      2 /* Start */,
+      /*node*/
+      void 0,
+      /*antecedent*/
+      void 0
+    );
+    const trueCondition = createFlowNode(32 /* TrueCondition */, expr, antecedent);
     const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
     if (trueType2 === initType)
       return void 0;
-    const falseCondition = {
-      ...trueCondition,
-      flags: 64 /* FalseCondition */
-    };
-    const falseSubtype = getFlowTypeOfReference(param.name, trueType2, trueType2, func, falseCondition);
+    const falseCondition = createFlowNode(64 /* FalseCondition */, expr, antecedent);
+    const falseSubtype = getFlowTypeOfReference(param.name, initType, trueType2, func, falseCondition);
     return falseSubtype.flags & 131072 /* Never */ ? trueType2 : void 0;
   }
   function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
@@ -80664,7 +80914,7 @@ function createTypeChecker(host) {
     ) || unknownType, isTemplateLiteralContextualType)) {
       return getTemplateLiteralType(texts, types);
     }
-    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node);
+    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node).value;
     return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
   }
   function isTemplateLiteralContextualType(type) {
@@ -85569,14 +85819,14 @@ function createTypeChecker(host) {
       let autoValue = 0;
       let previous;
       for (const member of node.members) {
-        const value = computeMemberValue(member, autoValue, previous);
-        getNodeLinks(member).enumMemberValue = value;
-        autoValue = typeof value === "number" ? value + 1 : void 0;
+        const result = computeEnumMemberValue(member, autoValue, previous);
+        getNodeLinks(member).enumMemberValue = result;
+        autoValue = typeof result.value === "number" ? result.value + 1 : void 0;
         previous = member;
       }
     }
   }
-  function computeMemberValue(member, autoValue, previous) {
+  function computeEnumMemberValue(member, autoValue, previous) {
     if (isComputedNonLiteralName(member.name)) {
       error2(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
     } else {
@@ -85586,34 +85836,43 @@ function createTypeChecker(host) {
       }
     }
     if (member.initializer) {
-      return computeConstantValue(member);
+      return computeConstantEnumMemberValue(member);
     }
     if (member.parent.flags & 33554432 /* Ambient */ && !isEnumConst(member.parent)) {
-      return void 0;
+      return evaluatorResult(
+        /*value*/
+        void 0
+      );
     }
     if (autoValue === void 0) {
       error2(member.name, Diagnostics.Enum_member_must_have_initializer);
-      return void 0;
-    }
-    if (getIsolatedModules(compilerOptions) && (previous == null ? void 0 : previous.initializer) && !isSyntacticallyNumericConstant(previous.initializer)) {
-      error2(
-        member.name,
-        Diagnostics.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled
+      return evaluatorResult(
+        /*value*/
+        void 0
       );
     }
-    return autoValue;
+    if (getIsolatedModules(compilerOptions) && (previous == null ? void 0 : previous.initializer)) {
+      const prevValue = getEnumMemberValue(previous);
+      if (!(typeof prevValue.value === "number" && !prevValue.resolvedOtherFiles)) {
+        error2(
+          member.name,
+          Diagnostics.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled
+        );
+      }
+    }
+    return evaluatorResult(autoValue);
   }
-  function computeConstantValue(member) {
+  function computeConstantEnumMemberValue(member) {
     const isConstEnum = isEnumConst(member.parent);
     const initializer = member.initializer;
-    const value = evaluate(initializer, member);
-    if (value !== void 0) {
-      if (isConstEnum && typeof value === "number" && !isFinite(value)) {
+    const result = evaluate(initializer, member);
+    if (result.value !== void 0) {
+      if (isConstEnum && typeof result.value === "number" && !isFinite(result.value)) {
         error2(
           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
+          isNaN(result.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 (getIsolatedModules(compilerOptions) && typeof value === "string" && !isSyntacticallyString(initializer)) {
+      } else if (getIsolatedModules(compilerOptions) && typeof result.value === "string" && !result.isSyntacticallyString) {
         error2(
           initializer,
           Diagnostics._0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is_enabled,
@@ -85627,19 +85886,7 @@ function createTypeChecker(host) {
     } else {
       checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
     }
-    return value;
-  }
-  function isSyntacticallyNumericConstant(expr) {
-    expr = skipOuterExpressions(expr);
-    switch (expr.kind) {
-      case 224 /* PrefixUnaryExpression */:
-        return isSyntacticallyNumericConstant(expr.operand);
-      case 226 /* BinaryExpression */:
-        return isSyntacticallyNumericConstant(expr.left) && isSyntacticallyNumericConstant(expr.right);
-      case 9 /* NumericLiteral */:
-        return true;
-    }
-    return false;
+    return result;
   }
   function evaluateEntityNameExpression(expr, location) {
     const symbol = resolveEntityName(
@@ -85649,7 +85896,10 @@ function createTypeChecker(host) {
       true
     );
     if (!symbol)
-      return void 0;
+      return evaluatorResult(
+        /*value*/
+        void 0
+      );
     if (expr.kind === 80 /* Identifier */) {
       const identifier = expr;
       if (isInfinityOrNaNString(identifier.escapedText) && symbol === getGlobalSymbol(
@@ -85658,7 +85908,11 @@ function createTypeChecker(host) {
         /*diagnostic*/
         void 0
       )) {
-        return +identifier.escapedText;
+        return evaluatorResult(
+          +identifier.escapedText,
+          /*isSyntacticallyString*/
+          false
+        );
       }
     }
     if (symbol.flags & 8 /* EnumMember */) {
@@ -85667,9 +85921,23 @@ function createTypeChecker(host) {
     if (isConstantVariable(symbol)) {
       const declaration = symbol.valueDeclaration;
       if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
-        return evaluate(declaration.initializer, declaration);
+        const result = evaluate(declaration.initializer, declaration);
+        if (location && getSourceFileOfNode(location) !== getSourceFileOfNode(declaration)) {
+          return evaluatorResult(
+            result.value,
+            /*isSyntacticallyString*/
+            false,
+            /*resolvedOtherFiles*/
+            true
+          );
+        }
+        return result;
       }
     }
+    return evaluatorResult(
+      /*value*/
+      void 0
+    );
   }
   function evaluateElementAccessExpression(expr, location) {
     const root = expr.expression;
@@ -85684,20 +85952,31 @@ function createTypeChecker(host) {
         const name = escapeLeadingUnderscores(expr.argumentExpression.text);
         const member = rootSymbol.exports.get(name);
         if (member) {
+          Debug.assert(getSourceFileOfNode(member.valueDeclaration) === getSourceFileOfNode(rootSymbol.valueDeclaration));
           return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
         }
       }
     }
+    return evaluatorResult(
+      /*value*/
+      void 0
+    );
   }
   function evaluateEnumMember(expr, symbol, location) {
     const declaration = symbol.valueDeclaration;
     if (!declaration || declaration === location) {
       error2(expr, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(symbol));
-      return void 0;
+      return evaluatorResult(
+        /*value*/
+        void 0
+      );
     }
     if (!isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
       error2(expr, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
-      return 0;
+      return evaluatorResult(
+        /*value*/
+        0
+      );
     }
     return getEnumMemberValue(declaration);
   }
@@ -87838,7 +88117,10 @@ function createTypeChecker(host) {
   }
   function getEnumMemberValue(node) {
     computeEnumMemberValues(node.parent);
-    return getNodeLinks(node).enumMemberValue;
+    return getNodeLinks(node).enumMemberValue ?? evaluatorResult(
+      /*value*/
+      void 0
+    );
   }
   function canHaveConstantValue(node) {
     switch (node.kind) {
@@ -87851,13 +88133,13 @@ function createTypeChecker(host) {
   }
   function getConstantValue2(node) {
     if (node.kind === 306 /* EnumMember */) {
-      return getEnumMemberValue(node);
+      return getEnumMemberValue(node).value;
     }
     const symbol = getNodeLinks(node).resolvedSymbol;
     if (symbol && symbol.flags & 8 /* EnumMember */) {
       const member = symbol.valueDeclaration;
       if (isEnumConst(member.parent)) {
-        return getEnumMemberValue(member);
+        return getEnumMemberValue(member).value;
       }
     }
     return void 0;
@@ -88232,6 +88514,10 @@ function createTypeChecker(host) {
         const node = getParseTreeNode(nodeIn, canHaveConstantValue);
         return node ? getConstantValue2(node) : void 0;
       },
+      getEnumMemberValue: (nodeIn) => {
+        const node = getParseTreeNode(nodeIn, isEnumMember);
+        return node ? getEnumMemberValue(node) : void 0;
+      },
       collectLinkedAliases,
       getReferencedValueDeclaration,
       getReferencedValueDeclarations,
@@ -94637,7 +94923,8 @@ function transformTypeScript(context) {
       /*generateNameForComputedPropertyName*/
       false
     );
-    const valueExpression = transformEnumMemberDeclarationValue(member);
+    const evaluated = resolver.getEnumMemberValue(member);
+    const valueExpression = transformEnumMemberDeclarationValue(member, evaluated == null ? void 0 : evaluated.value);
     const innerAssignment = factory2.createAssignment(
       factory2.createElementAccessExpression(
         currentNamespaceContainerName,
@@ -94645,7 +94932,7 @@ function transformTypeScript(context) {
       ),
       valueExpression
     );
-    const outerAssignment = isSyntacticallyString(valueExpression) ? innerAssignment : factory2.createAssignment(
+    const outerAssignment = typeof (evaluated == null ? void 0 : evaluated.value) === "string" || (evaluated == null ? void 0 : evaluated.isSyntacticallyString) ? innerAssignment : factory2.createAssignment(
       factory2.createElementAccessExpression(
         currentNamespaceContainerName,
         innerAssignment
@@ -94662,10 +94949,9 @@ function transformTypeScript(context) {
       member
     );
   }
-  function transformEnumMemberDeclarationValue(member) {
-    const value = resolver.getConstantValue(member);
-    if (value !== void 0) {
-      return typeof value === "string" ? factory2.createStringLiteral(value) : value < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-value)) : factory2.createNumericLiteral(value);
+  function transformEnumMemberDeclarationValue(member, constantValue) {
+    if (constantValue !== void 0) {
+      return typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : constantValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-constantValue)) : factory2.createNumericLiteral(constantValue);
     } else {
       enableSubstitutionForNonQualifiedEnumMembers();
       if (member.initializer) {
@@ -116016,6 +116302,7 @@ var notImplementedResolver = {
   isEntityNameVisible: notImplemented,
   // Returns the constant value this property access resolves to: notImplemented, or 'undefined' for a non-constant
   getConstantValue: notImplemented,
+  getEnumMemberValue: notImplemented,
   getReferencedValueDeclaration: notImplemented,
   getReferencedValueDeclarations: notImplemented,
   getTypeReferenceSerializationKind: notImplemented,
@@ -131035,6 +131322,1123 @@ function verboseReportProjectStatus(state, configFileName, status) {
   }
 }
 
+// src/compiler/executeCommandLine.ts
+var StatisticType = /* @__PURE__ */ ((StatisticType2) => {
+  StatisticType2[StatisticType2["time"] = 0] = "time";
+  StatisticType2[StatisticType2["count"] = 1] = "count";
+  StatisticType2[StatisticType2["memory"] = 2] = "memory";
+  return StatisticType2;
+})(StatisticType || {});
+function countLines(program) {
+  const counts2 = getCountsMap();
+  forEach(program.getSourceFiles(), (file) => {
+    const key = getCountKey(program, file);
+    const lineCount = getLineStarts(file).length;
+    counts2.set(key, counts2.get(key) + lineCount);
+  });
+  return counts2;
+}
+function getCountsMap() {
+  const counts2 = /* @__PURE__ */ new Map();
+  counts2.set("Library", 0);
+  counts2.set("Definitions", 0);
+  counts2.set("TypeScript", 0);
+  counts2.set("JavaScript", 0);
+  counts2.set("JSON", 0);
+  counts2.set("Other", 0);
+  return counts2;
+}
+function getCountKey(program, file) {
+  if (program.isSourceFileDefaultLibrary(file)) {
+    return "Library";
+  } else if (file.isDeclarationFile) {
+    return "Definitions";
+  }
+  const path = file.path;
+  if (fileExtensionIsOneOf(path, supportedTSExtensionsFlat)) {
+    return "TypeScript";
+  } else if (fileExtensionIsOneOf(path, supportedJSExtensionsFlat)) {
+    return "JavaScript";
+  } else if (fileExtensionIs(path, ".json" /* Json */)) {
+    return "JSON";
+  } else {
+    return "Other";
+  }
+}
+function updateReportDiagnostic(sys2, existing, options) {
+  return shouldBePretty(sys2, options) ? createDiagnosticReporter(
+    sys2,
+    /*pretty*/
+    true
+  ) : existing;
+}
+function defaultIsPretty(sys2) {
+  return !!sys2.writeOutputIsTTY && sys2.writeOutputIsTTY() && !sys2.getEnvironmentVariable("NO_COLOR");
+}
+function shouldBePretty(sys2, options) {
+  if (!options || typeof options.pretty === "undefined") {
+    return defaultIsPretty(sys2);
+  }
+  return options.pretty;
+}
+function getOptionsForHelp(commandLine) {
+  return !!commandLine.options.all ? sort(optionDeclarations, (a, b) => compareStringsCaseInsensitive(a.name, b.name)) : filter(optionDeclarations.slice(), (v) => !!v.showInSimplifiedHelpView);
+}
+function printVersion(sys2) {
+  sys2.write(getDiagnosticText(Diagnostics.Version_0, version) + sys2.newLine);
+}
+function createColors(sys2) {
+  const showColors = defaultIsPretty(sys2);
+  if (!showColors) {
+    return {
+      bold: (str) => str,
+      blue: (str) => str,
+      blueBackground: (str) => str,
+      brightWhite: (str) => str
+    };
+  }
+  function bold(str) {
+    return `\x1B[1m${str}\x1B[22m`;
+  }
+  const isWindows = sys2.getEnvironmentVariable("OS") && sys2.getEnvironmentVariable("OS").toLowerCase().includes("windows");
+  const isWindowsTerminal = sys2.getEnvironmentVariable("WT_SESSION");
+  const isVSCode = sys2.getEnvironmentVariable("TERM_PROGRAM") && sys2.getEnvironmentVariable("TERM_PROGRAM") === "vscode";
+  function blue(str) {
+    if (isWindows && !isWindowsTerminal && !isVSCode) {
+      return brightWhite(str);
+    }
+    return `\x1B[94m${str}\x1B[39m`;
+  }
+  const supportsRicherColors = sys2.getEnvironmentVariable("COLORTERM") === "truecolor" || sys2.getEnvironmentVariable("TERM") === "xterm-256color";
+  function blueBackground(str) {
+    if (supportsRicherColors) {
+      return `\x1B[48;5;68m${str}\x1B[39;49m`;
+    } else {
+      return `\x1B[44m${str}\x1B[39;49m`;
+    }
+  }
+  function brightWhite(str) {
+    return `\x1B[97m${str}\x1B[39m`;
+  }
+  return {
+    bold,
+    blue,
+    brightWhite,
+    blueBackground
+  };
+}
+function getDisplayNameTextOfOption(option) {
+  return `--${option.name}${option.shortName ? `, -${option.shortName}` : ""}`;
+}
+function generateOptionOutput(sys2, option, rightAlignOfLeft, leftAlignOfRight) {
+  var _a;
+  const text = [];
+  const colors = createColors(sys2);
+  const name = getDisplayNameTextOfOption(option);
+  const valueCandidates = getValueCandidate(option);
+  const defaultValueDescription = typeof option.defaultValueDescription === "object" ? getDiagnosticText(option.defaultValueDescription) : formatDefaultValue(
+    option.defaultValueDescription,
+    option.type === "list" || option.type === "listOrElement" ? option.element.type : option.type
+  );
+  const terminalWidth = ((_a = sys2.getWidthOfTerminal) == null ? void 0 : _a.call(sys2)) ?? 0;
+  if (terminalWidth >= 80) {
+    let description3 = "";
+    if (option.description) {
+      description3 = getDiagnosticText(option.description);
+    }
+    text.push(...getPrettyOutput(
+      name,
+      description3,
+      rightAlignOfLeft,
+      leftAlignOfRight,
+      terminalWidth,
+      /*colorLeft*/
+      true
+    ), sys2.newLine);
+    if (showAdditionalInfoOutput(valueCandidates, option)) {
+      if (valueCandidates) {
+        text.push(...getPrettyOutput(
+          valueCandidates.valueType,
+          valueCandidates.possibleValues,
+          rightAlignOfLeft,
+          leftAlignOfRight,
+          terminalWidth,
+          /*colorLeft*/
+          false
+        ), sys2.newLine);
+      }
+      if (defaultValueDescription) {
+        text.push(...getPrettyOutput(
+          getDiagnosticText(Diagnostics.default_Colon),
+          defaultValueDescription,
+          rightAlignOfLeft,
+          leftAlignOfRight,
+          terminalWidth,
+          /*colorLeft*/
+          false
+        ), sys2.newLine);
+      }
+    }
+    text.push(sys2.newLine);
+  } else {
+    text.push(colors.blue(name), sys2.newLine);
+    if (option.description) {
+      const description3 = getDiagnosticText(option.description);
+      text.push(description3);
+    }
+    text.push(sys2.newLine);
+    if (showAdditionalInfoOutput(valueCandidates, option)) {
+      if (valueCandidates) {
+        text.push(`${valueCandidates.valueType} ${valueCandidates.possibleValues}`);
+      }
+      if (defaultValueDescription) {
+        if (valueCandidates)
+          text.push(sys2.newLine);
+        const diagType = getDiagnosticText(Diagnostics.default_Colon);
+        text.push(`${diagType} ${defaultValueDescription}`);
+      }
+      text.push(sys2.newLine);
+    }
+    text.push(sys2.newLine);
+  }
+  return text;
+  function formatDefaultValue(defaultValue, type) {
+    return defaultValue !== void 0 && typeof type === "object" ? arrayFrom(type.entries()).filter(([, value]) => value === defaultValue).map(([name2]) => name2).join("/") : String(defaultValue);
+  }
+  function showAdditionalInfoOutput(valueCandidates2, option2) {
+    const ignoreValues = ["string"];
+    const ignoredDescriptions = [void 0, "false", "n/a"];
+    const defaultValueDescription2 = option2.defaultValueDescription;
+    if (option2.category === Diagnostics.Command_line_Options)
+      return false;
+    if (contains(ignoreValues, valueCandidates2 == null ? void 0 : valueCandidates2.possibleValues) && contains(ignoredDescriptions, defaultValueDescription2)) {
+      return false;
+    }
+    return true;
+  }
+  function getPrettyOutput(left, right, rightAlignOfLeft2, leftAlignOfRight2, terminalWidth2, colorLeft) {
+    const res = [];
+    let isFirstLine = true;
+    let remainRight = right;
+    const rightCharacterNumber = terminalWidth2 - leftAlignOfRight2;
+    while (remainRight.length > 0) {
+      let curLeft = "";
+      if (isFirstLine) {
+        curLeft = left.padStart(rightAlignOfLeft2);
+        curLeft = curLeft.padEnd(leftAlignOfRight2);
+        curLeft = colorLeft ? colors.blue(curLeft) : curLeft;
+      } else {
+        curLeft = "".padStart(leftAlignOfRight2);
+      }
+      const curRight = remainRight.substr(0, rightCharacterNumber);
+      remainRight = remainRight.slice(rightCharacterNumber);
+      res.push(`${curLeft}${curRight}`);
+      isFirstLine = false;
+    }
+    return res;
+  }
+  function getValueCandidate(option2) {
+    if (option2.type === "object") {
+      return void 0;
+    }
+    return {
+      valueType: getValueType(option2),
+      possibleValues: getPossibleValues(option2)
+    };
+    function getValueType(option3) {
+      Debug.assert(option3.type !== "listOrElement");
+      switch (option3.type) {
+        case "string":
+        case "number":
+        case "boolean":
+          return getDiagnosticText(Diagnostics.type_Colon);
+        case "list":
+          return getDiagnosticText(Diagnostics.one_or_more_Colon);
+        default:
+          return getDiagnosticText(Diagnostics.one_of_Colon);
+      }
+    }
+    function getPossibleValues(option3) {
+      let possibleValues;
+      switch (option3.type) {
+        case "string":
+        case "number":
+        case "boolean":
+          possibleValues = option3.type;
+          break;
+        case "list":
+        case "listOrElement":
+          possibleValues = getPossibleValues(option3.element);
+          break;
+        case "object":
+          possibleValues = "";
+          break;
+        default:
+          const inverted = {};
+          option3.type.forEach((value, name2) => {
+            var _a2;
+            if (!((_a2 = option3.deprecatedKeys) == null ? void 0 : _a2.has(name2))) {
+              (inverted[value] || (inverted[value] = [])).push(name2);
+            }
+          });
+          return Object.entries(inverted).map(([, synonyms]) => synonyms.join("/")).join(", ");
+      }
+      return possibleValues;
+    }
+  }
+}
+function generateGroupOptionOutput(sys2, optionsList) {
+  let maxLength2 = 0;
+  for (const option of optionsList) {
+    const curLength = getDisplayNameTextOfOption(option).length;
+    maxLength2 = maxLength2 > curLength ? maxLength2 : curLength;
+  }
+  const rightAlignOfLeftPart = maxLength2 + 2;
+  const leftAlignOfRightPart = rightAlignOfLeftPart + 2;
+  let lines = [];
+  for (const option of optionsList) {
+    const tmp = generateOptionOutput(sys2, option, rightAlignOfLeftPart, leftAlignOfRightPart);
+    lines = [...lines, ...tmp];
+  }
+  if (lines[lines.length - 2] !== sys2.newLine) {
+    lines.push(sys2.newLine);
+  }
+  return lines;
+}
+function generateSectionOptionsOutput(sys2, sectionName, options, subCategory, beforeOptionsDescription, afterOptionsDescription) {
+  let res = [];
+  res.push(createColors(sys2).bold(sectionName) + sys2.newLine + sys2.newLine);
+  if (beforeOptionsDescription) {
+    res.push(beforeOptionsDescription + sys2.newLine + sys2.newLine);
+  }
+  if (!subCategory) {
+    res = [...res, ...generateGroupOptionOutput(sys2, options)];
+    if (afterOptionsDescription) {
+      res.push(afterOptionsDescription + sys2.newLine + sys2.newLine);
+    }
+    return res;
+  }
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const option of options) {
+    if (!option.category) {
+      continue;
+    }
+    const curCategory = getDiagnosticText(option.category);
+    const optionsOfCurCategory = categoryMap.get(curCategory) ?? [];
+    optionsOfCurCategory.push(option);
+    categoryMap.set(curCategory, optionsOfCurCategory);
+  }
+  categoryMap.forEach((value, key) => {
+    res.push(`### ${key}${sys2.newLine}${sys2.newLine}`);
+    res = [...res, ...generateGroupOptionOutput(sys2, value)];
+  });
+  if (afterOptionsDescription) {
+    res.push(afterOptionsDescription + sys2.newLine + sys2.newLine);
+  }
+  return res;
+}
+function printEasyHelp(sys2, simpleOptions) {
+  const colors = createColors(sys2);
+  let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];
+  output.push(colors.bold(getDiagnosticText(Diagnostics.COMMON_COMMANDS)) + sys2.newLine + sys2.newLine);
+  example("tsc", Diagnostics.Compiles_the_current_project_tsconfig_json_in_the_working_directory);
+  example("tsc app.ts util.ts", Diagnostics.Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options);
+  example("tsc -b", Diagnostics.Build_a_composite_project_in_the_working_directory);
+  example("tsc --init", Diagnostics.Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory);
+  example("tsc -p ./path/to/tsconfig.json", Diagnostics.Compiles_the_TypeScript_project_located_at_the_specified_path);
+  example("tsc --help --all", Diagnostics.An_expanded_version_of_this_information_showing_all_possible_compiler_options);
+  example(["tsc --noEmit", "tsc --target esnext"], Diagnostics.Compiles_the_current_project_with_additional_settings);
+  const cliCommands = simpleOptions.filter((opt) => opt.isCommandLineOnly || opt.category === Diagnostics.Command_line_Options);
+  const configOpts = simpleOptions.filter((opt) => !contains(cliCommands, opt));
+  output = [
+    ...output,
+    ...generateSectionOptionsOutput(
+      sys2,
+      getDiagnosticText(Diagnostics.COMMAND_LINE_FLAGS),
+      cliCommands,
+      /*subCategory*/
+      false,
+      /*beforeOptionsDescription*/
+      void 0,
+      /*afterOptionsDescription*/
+      void 0
+    ),
+    ...generateSectionOptionsOutput(
+      sys2,
+      getDiagnosticText(Diagnostics.COMMON_COMPILER_OPTIONS),
+      configOpts,
+      /*subCategory*/
+      false,
+      /*beforeOptionsDescription*/
+      void 0,
+      formatMessage(Diagnostics.You_can_learn_about_all_of_the_compiler_options_at_0, "https://aka.ms/tsc")
+    )
+  ];
+  for (const line of output) {
+    sys2.write(line);
+  }
+  function example(ex, desc) {
+    const examples = typeof ex === "string" ? [ex] : ex;
+    for (const example2 of examples) {
+      output.push("  " + colors.blue(example2) + sys2.newLine);
+    }
+    output.push("  " + getDiagnosticText(desc) + sys2.newLine + sys2.newLine);
+  }
+}
+function printAllHelp(sys2, compilerOptions, buildOptions, watchOptions) {
+  let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];
+  output = [...output, ...generateSectionOptionsOutput(
+    sys2,
+    getDiagnosticText(Diagnostics.ALL_COMPILER_OPTIONS),
+    compilerOptions,
+    /*subCategory*/
+    true,
+    /*beforeOptionsDescription*/
+    void 0,
+    formatMessage(Diagnostics.You_can_learn_about_all_of_the_compiler_options_at_0, "https://aka.ms/tsc")
+  )];
+  output = [...output, ...generateSectionOptionsOutput(
+    sys2,
+    getDiagnosticText(Diagnostics.WATCH_OPTIONS),
+    watchOptions,
+    /*subCategory*/
+    false,
+    getDiagnosticText(Diagnostics.Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon)
+  )];
+  output = [...output, ...generateSectionOptionsOutput(
+    sys2,
+    getDiagnosticText(Diagnostics.BUILD_OPTIONS),
+    buildOptions,
+    /*subCategory*/
+    false,
+    formatMessage(Diagnostics.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds")
+  )];
+  for (const line of output) {
+    sys2.write(line);
+  }
+}
+function printBuildHelp(sys2, buildOptions) {
+  let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];
+  output = [...output, ...generateSectionOptionsOutput(
+    sys2,
+    getDiagnosticText(Diagnostics.BUILD_OPTIONS),
+    buildOptions,
+    /*subCategory*/
+    false,
+    formatMessage(Diagnostics.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds")
+  )];
+  for (const line of output) {
+    sys2.write(line);
+  }
+}
+function getHeader(sys2, message) {
+  var _a;
+  const colors = createColors(sys2);
+  const header = [];
+  const terminalWidth = ((_a = sys2.getWidthOfTerminal) == null ? void 0 : _a.call(sys2)) ?? 0;
+  const tsIconLength = 5;
+  const tsIconFirstLine = colors.blueBackground("".padStart(tsIconLength));
+  const tsIconSecondLine = colors.blueBackground(colors.brightWhite("TS ".padStart(tsIconLength)));
+  if (terminalWidth >= message.length + tsIconLength) {
+    const rightAlign = terminalWidth > 120 ? 120 : terminalWidth;
+    const leftAlign = rightAlign - tsIconLength;
+    header.push(message.padEnd(leftAlign) + tsIconFirstLine + sys2.newLine);
+    header.push("".padStart(leftAlign) + tsIconSecondLine + sys2.newLine);
+  } else {
+    header.push(message + sys2.newLine);
+    header.push(sys2.newLine);
+  }
+  return header;
+}
+function printHelp(sys2, commandLine) {
+  if (!commandLine.options.all) {
+    printEasyHelp(sys2, getOptionsForHelp(commandLine));
+  } else {
+    printAllHelp(sys2, getOptionsForHelp(commandLine), optionsForBuild, optionsForWatch);
+  }
+}
+function executeCommandLineWorker(sys2, cb, commandLine) {
+  let reportDiagnostic = createDiagnosticReporter(sys2);
+  if (commandLine.options.build) {
+    reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_build_must_be_the_first_command_line_argument));
+    return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+  }
+  let configFileName;
+  if (commandLine.options.locale) {
+    validateLocaleAndSetLanguage(commandLine.options.locale, sys2, commandLine.errors);
+  }
+  if (commandLine.errors.length > 0) {
+    commandLine.errors.forEach(reportDiagnostic);
+    return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+  }
+  if (commandLine.options.init) {
+    writeConfigFile(sys2, reportDiagnostic, commandLine.options, commandLine.fileNames);
+    return sys2.exit(0 /* Success */);
+  }
+  if (commandLine.options.version) {
+    printVersion(sys2);
+    return sys2.exit(0 /* Success */);
+  }
+  if (commandLine.options.help || commandLine.options.all) {
+    printHelp(sys2, commandLine);
+    return sys2.exit(0 /* Success */);
+  }
+  if (commandLine.options.watch && commandLine.options.listFilesOnly) {
+    reportDiagnostic(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "listFilesOnly"));
+    return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+  }
+  if (commandLine.options.project) {
+    if (commandLine.fileNames.length !== 0) {
+      reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line));
+      return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+    }
+    const fileOrDirectory = normalizePath(commandLine.options.project);
+    if (!fileOrDirectory || sys2.directoryExists(fileOrDirectory)) {
+      configFileName = combinePaths(fileOrDirectory, "tsconfig.json");
+      if (!sys2.fileExists(configFileName)) {
+        reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0, commandLine.options.project));
+        return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+      }
+    } else {
+      configFileName = fileOrDirectory;
+      if (!sys2.fileExists(configFileName)) {
+        reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_specified_path_does_not_exist_Colon_0, commandLine.options.project));
+        return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+      }
+    }
+  } else if (commandLine.fileNames.length === 0) {
+    const searchPath = normalizePath(sys2.getCurrentDirectory());
+    configFileName = findConfigFile(searchPath, (fileName) => sys2.fileExists(fileName));
+  }
+  if (commandLine.fileNames.length === 0 && !configFileName) {
+    if (commandLine.options.showConfig) {
+      reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0, normalizePath(sys2.getCurrentDirectory())));
+    } else {
+      printVersion(sys2);
+      printHelp(sys2, commandLine);
+    }
+    return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+  }
+  const currentDirectory = sys2.getCurrentDirectory();
+  const commandLineOptions = convertToOptionsWithAbsolutePaths(
+    commandLine.options,
+    (fileName) => getNormalizedAbsolutePath(fileName, currentDirectory)
+  );
+  if (configFileName) {
+    const extendedConfigCache = /* @__PURE__ */ new Map();
+    const configParseResult = parseConfigFileWithSystem(configFileName, commandLineOptions, extendedConfigCache, commandLine.watchOptions, sys2, reportDiagnostic);
+    if (commandLineOptions.showConfig) {
+      if (configParseResult.errors.length !== 0) {
+        reportDiagnostic = updateReportDiagnostic(
+          sys2,
+          reportDiagnostic,
+          configParseResult.options
+        );
+        configParseResult.errors.forEach(reportDiagnostic);
+        return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+      }
+      sys2.write(JSON.stringify(convertToTSConfig(configParseResult, configFileName, sys2), null, 4) + sys2.newLine);
+      return sys2.exit(0 /* Success */);
+    }
+    reportDiagnostic = updateReportDiagnostic(
+      sys2,
+      reportDiagnostic,
+      configParseResult.options
+    );
+    if (isWatchSet(configParseResult.options)) {
+      if (reportWatchModeWithoutSysSupport(sys2, reportDiagnostic))
+        return;
+      return createWatchOfConfigFile(
+        sys2,
+        cb,
+        reportDiagnostic,
+        configParseResult,
+        commandLineOptions,
+        commandLine.watchOptions,
+        extendedConfigCache
+      );
+    } else if (isIncrementalCompilation(configParseResult.options)) {
+      performIncrementalCompilation2(
+        sys2,
+        cb,
+        reportDiagnostic,
+        configParseResult
+      );
+    } else {
+      performCompilation(
+        sys2,
+        cb,
+        reportDiagnostic,
+        configParseResult
+      );
+    }
+  } else {
+    if (commandLineOptions.showConfig) {
+      sys2.write(JSON.stringify(convertToTSConfig(commandLine, combinePaths(currentDirectory, "tsconfig.json"), sys2), null, 4) + sys2.newLine);
+      return sys2.exit(0 /* Success */);
+    }
+    reportDiagnostic = updateReportDiagnostic(
+      sys2,
+      reportDiagnostic,
+      commandLineOptions
+    );
+    if (isWatchSet(commandLineOptions)) {
+      if (reportWatchModeWithoutSysSupport(sys2, reportDiagnostic))
+        return;
+      return createWatchOfFilesAndCompilerOptions(
+        sys2,
+        cb,
+        reportDiagnostic,
+        commandLine.fileNames,
+        commandLineOptions,
+        commandLine.watchOptions
+      );
+    } else if (isIncrementalCompilation(commandLineOptions)) {
+      performIncrementalCompilation2(
+        sys2,
+        cb,
+        reportDiagnostic,
+        { ...commandLine, options: commandLineOptions }
+      );
+    } else {
+      performCompilation(
+        sys2,
+        cb,
+        reportDiagnostic,
+        { ...commandLine, options: commandLineOptions }
+      );
+    }
+  }
+}
+function isBuild(commandLineArgs) {
+  if (commandLineArgs.length > 0 && commandLineArgs[0].charCodeAt(0) === 45 /* minus */) {
+    const firstOption = commandLineArgs[0].slice(commandLineArgs[0].charCodeAt(1) === 45 /* minus */ ? 2 : 1).toLowerCase();
+    return firstOption === "build" || firstOption === "b";
+  }
+  return false;
+}
+function executeCommandLine(system, cb, commandLineArgs) {
+  if (isBuild(commandLineArgs)) {
+    const { buildOptions, watchOptions, projects, errors } = parseBuildCommand(commandLineArgs.slice(1));
+    if (buildOptions.generateCpuProfile && system.enableCPUProfiler) {
+      system.enableCPUProfiler(buildOptions.generateCpuProfile, () => performBuild(
+        system,
+        cb,
+        buildOptions,
+        watchOptions,
+        projects,
+        errors
+      ));
+    } else {
+      return performBuild(
+        system,
+        cb,
+        buildOptions,
+        watchOptions,
+        projects,
+        errors
+      );
+    }
+  }
+  const commandLine = parseCommandLine(commandLineArgs, (path) => system.readFile(path));
+  if (commandLine.options.generateCpuProfile && system.enableCPUProfiler) {
+    system.enableCPUProfiler(commandLine.options.generateCpuProfile, () => executeCommandLineWorker(
+      system,
+      cb,
+      commandLine
+    ));
+  } else {
+    return executeCommandLineWorker(system, cb, commandLine);
+  }
+}
+function reportWatchModeWithoutSysSupport(sys2, reportDiagnostic) {
+  if (!sys2.watchFile || !sys2.watchDirectory) {
+    reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"));
+    sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+    return true;
+  }
+  return false;
+}
+var defaultJSDocParsingMode = 2 /* ParseForTypeErrors */;
+function performBuild(sys2, cb, buildOptions, watchOptions, projects, errors) {
+  const reportDiagnostic = updateReportDiagnostic(
+    sys2,
+    createDiagnosticReporter(sys2),
+    buildOptions
+  );
+  if (buildOptions.locale) {
+    validateLocaleAndSetLanguage(buildOptions.locale, sys2, errors);
+  }
+  if (errors.length > 0) {
+    errors.forEach(reportDiagnostic);
+    return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+  }
+  if (buildOptions.help) {
+    printVersion(sys2);
+    printBuildHelp(sys2, buildOpts);
+    return sys2.exit(0 /* Success */);
+  }
+  if (projects.length === 0) {
+    printVersion(sys2);
+    printBuildHelp(sys2, buildOpts);
+    return sys2.exit(0 /* Success */);
+  }
+  if (!sys2.getModifiedTime || !sys2.setModifiedTime || buildOptions.clean && !sys2.deleteFile) {
+    reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--build"));
+    return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+  }
+  if (buildOptions.watch) {
+    if (reportWatchModeWithoutSysSupport(sys2, reportDiagnostic))
+      return;
+    const buildHost2 = createSolutionBuilderWithWatchHost(
+      sys2,
+      /*createProgram*/
+      void 0,
+      reportDiagnostic,
+      createBuilderStatusReporter(sys2, shouldBePretty(sys2, buildOptions)),
+      createWatchStatusReporter2(sys2, buildOptions)
+    );
+    buildHost2.jsDocParsingMode = defaultJSDocParsingMode;
+    const solutionPerformance2 = enableSolutionPerformance(sys2, buildOptions);
+    updateSolutionBuilderHost(sys2, cb, buildHost2, solutionPerformance2);
+    const onWatchStatusChange = buildHost2.onWatchStatusChange;
+    let reportBuildStatistics = false;
+    buildHost2.onWatchStatusChange = (d, newLine, options, errorCount) => {
+      onWatchStatusChange == null ? void 0 : onWatchStatusChange(d, newLine, options, errorCount);
+      if (reportBuildStatistics && (d.code === Diagnostics.Found_0_errors_Watching_for_file_changes.code || d.code === Diagnostics.Found_1_error_Watching_for_file_changes.code)) {
+        reportSolutionBuilderTimes(builder2, solutionPerformance2);
+      }
+    };
+    const builder2 = createSolutionBuilderWithWatch(buildHost2, projects, buildOptions, watchOptions);
+    builder2.build();
+    reportSolutionBuilderTimes(builder2, solutionPerformance2);
+    reportBuildStatistics = true;
+    return builder2;
+  }
+  const buildHost = createSolutionBuilderHost(
+    sys2,
+    /*createProgram*/
+    void 0,
+    reportDiagnostic,
+    createBuilderStatusReporter(sys2, shouldBePretty(sys2, buildOptions)),
+    createReportErrorSummary(sys2, buildOptions)
+  );
+  buildHost.jsDocParsingMode = defaultJSDocParsingMode;
+  const solutionPerformance = enableSolutionPerformance(sys2, buildOptions);
+  updateSolutionBuilderHost(sys2, cb, buildHost, solutionPerformance);
+  const builder = createSolutionBuilder(buildHost, projects, buildOptions);
+  const exitStatus = buildOptions.clean ? builder.clean() : builder.build();
+  reportSolutionBuilderTimes(builder, solutionPerformance);
+  dumpTracingLegend();
+  return sys2.exit(exitStatus);
+}
+function createReportErrorSummary(sys2, options) {
+  return shouldBePretty(sys2, options) ? (errorCount, filesInError) => sys2.write(getErrorSummaryText(errorCount, filesInError, sys2.newLine, sys2)) : void 0;
+}
+function performCompilation(sys2, cb, reportDiagnostic, config) {
+  const { fileNames, options, projectReferences } = config;
+  const host = createCompilerHostWorker(
+    options,
+    /*setParentNodes*/
+    void 0,
+    sys2
+  );
+  host.jsDocParsingMode = defaultJSDocParsingMode;
+  const currentDirectory = host.getCurrentDirectory();
+  const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
+  changeCompilerHostLikeToUseCache(host, (fileName) => toPath(fileName, currentDirectory, getCanonicalFileName));
+  enableStatisticsAndTracing(
+    sys2,
+    options,
+    /*isBuildMode*/
+    false
+  );
+  const programOptions = {
+    rootNames: fileNames,
+    options,
+    projectReferences,
+    host,
+    configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config)
+  };
+  const program = createProgram(programOptions);
+  const exitStatus = emitFilesAndReportErrorsAndGetExitStatus(
+    program,
+    reportDiagnostic,
+    (s) => sys2.write(s + sys2.newLine),
+    createReportErrorSummary(sys2, options)
+  );
+  reportStatistics(
+    sys2,
+    program,
+    /*solutionPerformance*/
+    void 0
+  );
+  cb(program);
+  return sys2.exit(exitStatus);
+}
+function performIncrementalCompilation2(sys2, cb, reportDiagnostic, config) {
+  const { options, fileNames, projectReferences } = config;
+  enableStatisticsAndTracing(
+    sys2,
+    options,
+    /*isBuildMode*/
+    false
+  );
+  const host = createIncrementalCompilerHost(options, sys2);
+  host.jsDocParsingMode = defaultJSDocParsingMode;
+  const exitStatus = performIncrementalCompilation({
+    host,
+    system: sys2,
+    rootNames: fileNames,
+    options,
+    configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config),
+    projectReferences,
+    reportDiagnostic,
+    reportErrorSummary: createReportErrorSummary(sys2, options),
+    afterProgramEmitAndDiagnostics: (builderProgram) => {
+      reportStatistics(
+        sys2,
+        builderProgram.getProgram(),
+        /*solutionPerformance*/
+        void 0
+      );
+      cb(builderProgram);
+    }
+  });
+  return sys2.exit(exitStatus);
+}
+function updateSolutionBuilderHost(sys2, cb, buildHost, solutionPerformance) {
+  updateCreateProgram(
+    sys2,
+    buildHost,
+    /*isBuildMode*/
+    true
+  );
+  buildHost.afterProgramEmitAndDiagnostics = (program) => {
+    reportStatistics(sys2, program.getProgram(), solutionPerformance);
+    cb(program);
+  };
+}
+function updateCreateProgram(sys2, host, isBuildMode) {
+  const compileUsingBuilder = host.createProgram;
+  host.createProgram = (rootNames, options, host2, oldProgram, configFileParsingDiagnostics, projectReferences) => {
+    Debug.assert(rootNames !== void 0 || options === void 0 && !!oldProgram);
+    if (options !== void 0) {
+      enableStatisticsAndTracing(sys2, options, isBuildMode);
+    }
+    return compileUsingBuilder(rootNames, options, host2, oldProgram, configFileParsingDiagnostics, projectReferences);
+  };
+}
+function updateWatchCompilationHost(sys2, cb, watchCompilerHost) {
+  watchCompilerHost.jsDocParsingMode = defaultJSDocParsingMode;
+  updateCreateProgram(
+    sys2,
+    watchCompilerHost,
+    /*isBuildMode*/
+    false
+  );
+  const emitFilesUsingBuilder = watchCompilerHost.afterProgramCreate;
+  watchCompilerHost.afterProgramCreate = (builderProgram) => {
+    emitFilesUsingBuilder(builderProgram);
+    reportStatistics(
+      sys2,
+      builderProgram.getProgram(),
+      /*solutionPerformance*/
+      void 0
+    );
+    cb(builderProgram);
+  };
+}
+function createWatchStatusReporter2(sys2, options) {
+  return createWatchStatusReporter(sys2, shouldBePretty(sys2, options));
+}
+function createWatchOfConfigFile(system, cb, reportDiagnostic, configParseResult, optionsToExtend, watchOptionsToExtend, extendedConfigCache) {
+  const watchCompilerHost = createWatchCompilerHostOfConfigFile({
+    configFileName: configParseResult.options.configFilePath,
+    optionsToExtend,
+    watchOptionsToExtend,
+    system,
+    reportDiagnostic,
+    reportWatchStatus: createWatchStatusReporter2(system, configParseResult.options)
+  });
+  updateWatchCompilationHost(system, cb, watchCompilerHost);
+  watchCompilerHost.configFileParsingResult = configParseResult;
+  watchCompilerHost.extendedConfigCache = extendedConfigCache;
+  return createWatchProgram(watchCompilerHost);
+}
+function createWatchOfFilesAndCompilerOptions(system, cb, reportDiagnostic, rootFiles, options, watchOptions) {
+  const watchCompilerHost = createWatchCompilerHostOfFilesAndCompilerOptions({
+    rootFiles,
+    options,
+    watchOptions,
+    system,
+    reportDiagnostic,
+    reportWatchStatus: createWatchStatusReporter2(system, options)
+  });
+  updateWatchCompilationHost(system, cb, watchCompilerHost);
+  return createWatchProgram(watchCompilerHost);
+}
+function enableSolutionPerformance(system, options) {
+  if (system === sys && options.extendedDiagnostics) {
+    enable();
+    return createSolutionPerfomrance();
+  }
+}
+function createSolutionPerfomrance() {
+  let statistics;
+  return {
+    addAggregateStatistic,
+    forEachAggregateStatistics: forEachAggreateStatistics,
+    clear: clear2
+  };
+  function addAggregateStatistic(s) {
+    const existing = statistics == null ? void 0 : statistics.get(s.name);
+    if (existing) {
+      if (existing.type === 2 /* memory */)
+        existing.value = Math.max(existing.value, s.value);
+      else
+        existing.value += s.value;
+    } else {
+      (statistics ?? (statistics = /* @__PURE__ */ new Map())).set(s.name, s);
+    }
+  }
+  function forEachAggreateStatistics(cb) {
+    statistics == null ? void 0 : statistics.forEach(cb);
+  }
+  function clear2() {
+    statistics = void 0;
+  }
+}
+function reportSolutionBuilderTimes(builder, solutionPerformance) {
+  if (!solutionPerformance)
+    return;
+  if (!isEnabled()) {
+    sys.write(Diagnostics.Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found.message + "\n");
+    return;
+  }
+  const statistics = [];
+  statistics.push(
+    { name: "Projects in scope", value: getBuildOrderFromAnyBuildOrder(builder.getBuildOrder()).length, type: 1 /* count */ }
+  );
+  reportSolutionBuilderCountStatistic("SolutionBuilder::Projects built");
+  reportSolutionBuilderCountStatistic("SolutionBuilder::Timestamps only updates");
+  reportSolutionBuilderCountStatistic("SolutionBuilder::Bundles updated");
+  solutionPerformance.forEachAggregateStatistics((s) => {
+    s.name = `Aggregate ${s.name}`;
+    statistics.push(s);
+  });
+  forEachMeasure((name, duration) => {
+    if (isSolutionMarkOrMeasure(name))
+      statistics.push({ name: `${getNameFromSolutionBuilderMarkOrMeasure(name)} time`, value: duration, type: 0 /* time */ });
+  });
+  disable();
+  enable();
+  solutionPerformance.clear();
+  reportAllStatistics(sys, statistics);
+  function reportSolutionBuilderCountStatistic(name) {
+    const value = getCount(name);
+    if (value) {
+      statistics.push({ name: getNameFromSolutionBuilderMarkOrMeasure(name), value, type: 1 /* count */ });
+    }
+  }
+  function getNameFromSolutionBuilderMarkOrMeasure(name) {
+    return name.replace("SolutionBuilder::", "");
+  }
+}
+function canReportDiagnostics(system, compilerOptions) {
+  return system === sys && (compilerOptions.diagnostics || compilerOptions.extendedDiagnostics);
+}
+function canTrace(system, compilerOptions) {
+  return system === sys && compilerOptions.generateTrace;
+}
+function enableStatisticsAndTracing(system, compilerOptions, isBuildMode) {
+  if (canReportDiagnostics(system, compilerOptions)) {
+    enable(system);
+  }
+  if (canTrace(system, compilerOptions)) {
+    startTracing(isBuildMode ? "build" : "project", compilerOptions.generateTrace, compilerOptions.configFilePath);
+  }
+}
+function isSolutionMarkOrMeasure(name) {
+  return startsWith(name, "SolutionBuilder::");
+}
+function reportStatistics(sys2, program, solutionPerformance) {
+  var _a;
+  const compilerOptions = program.getCompilerOptions();
+  if (canTrace(sys2, compilerOptions)) {
+    (_a = tracing) == null ? void 0 : _a.stopTracing();
+  }
+  let statistics;
+  if (canReportDiagnostics(sys2, compilerOptions)) {
+    statistics = [];
+    const memoryUsed = sys2.getMemoryUsage ? sys2.getMemoryUsage() : -1;
+    reportCountStatistic("Files", program.getSourceFiles().length);
+    const lineCounts = countLines(program);
+    if (compilerOptions.extendedDiagnostics) {
+      for (const [key, value] of lineCounts.entries()) {
+        reportCountStatistic("Lines of " + key, value);
+      }
+    } else {
+      reportCountStatistic("Lines", reduceLeftIterator(lineCounts.values(), (sum, count) => sum + count, 0));
+    }
+    reportCountStatistic("Identifiers", program.getIdentifierCount());
+    reportCountStatistic("Symbols", program.getSymbolCount());
+    reportCountStatistic("Types", program.getTypeCount());
+    reportCountStatistic("Instantiations", program.getInstantiationCount());
+    if (memoryUsed >= 0) {
+      reportStatisticalValue(
+        { name: "Memory used", value: memoryUsed, type: 2 /* memory */ },
+        /*aggregate*/
+        true
+      );
+    }
+    const isPerformanceEnabled = isEnabled();
+    const programTime = isPerformanceEnabled ? getDuration("Program") : 0;
+    const bindTime = isPerformanceEnabled ? getDuration("Bind") : 0;
+    const checkTime = isPerformanceEnabled ? getDuration("Check") : 0;
+    const emitTime = isPerformanceEnabled ? getDuration("Emit") : 0;
+    if (compilerOptions.extendedDiagnostics) {
+      const caches = program.getRelationCacheSizes();
+      reportCountStatistic("Assignability cache size", caches.assignable);
+      reportCountStatistic("Identity cache size", caches.identity);
+      reportCountStatistic("Subtype cache size", caches.subtype);
+      reportCountStatistic("Strict subtype cache size", caches.strictSubtype);
+      if (isPerformanceEnabled) {
+        forEachMeasure((name, duration) => {
+          if (!isSolutionMarkOrMeasure(name))
+            reportTimeStatistic(
+              `${name} time`,
+              duration,
+              /*aggregate*/
+              true
+            );
+        });
+      }
+    } else if (isPerformanceEnabled) {
+      reportTimeStatistic(
+        "I/O read",
+        getDuration("I/O Read"),
+        /*aggregate*/
+        true
+      );
+      reportTimeStatistic(
+        "I/O write",
+        getDuration("I/O Write"),
+        /*aggregate*/
+        true
+      );
+      reportTimeStatistic(
+        "Parse time",
+        programTime,
+        /*aggregate*/
+        true
+      );
+      reportTimeStatistic(
+        "Bind time",
+        bindTime,
+        /*aggregate*/
+        true
+      );
+      reportTimeStatistic(
+        "Check time",
+        checkTime,
+        /*aggregate*/
+        true
+      );
+      reportTimeStatistic(
+        "Emit time",
+        emitTime,
+        /*aggregate*/
+        true
+      );
+    }
+    if (isPerformanceEnabled) {
+      reportTimeStatistic(
+        "Total time",
+        programTime + bindTime + checkTime + emitTime,
+        /*aggregate*/
+        false
+      );
+    }
+    reportAllStatistics(sys2, statistics);
+    if (!isPerformanceEnabled) {
+      sys2.write(Diagnostics.Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found.message + "\n");
+    } else {
+      if (solutionPerformance) {
+        forEachMeasure((name) => {
+          if (!isSolutionMarkOrMeasure(name))
+            clearMeasures(name);
+        });
+        forEachMark((name) => {
+          if (!isSolutionMarkOrMeasure(name))
+            clearMarks(name);
+        });
+      } else {
+        disable();
+      }
+    }
+  }
+  function reportStatisticalValue(s, aggregate) {
+    statistics.push(s);
+    if (aggregate)
+      solutionPerformance == null ? void 0 : solutionPerformance.addAggregateStatistic(s);
+  }
+  function reportCountStatistic(name, count) {
+    reportStatisticalValue(
+      { name, value: count, type: 1 /* count */ },
+      /*aggregate*/
+      true
+    );
+  }
+  function reportTimeStatistic(name, time, aggregate) {
+    reportStatisticalValue({ name, value: time, type: 0 /* time */ }, aggregate);
+  }
+}
+function reportAllStatistics(sys2, statistics) {
+  let nameSize = 0;
+  let valueSize = 0;
+  for (const s of statistics) {
+    if (s.name.length > nameSize) {
+      nameSize = s.name.length;
+    }
+    const value = statisticValue(s);
+    if (value.length > valueSize) {
+      valueSize = value.length;
+    }
+  }
+  for (const s of statistics) {
+    sys2.write(`${s.name}:`.padEnd(nameSize + 2) + statisticValue(s).toString().padStart(valueSize) + sys2.newLine);
+  }
+}
+function statisticValue(s) {
+  switch (s.type) {
+    case 1 /* count */:
+      return "" + s.value;
+    case 0 /* time */:
+      return (s.value / 1e3).toFixed(2) + "s";
+    case 2 /* memory */:
+      return Math.round(s.value / 1e3) + "K";
+    default:
+      Debug.assertNever(s.type);
+  }
+}
+function writeConfigFile(sys2, reportDiagnostic, options, fileNames) {
+  const currentDirectory = sys2.getCurrentDirectory();
+  const file = normalizePath(combinePaths(currentDirectory, "tsconfig.json"));
+  if (sys2.fileExists(file)) {
+    reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file));
+  } else {
+    sys2.writeFile(file, generateTSConfig(options, fileNames, sys2.newLine));
+    const output = [sys2.newLine, ...getHeader(sys2, "Created a new tsconfig.json with:")];
+    output.push(getCompilerOptionsDiffValue(options, sys2.newLine) + sys2.newLine + sys2.newLine);
+    output.push(`You can learn more at https://aka.ms/tsconfig` + sys2.newLine);
+    for (const line of output) {
+      sys2.write(line);
+    }
+  }
+  return;
+}
+
 // src/jsTyping/_namespaces/ts.JsTyping.ts
 var ts_JsTyping_exports = {};
 __export(ts_JsTyping_exports, {
@@ -144390,11 +145794,14 @@ var NodeObject = class {
   constructor(kind, pos, end) {
     this.pos = pos;
     this.end = end;
+    this.kind = kind;
+    this.id = 0;
     this.flags = 0 /* None */;
     this.modifierFlagsCache = 0 /* None */;
     this.transformFlags = 0 /* None */;
     this.parent = void 0;
-    this.kind = kind;
+    this.original = void 0;
+    this.emitNode = void 0;
   }
   assertHasRealPosition(message) {
     Debug.assert(!positionIsSynthesized(this.pos) && !positionIsSynthesized(this.end), message || "Node must have a real position for this operation");
@@ -144445,7 +145852,7 @@ var NodeObject = class {
   }
   getChildren(sourceFile) {
     this.assertHasRealPosition("Node without a real position cannot be scanned and thus has no token nodes - use forEachChild and collect the result if that's fine");
-    return this._children || (this._children = createChildren(this, sourceFile));
+    return getNodeChildren(this) ?? setNodeChildren(this, createChildren(this, sourceFile));
   }
   getFirstToken(sourceFile) {
     this.assertHasRealPosition();
@@ -144521,24 +145928,27 @@ function addSyntheticNodes(nodes, pos, end, parent2) {
 }
 function createSyntaxList(nodes, parent2) {
   const list = createNode(352 /* SyntaxList */, nodes.pos, nodes.end, parent2);
-  list._children = [];
+  const children = [];
   let pos = nodes.pos;
   for (const node of nodes) {
-    addSyntheticNodes(list._children, pos, node.pos, parent2);
-    list._children.push(node);
+    addSyntheticNodes(children, pos, node.pos, parent2);
+    children.push(node);
     pos = node.end;
   }
-  addSyntheticNodes(list._children, pos, nodes.end, parent2);
+  addSyntheticNodes(children, pos, nodes.end, parent2);
+  setNodeChildren(list, children);
   return list;
 }
 var TokenOrIdentifierObject = class {
-  constructor(pos, end) {
+  constructor(kind, pos, end) {
     this.pos = pos;
     this.end = end;
+    this.kind = kind;
+    this.id = 0;
     this.flags = 0 /* None */;
-    this.modifierFlagsCache = 0 /* None */;
     this.transformFlags = 0 /* None */;
     this.parent = void 0;
+    this.emitNode = void 0;
   }
   getSourceFile() {
     return getSourceFileOfNode(this);
@@ -144591,10 +146001,20 @@ var TokenOrIdentifierObject = class {
 };
 var SymbolObject = class {
   constructor(flags, name) {
-    this.id = 0;
-    this.mergeId = 0;
     this.flags = flags;
     this.escapedName = name;
+    this.declarations = void 0;
+    this.valueDeclaration = void 0;
+    this.id = 0;
+    this.mergeId = 0;
+    this.parent = void 0;
+    this.members = void 0;
+    this.exports = void 0;
+    this.exportSymbol = void 0;
+    this.constEnumOnlyModule = void 0;
+    this.isReferenced = void 0;
+    this.lastAssignmentPos = void 0;
+    this.links = void 0;
   }
   getFlags() {
     return this.flags;
@@ -144674,34 +146094,29 @@ var SymbolObject = class {
 };
 var TokenObject = class extends TokenOrIdentifierObject {
   constructor(kind, pos, end) {
-    super(pos, end);
-    this.kind = kind;
+    super(kind, pos, end);
   }
 };
 var IdentifierObject = class extends TokenOrIdentifierObject {
-  constructor(_kind, pos, end) {
-    super(pos, end);
-    this.kind = 80 /* Identifier */;
+  constructor(kind, pos, end) {
+    super(kind, pos, end);
   }
   get text() {
     return idText(this);
   }
 };
-IdentifierObject.prototype.kind = 80 /* Identifier */;
 var PrivateIdentifierObject = class extends TokenOrIdentifierObject {
-  constructor(_kind, pos, end) {
-    super(pos, end);
-    this.kind = 81 /* PrivateIdentifier */;
+  constructor(kind, pos, end) {
+    super(kind, pos, end);
   }
   get text() {
     return idText(this);
   }
 };
-PrivateIdentifierObject.prototype.kind = 81 /* PrivateIdentifier */;
 var TypeObject = class {
   constructor(checker, flags) {
-    this.checker = checker;
     this.flags = flags;
+    this.checker = checker;
   }
   getFlags() {
     return this.flags;
@@ -144791,8 +146206,8 @@ var TypeObject = class {
 var SignatureObject = class {
   // same
   constructor(checker, flags) {
-    this.checker = checker;
     this.flags = flags;
+    this.checker = checker;
   }
   getDeclaration() {
     return this.declaration;
@@ -144888,7 +146303,6 @@ function findBaseOfDeclaration(checker, declaration, cb) {
 var SourceFileObject = class extends NodeObject {
   constructor(kind, pos, end) {
     super(kind, pos, end);
-    this.kind = 307 /* SourceFile */;
   }
   update(newText, textChangeRange) {
     return updateSourceFile(this, newText, textChangeRange);
@@ -145039,7 +146453,7 @@ var SourceMapSourceObject = class {
   constructor(fileName, text, skipTrivia2) {
     this.fileName = fileName;
     this.text = text;
-    this.skipTrivia = skipTrivia2;
+    this.skipTrivia = skipTrivia2 || ((pos) => pos);
   }
   getLineAndCharacterOfPosition(pos) {
     return getLineAndCharacterOfPosition(this, pos);
@@ -145682,6 +147096,9 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
   function shouldGetType(sourceFile, node, position) {
     switch (node.kind) {
       case 80 /* Identifier */:
+        if (node.flags & 16777216 /* JSDoc */ && !isInJSFile(node) && (node.parent.kind === 171 /* PropertySignature */ && node.parent.name === node || findAncestor(node, (n) => n.kind === 169 /* Parameter */))) {
+          return false;
+        }
         return !isLabelName(node) && !isTagName(node) && !isConstTypeReference(node.parent);
       case 211 /* PropertyAccessExpression */:
       case 166 /* QualifiedName */:
@@ -150175,7 +151592,8 @@ function canConvertImportDeclarationForSpecifier(specifier, sourceFile, program)
   const checker = program.getTypeChecker();
   for (const specifier2 of nonTypeOnlySpecifiers) {
     const isUsedAsValue = ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(specifier2.name, checker, sourceFile, (usage) => {
-      return !isValidTypeOnlyAliasUseSite(usage);
+      const symbol = checker.getSymbolAtLocation(usage);
+      return !!symbol && checker.symbolIsValue(symbol) || !isValidTypeOnlyAliasUseSite(usage);
     });
     if (isUsedAsValue) {
       return false;
@@ -173560,7 +174978,8 @@ var SmartIndenter;
         return childKind !== 290 /* JsxClosingFragment */;
       case 193 /* IntersectionType */:
       case 192 /* UnionType */:
-        if (childKind === 187 /* TypeLiteral */ || childKind === 189 /* TupleType */) {
+      case 238 /* SatisfiesExpression */:
+        if (childKind === 187 /* TypeLiteral */ || childKind === 189 /* TupleType */ || childKind === 200 /* MappedType */) {
           return false;
         }
         break;
@@ -173728,6 +175147,7 @@ __export(ts_exports2, {
   SignatureKind: () => SignatureKind,
   SmartSelectionRange: () => ts_SmartSelectionRange_exports,
   SnippetKind: () => SnippetKind,
+  StatisticType: () => StatisticType,
   StructureIsReused: () => StructureIsReused,
   SymbolAccessibility: () => SymbolAccessibility,
   SymbolDisplay: () => ts_SymbolDisplay_exports,
@@ -173976,6 +175396,7 @@ __export(ts_exports2, {
   createExternalHelpersImportDeclarationIfNeeded: () => createExternalHelpersImportDeclarationIfNeeded,
   createFileDiagnostic: () => createFileDiagnostic,
   createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain,
+  createFlowNode: () => createFlowNode,
   createForOfBindingStatement: () => createForOfBindingStatement,
   createGetCanonicalFileName: () => createGetCanonicalFileName,
   createGetSourceFile: () => createGetSourceFile,
@@ -174107,7 +175528,9 @@ __export(ts_exports2, {
   escapeSnippetText: () => escapeSnippetText,
   escapeString: () => escapeString,
   escapeTemplateSubstitution: () => escapeTemplateSubstitution,
+  evaluatorResult: () => evaluatorResult,
   every: () => every,
+  executeCommandLine: () => executeCommandLine,
   expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression,
   explainFiles: () => explainFiles,
   explainIfFileIsRedirectAndImpliedFormat: () => explainIfFileIsRedirectAndImpliedFormat,
@@ -174473,6 +175896,7 @@ __export(ts_exports2, {
   getNewLineOrDefaultFromHost: () => getNewLineOrDefaultFromHost,
   getNewTargetContainer: () => getNewTargetContainer,
   getNextJSDocCommentLocation: () => getNextJSDocCommentLocation,
+  getNodeChildren: () => getNodeChildren,
   getNodeForGeneratedName: () => getNodeForGeneratedName,
   getNodeId: () => getNodeId,
   getNodeKind: () => getNodeKind,
@@ -174795,6 +176219,7 @@ __export(ts_exports2, {
   isBooleanLiteral: () => isBooleanLiteral,
   isBreakOrContinueStatement: () => isBreakOrContinueStatement,
   isBreakStatement: () => isBreakStatement,
+  isBuild: () => isBuild,
   isBuildInfoFile: () => isBuildInfoFile,
   isBuilderProgram: () => isBuilderProgram2,
   isBundle: () => isBundle,
@@ -175326,7 +176751,6 @@ __export(ts_exports2, {
   isSuperProperty: () => isSuperProperty,
   isSupportedSourceFileName: () => isSupportedSourceFileName,
   isSwitchStatement: () => isSwitchStatement,
-  isSyntacticallyString: () => isSyntacticallyString,
   isSyntaxList: () => isSyntaxList,
   isSyntheticExpression: () => isSyntheticExpression,
   isSyntheticReference: () => isSyntheticReference,
@@ -175658,6 +177082,7 @@ __export(ts_exports2, {
   setInternalEmitFlags: () => setInternalEmitFlags,
   setLocalizedDiagnosticMessages: () => setLocalizedDiagnosticMessages,
   setModuleDefaultHelper: () => setModuleDefaultHelper,
+  setNodeChildren: () => setNodeChildren,
   setNodeFlags: () => setNodeFlags,
   setObjectAllocator: () => setObjectAllocator,
   setOriginalNode: () => setOriginalNode,
@@ -175852,6 +177277,7 @@ __export(ts_exports2, {
   unorderedRemoveItem: () => unorderedRemoveItem,
   unorderedRemoveItemAt: () => unorderedRemoveItemAt,
   unreachableCodeIsError: () => unreachableCodeIsError,
+  unsetNodeChildren: () => unsetNodeChildren,
   unusedLabelIsError: () => unusedLabelIsError,
   unwrapInnermostStatementOfLabel: () => unwrapInnermostStatementOfLabel,
   updateErrorForNoInputFiles: () => updateErrorForNoInputFiles,
@@ -187944,6 +189370,7 @@ if (typeof console !== "undefined") {
   SignatureKind,
   SmartSelectionRange,
   SnippetKind,
+  StatisticType,
   StructureIsReused,
   SymbolAccessibility,
   SymbolDisplay,
@@ -188192,6 +189619,7 @@ if (typeof console !== "undefined") {
   createExternalHelpersImportDeclarationIfNeeded,
   createFileDiagnostic,
   createFileDiagnosticFromMessageChain,
+  createFlowNode,
   createForOfBindingStatement,
   createGetCanonicalFileName,
   createGetSourceFile,
@@ -188323,7 +189751,9 @@ if (typeof console !== "undefined") {
   escapeSnippetText,
   escapeString,
   escapeTemplateSubstitution,
+  evaluatorResult,
   every,
+  executeCommandLine,
   expandPreOrPostfixIncrementOrDecrementExpression,
   explainFiles,
   explainIfFileIsRedirectAndImpliedFormat,
@@ -188689,6 +190119,7 @@ if (typeof console !== "undefined") {
   getNewLineOrDefaultFromHost,
   getNewTargetContainer,
   getNextJSDocCommentLocation,
+  getNodeChildren,
   getNodeForGeneratedName,
   getNodeId,
   getNodeKind,
@@ -189011,6 +190442,7 @@ if (typeof console !== "undefined") {
   isBooleanLiteral,
   isBreakOrContinueStatement,
   isBreakStatement,
+  isBuild,
   isBuildInfoFile,
   isBuilderProgram,
   isBundle,
@@ -189542,7 +190974,6 @@ if (typeof console !== "undefined") {
   isSuperProperty,
   isSupportedSourceFileName,
   isSwitchStatement,
-  isSyntacticallyString,
   isSyntaxList,
   isSyntheticExpression,
   isSyntheticReference,
@@ -189874,6 +191305,7 @@ if (typeof console !== "undefined") {
   setInternalEmitFlags,
   setLocalizedDiagnosticMessages,
   setModuleDefaultHelper,
+  setNodeChildren,
   setNodeFlags,
   setObjectAllocator,
   setOriginalNode,
@@ -190068,6 +191500,7 @@ if (typeof console !== "undefined") {
   unorderedRemoveItem,
   unorderedRemoveItemAt,
   unreachableCodeIsError,
+  unsetNodeChildren,
   unusedLabelIsError,
   unwrapInnermostStatementOfLabel,
   updateErrorForNoInputFiles,