typescript 5.3.1-rc → 5.4.0-dev.20231104

package/lib/tsserver.js

@@ -1721,6 +1721,8 @@ __export(server_exports, {
   isSignedNumericLiteral: () => isSignedNumericLiteral,
   isSimpleCopiableExpression: () => isSimpleCopiableExpression,
   isSimpleInlineableExpression: () => isSimpleInlineableExpression,
+  isSimpleParameter: () => isSimpleParameter,
+  isSimpleParameterList: () => isSimpleParameterList,
   isSingleOrDoubleQuote: () => isSingleOrDoubleQuote,
   isSourceFile: () => isSourceFile,
   isSourceFileFromLibrary: () => isSourceFileFromLibrary,
@@ -2327,8 +2329,8 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.3";
-var version = "5.3.1-rc";
+var versionMajorMinor = "5.4";
+var version = `${versionMajorMinor}.0-dev.20231104`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -27668,7 +27670,7 @@ function createEmitHelperFactory(context) {
       ]
     );
   }
-  function createAwaiterHelper(hasLexicalThis, hasLexicalArguments, promiseConstructor, body) {
+  function createAwaiterHelper(hasLexicalThis, argumentsExpression, promiseConstructor, parameters, body) {
     context.requestEmitHelper(awaiterHelper);
     const generatorFunc = factory2.createFunctionExpression(
       /*modifiers*/
@@ -27678,8 +27680,7 @@ function createEmitHelperFactory(context) {
       void 0,
       /*typeParameters*/
       void 0,
-      /*parameters*/
-      [],
+      parameters ?? [],
       /*type*/
       void 0,
       body
@@ -27691,7 +27692,7 @@ function createEmitHelperFactory(context) {
       void 0,
       [
         hasLexicalThis ? factory2.createThis() : factory2.createVoidZero(),
-        hasLexicalArguments ? factory2.createIdentifier("arguments") : factory2.createVoidZero(),
+        argumentsExpression ?? factory2.createVoidZero(),
         promiseConstructor ? createExpressionFromEntityName(factory2, promiseConstructor) : factory2.createVoidZero(),
         generatorFunc
       ]
@@ -38246,6 +38247,7 @@ var libEntries = [
   ["es2015.symbol", "lib.es2015.symbol.d.ts"],
   ["es2015.symbol.wellknown", "lib.es2015.symbol.wellknown.d.ts"],
   ["es2016.array.include", "lib.es2016.array.include.d.ts"],
+  ["es2016.intl", "lib.es2016.intl.d.ts"],
   ["es2017.date", "lib.es2017.date.d.ts"],
   ["es2017.object", "lib.es2017.object.d.ts"],
   ["es2017.sharedmemory", "lib.es2017.sharedmemory.d.ts"],
@@ -38577,6 +38579,7 @@ var targetOptionDeclaration = {
   affectsModuleResolution: true,
   affectsEmit: true,
   affectsBuildInfo: true,
+  deprecatedKeys: /* @__PURE__ */ new Set(["es3"]),
   paramType: Diagnostics.VERSION,
   showInSimplifiedHelpView: true,
   category: Diagnostics.Language_and_Environment,
@@ -44693,6 +44696,9 @@ function createBinder() {
       case 213 /* CallExpression */:
         return hasNarrowableArgument(expr);
       case 217 /* ParenthesizedExpression */:
+        if (isJSDocTypeAssertion(expr)) {
+          return false;
+        }
       case 235 /* NonNullExpression */:
         return isNarrowingExpression(expr.expression);
       case 226 /* BinaryExpression */:
@@ -71570,15 +71576,23 @@ function createTypeChecker(host) {
         error2(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers);
         return errorType;
       }
-      const container = getContainingFunction(node);
-      if (languageVersion < 2 /* ES2015 */) {
-        if (container.kind === 219 /* ArrowFunction */) {
-          error2(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
-        } else if (hasSyntacticModifier(container, 1024 /* Async */)) {
-          error2(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method);
+      let container = getContainingFunction(node);
+      if (container) {
+        if (languageVersion < 2 /* ES2015 */) {
+          if (container.kind === 219 /* ArrowFunction */) {
+            error2(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
+          } else if (hasSyntacticModifier(container, 1024 /* Async */)) {
+            error2(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method);
+          }
+        }
+        getNodeLinks(container).flags |= 512 /* CaptureArguments */;
+        while (container && isArrowFunction(container)) {
+          container = getContainingFunction(container);
+          if (container) {
+            getNodeLinks(container).flags |= 512 /* CaptureArguments */;
+          }
         }
       }
-      getNodeLinks(container).flags |= 512 /* CaptureArguments */;
       return getTypeOfSymbol(symbol);
     }
     if (shouldMarkIdentifierAliasReferenced(node)) {
@@ -91606,6 +91620,12 @@ function setPrivateIdentifier(privateEnv, name, entry) {
 function accessPrivateIdentifier(env, name) {
   return walkUpLexicalEnvironments(env, (env2) => getPrivateIdentifier(env2.privateEnv, name));
 }
+function isSimpleParameter(node) {
+  return !node.initializer && isIdentifier(node.name);
+}
+function isSimpleParameterList(nodes) {
+  return every(nodes, isSimpleParameter);
+}
 
 // src/compiler/transformers/destructuring.ts
 var FlattenLevel = /* @__PURE__ */ ((FlattenLevel2) => {
@@ -99092,6 +99112,7 @@ function transformES2017(context) {
   let enclosingFunctionParameterNames;
   let capturedSuperProperties;
   let hasSuperElementAccess;
+  let lexicalArgumentsBinding;
   const substitutedSuperAccessors = [];
   let contextFlags = 0 /* None */;
   const previousOnEmitNode = context.onEmitNode;
@@ -99142,9 +99163,30 @@ function transformES2017(context) {
   function visitDefault(node) {
     return visitEachChild(node, visitor, context);
   }
+  function argumentsVisitor(node) {
+    switch (node.kind) {
+      case 218 /* FunctionExpression */:
+      case 262 /* FunctionDeclaration */:
+      case 174 /* MethodDeclaration */:
+      case 177 /* GetAccessor */:
+      case 178 /* SetAccessor */:
+      case 176 /* Constructor */:
+        return node;
+      case 169 /* Parameter */:
+      case 208 /* BindingElement */:
+      case 260 /* VariableDeclaration */:
+        break;
+      case 80 /* Identifier */:
+        if (lexicalArgumentsBinding && resolver.isArgumentsLocalBinding(node)) {
+          return lexicalArgumentsBinding;
+        }
+        break;
+    }
+    return visitEachChild(node, argumentsVisitor, context);
+  }
   function visitor(node) {
     if ((node.transformFlags & 256 /* ContainsES2017 */) === 0) {
-      return node;
+      return lexicalArgumentsBinding ? argumentsVisitor(node) : node;
     }
     switch (node.kind) {
       case 134 /* AsyncKeyword */:
@@ -99302,15 +99344,23 @@ function transformES2017(context) {
     );
   }
   function visitConstructorDeclaration(node) {
-    return factory2.updateConstructorDeclaration(
+    const savedLexicalArgumentsBinding = lexicalArgumentsBinding;
+    lexicalArgumentsBinding = void 0;
+    const updated = factory2.updateConstructorDeclaration(
       node,
       visitNodes2(node.modifiers, visitor, isModifier),
       visitParameterList(node.parameters, visitor, context),
       transformMethodBody(node)
     );
+    lexicalArgumentsBinding = savedLexicalArgumentsBinding;
+    return updated;
   }
   function visitMethodDeclaration(node) {
-    return factory2.updateMethodDeclaration(
+    let parameters;
+    const functionFlags = getFunctionFlags(node);
+    const savedLexicalArgumentsBinding = lexicalArgumentsBinding;
+    lexicalArgumentsBinding = void 0;
+    const updated = factory2.updateMethodDeclaration(
       node,
       visitNodes2(node.modifiers, visitor, isModifierLike),
       node.asteriskToken,
@@ -99319,14 +99369,18 @@ function transformES2017(context) {
       void 0,
       /*typeParameters*/
       void 0,
-      visitParameterList(node.parameters, visitor, context),
+      parameters = functionFlags & 2 /* Async */ ? transformAsyncFunctionParameterList(node) : visitParameterList(node.parameters, visitor, context),
       /*type*/
       void 0,
-      getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : transformMethodBody(node)
+      functionFlags & 2 /* Async */ ? transformAsyncFunctionBody(node, parameters) : transformMethodBody(node)
     );
+    lexicalArgumentsBinding = savedLexicalArgumentsBinding;
+    return updated;
   }
   function visitGetAccessorDeclaration(node) {
-    return factory2.updateGetAccessorDeclaration(
+    const savedLexicalArgumentsBinding = lexicalArgumentsBinding;
+    lexicalArgumentsBinding = void 0;
+    const updated = factory2.updateGetAccessorDeclaration(
       node,
       visitNodes2(node.modifiers, visitor, isModifierLike),
       node.name,
@@ -99335,55 +99389,75 @@ function transformES2017(context) {
       void 0,
       transformMethodBody(node)
     );
+    lexicalArgumentsBinding = savedLexicalArgumentsBinding;
+    return updated;
   }
   function visitSetAccessorDeclaration(node) {
-    return factory2.updateSetAccessorDeclaration(
+    const savedLexicalArgumentsBinding = lexicalArgumentsBinding;
+    lexicalArgumentsBinding = void 0;
+    const updated = factory2.updateSetAccessorDeclaration(
       node,
       visitNodes2(node.modifiers, visitor, isModifierLike),
       node.name,
       visitParameterList(node.parameters, visitor, context),
       transformMethodBody(node)
     );
+    lexicalArgumentsBinding = savedLexicalArgumentsBinding;
+    return updated;
   }
   function visitFunctionDeclaration(node) {
-    return factory2.updateFunctionDeclaration(
+    let parameters;
+    const savedLexicalArgumentsBinding = lexicalArgumentsBinding;
+    lexicalArgumentsBinding = void 0;
+    const functionFlags = getFunctionFlags(node);
+    const updated = factory2.updateFunctionDeclaration(
       node,
       visitNodes2(node.modifiers, visitor, isModifierLike),
       node.asteriskToken,
       node.name,
       /*typeParameters*/
       void 0,
-      visitParameterList(node.parameters, visitor, context),
+      parameters = functionFlags & 2 /* Async */ ? transformAsyncFunctionParameterList(node) : visitParameterList(node.parameters, visitor, context),
       /*type*/
       void 0,
-      getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context)
+      functionFlags & 2 /* Async */ ? transformAsyncFunctionBody(node, parameters) : visitFunctionBody(node.body, visitor, context)
     );
+    lexicalArgumentsBinding = savedLexicalArgumentsBinding;
+    return updated;
   }
   function visitFunctionExpression(node) {
-    return factory2.updateFunctionExpression(
+    let parameters;
+    const savedLexicalArgumentsBinding = lexicalArgumentsBinding;
+    lexicalArgumentsBinding = void 0;
+    const functionFlags = getFunctionFlags(node);
+    const updated = factory2.updateFunctionExpression(
       node,
       visitNodes2(node.modifiers, visitor, isModifier),
       node.asteriskToken,
       node.name,
       /*typeParameters*/
       void 0,
-      visitParameterList(node.parameters, visitor, context),
+      parameters = functionFlags & 2 /* Async */ ? transformAsyncFunctionParameterList(node) : visitParameterList(node.parameters, visitor, context),
       /*type*/
       void 0,
-      getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context)
+      functionFlags & 2 /* Async */ ? transformAsyncFunctionBody(node, parameters) : visitFunctionBody(node.body, visitor, context)
     );
+    lexicalArgumentsBinding = savedLexicalArgumentsBinding;
+    return updated;
   }
   function visitArrowFunction(node) {
+    let parameters;
+    const functionFlags = getFunctionFlags(node);
     return factory2.updateArrowFunction(
       node,
       visitNodes2(node.modifiers, visitor, isModifier),
       /*typeParameters*/
       void 0,
-      visitParameterList(node.parameters, visitor, context),
+      parameters = functionFlags & 2 /* Async */ ? transformAsyncFunctionParameterList(node) : visitParameterList(node.parameters, visitor, context),
       /*type*/
       void 0,
       node.equalsGreaterThanToken,
-      getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context)
+      functionFlags & 2 /* Async */ ? transformAsyncFunctionBody(node, parameters) : visitFunctionBody(node.body, visitor, context)
     );
   }
   function recordDeclarationName({ name }, names) {
@@ -99477,13 +99551,91 @@ function transformES2017(context) {
     hasSuperElementAccess = savedHasSuperElementAccess;
     return updated;
   }
-  function transformAsyncFunctionBody(node) {
+  function createCaptureArgumentsStatement() {
+    Debug.assert(lexicalArgumentsBinding);
+    const variable = factory2.createVariableDeclaration(
+      lexicalArgumentsBinding,
+      /*exclamationToken*/
+      void 0,
+      /*type*/
+      void 0,
+      factory2.createIdentifier("arguments")
+    );
+    const statement = factory2.createVariableStatement(
+      /*modifiers*/
+      void 0,
+      [variable]
+    );
+    startOnNewLine(statement);
+    addEmitFlags(statement, 2097152 /* CustomPrologue */);
+    return statement;
+  }
+  function transformAsyncFunctionParameterList(node) {
+    if (isSimpleParameterList(node.parameters)) {
+      return visitParameterList(node.parameters, visitor, context);
+    }
+    const newParameters = [];
+    for (const parameter of node.parameters) {
+      if (parameter.initializer || parameter.dotDotDotToken) {
+        if (node.kind === 219 /* ArrowFunction */) {
+          const restParameter = factory2.createParameterDeclaration(
+            /*modifiers*/
+            void 0,
+            factory2.createToken(26 /* DotDotDotToken */),
+            factory2.createUniqueName("args", 8 /* ReservedInNestedScopes */)
+          );
+          newParameters.push(restParameter);
+        }
+        break;
+      }
+      const newParameter = factory2.createParameterDeclaration(
+        /*modifiers*/
+        void 0,
+        /*dotDotDotToken*/
+        void 0,
+        factory2.getGeneratedNameForNode(parameter.name, 8 /* ReservedInNestedScopes */)
+      );
+      newParameters.push(newParameter);
+    }
+    const newParametersArray = factory2.createNodeArray(newParameters);
+    setTextRange(newParametersArray, node.parameters);
+    return newParametersArray;
+  }
+  function transformAsyncFunctionBody(node, outerParameters) {
+    const innerParameters = !isSimpleParameterList(node.parameters) ? visitParameterList(node.parameters, visitor, context) : void 0;
     resumeLexicalEnvironment();
     const original = getOriginalNode(node, isFunctionLike);
     const nodeType = original.type;
     const promiseConstructor = languageVersion < 2 /* ES2015 */ ? getPromiseConstructor(nodeType) : void 0;
     const isArrowFunction2 = node.kind === 219 /* ArrowFunction */;
+    const savedLexicalArgumentsBinding = lexicalArgumentsBinding;
     const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 512 /* CaptureArguments */) !== 0;
+    const captureLexicalArguments = hasLexicalArguments && !lexicalArgumentsBinding;
+    if (captureLexicalArguments) {
+      lexicalArgumentsBinding = factory2.createUniqueName("arguments");
+    }
+    let argumentsExpression;
+    if (innerParameters) {
+      if (isArrowFunction2) {
+        const parameterBindings = [];
+        Debug.assert(outerParameters.length <= node.parameters.length);
+        for (let i = 0; i < node.parameters.length; i++) {
+          Debug.assert(i < outerParameters.length);
+          const originalParameter = node.parameters[i];
+          const outerParameter = outerParameters[i];
+          Debug.assertNode(outerParameter.name, isIdentifier);
+          if (originalParameter.initializer || originalParameter.dotDotDotToken) {
+            Debug.assert(i === outerParameters.length - 1);
+            parameterBindings.push(factory2.createSpreadElement(outerParameter.name));
+            break;
+          }
+          parameterBindings.push(outerParameter.name);
+        }
+        argumentsExpression = factory2.createArrayLiteralExpression(parameterBindings);
+      } else {
+        argumentsExpression = factory2.createIdentifier("arguments");
+      }
+    }
     const savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames;
     enclosingFunctionParameterNames = /* @__PURE__ */ new Set();
     for (const parameter of node.parameters) {
@@ -99495,27 +99647,23 @@ function transformES2017(context) {
       capturedSuperProperties = /* @__PURE__ */ new Set();
       hasSuperElementAccess = false;
     }
+    const hasLexicalThis = inHasLexicalThisContext();
+    let asyncBody = transformAsyncFunctionBodyWorker(node.body);
+    asyncBody = factory2.updateBlock(asyncBody, factory2.mergeLexicalEnvironment(asyncBody.statements, endLexicalEnvironment()));
     let result;
     if (!isArrowFunction2) {
       const statements = [];
-      const statementOffset = factory2.copyPrologue(
-        node.body.statements,
-        statements,
-        /*ensureUseStrict*/
-        false,
-        visitor
-      );
       statements.push(
         factory2.createReturnStatement(
           emitHelpers().createAwaiterHelper(
-            inHasLexicalThisContext(),
-            hasLexicalArguments,
+            hasLexicalThis,
+            argumentsExpression,
             promiseConstructor,
-            transformAsyncFunctionBodyWorker(node.body, statementOffset)
+            innerParameters,
+            asyncBody
           )
         )
       );
-      insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
       const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
       if (emitSuperHelpers) {
         enableSubstitutionForAsyncMethodsWithSuper();
@@ -99525,6 +99673,9 @@ function transformES2017(context) {
           insertStatementsAfterStandardPrologue(statements, [variableStatement]);
         }
       }
+      if (captureLexicalArguments) {
+        insertStatementsAfterStandardPrologue(statements, [createCaptureArgumentsStatement()]);
+      }
       const block = factory2.createBlock(
         statements,
         /*multiLine*/
@@ -99540,24 +99691,23 @@ function transformES2017(context) {
       }
       result = block;
     } else {
-      const expression = emitHelpers().createAwaiterHelper(
-        inHasLexicalThisContext(),
-        hasLexicalArguments,
+      result = emitHelpers().createAwaiterHelper(
+        hasLexicalThis,
+        argumentsExpression,
         promiseConstructor,
-        transformAsyncFunctionBodyWorker(node.body)
+        innerParameters,
+        asyncBody
       );
-      const declarations = endLexicalEnvironment();
-      if (some(declarations)) {
-        const block = factory2.converters.convertToFunctionBlock(expression);
-        result = factory2.updateBlock(block, setTextRange(factory2.createNodeArray(concatenate(declarations, block.statements)), block.statements));
-      } else {
-        result = expression;
+      if (captureLexicalArguments) {
+        const block = factory2.converters.convertToFunctionBlock(result);
+        result = factory2.updateBlock(block, factory2.mergeLexicalEnvironment(block.statements, [createCaptureArgumentsStatement()]));
       }
     }
     enclosingFunctionParameterNames = savedEnclosingFunctionParameterNames;
     if (!isArrowFunction2) {
       capturedSuperProperties = savedCapturedSuperProperties;
       hasSuperElementAccess = savedHasSuperElementAccess;
+      lexicalArgumentsBinding = savedLexicalArgumentsBinding;
     }
     return result;
   }
@@ -100673,7 +100823,7 @@ function transformES2018(context) {
       ),
       /*typeParameters*/
       void 0,
-      visitParameterList(node.parameters, parameterVisitor, context),
+      enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionParameterList(node) : visitParameterList(node.parameters, parameterVisitor, context),
       /*type*/
       void 0,
       enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionBody(node) : transformFunctionBody2(node)
@@ -100694,7 +100844,7 @@ function transformES2018(context) {
       node.name,
       /*typeParameters*/
       void 0,
-      visitParameterList(node.parameters, parameterVisitor, context),
+      enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionParameterList(node) : visitParameterList(node.parameters, parameterVisitor, context),
       /*type*/
       void 0,
       enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionBody(node) : transformFunctionBody2(node)
@@ -100735,7 +100885,7 @@ function transformES2018(context) {
       node.name,
       /*typeParameters*/
       void 0,
-      visitParameterList(node.parameters, parameterVisitor, context),
+      enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionParameterList(node) : visitParameterList(node.parameters, parameterVisitor, context),
       /*type*/
       void 0,
       enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionBody(node) : transformFunctionBody2(node)
@@ -100744,21 +100894,38 @@ function transformES2018(context) {
     parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
     return updated;
   }
+  function transformAsyncGeneratorFunctionParameterList(node) {
+    if (isSimpleParameterList(node.parameters)) {
+      return visitParameterList(node.parameters, visitor, context);
+    }
+    const newParameters = [];
+    for (const parameter of node.parameters) {
+      if (parameter.initializer || parameter.dotDotDotToken) {
+        break;
+      }
+      const newParameter = factory2.createParameterDeclaration(
+        /*modifiers*/
+        void 0,
+        /*dotDotDotToken*/
+        void 0,
+        factory2.getGeneratedNameForNode(parameter.name, 8 /* ReservedInNestedScopes */)
+      );
+      newParameters.push(newParameter);
+    }
+    const newParametersArray = factory2.createNodeArray(newParameters);
+    setTextRange(newParametersArray, node.parameters);
+    return newParametersArray;
+  }
   function transformAsyncGeneratorFunctionBody(node) {
+    const innerParameters = !isSimpleParameterList(node.parameters) ? visitParameterList(node.parameters, visitor, context) : void 0;
     resumeLexicalEnvironment();
-    const statements = [];
-    const statementOffset = factory2.copyPrologue(
-      node.body.statements,
-      statements,
-      /*ensureUseStrict*/
-      false,
-      visitor
-    );
-    appendObjectRestAssignmentsIfNeeded(statements, node);
     const savedCapturedSuperProperties = capturedSuperProperties;
     const savedHasSuperElementAccess = hasSuperElementAccess;
     capturedSuperProperties = /* @__PURE__ */ new Set();
     hasSuperElementAccess = false;
+    const outerStatements = [];
+    let asyncBody = factory2.updateBlock(node.body, visitNodes2(node.body.statements, visitor, isStatement));
+    asyncBody = factory2.updateBlock(asyncBody, factory2.mergeLexicalEnvironment(asyncBody.statements, appendObjectRestAssignmentsIfNeeded(endLexicalEnvironment(), node)));
     const returnStatement = factory2.createReturnStatement(
       emitHelpers().createAsyncGeneratorHelper(
         factory2.createFunctionExpression(
@@ -100768,14 +100935,10 @@ function transformES2018(context) {
           node.name && factory2.getGeneratedNameForNode(node.name),
           /*typeParameters*/
           void 0,
-          /*parameters*/
-          [],
+          innerParameters ?? [],
           /*type*/
           void 0,
-          factory2.updateBlock(
-            node.body,
-            visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset)
-          )
+          asyncBody
         ),
         !!(hierarchyFacts & 1 /* HasLexicalThis */)
       )
@@ -100785,11 +100948,10 @@ function transformES2018(context) {
       enableSubstitutionForAsyncMethodsWithSuper();
       const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
       substitutedSuperAccessors[getNodeId(variableStatement)] = true;
-      insertStatementsAfterStandardPrologue(statements, [variableStatement]);
+      insertStatementsAfterStandardPrologue(outerStatements, [variableStatement]);
     }
-    statements.push(returnStatement);
-    insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
-    const block = factory2.updateBlock(node.body, statements);
+    outerStatements.push(returnStatement);
+    const block = factory2.updateBlock(node.body, outerStatements);
     if (emitSuperHelpers && hasSuperElementAccess) {
       if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
         addEmitHelper(block, advancedAsyncSuperHelper);
@@ -114634,27 +114796,6 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
     (_e = tracing) == null ? void 0 : _e.push(tracing.Phase.Emit, "emitBuildInfo", { buildInfoPath });
     emitBuildInfo(bundleBuildInfo, buildInfoPath);
     (_f = tracing) == null ? void 0 : _f.pop();
-    if (!emitSkipped && emittedFilesList) {
-      if (!emitOnly) {
-        if (jsFilePath) {
-          emittedFilesList.push(jsFilePath);
-        }
-        if (sourceMapFilePath) {
-          emittedFilesList.push(sourceMapFilePath);
-        }
-        if (buildInfoPath) {
-          emittedFilesList.push(buildInfoPath);
-        }
-      }
-      if (emitOnly !== 0 /* Js */) {
-        if (declarationFilePath) {
-          emittedFilesList.push(declarationFilePath);
-        }
-        if (declarationMapPath) {
-          emittedFilesList.push(declarationMapPath);
-        }
-      }
-    }
     function relativeToBuildInfo(path) {
       return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path, host.getCanonicalFileName));
     }
@@ -114682,6 +114823,7 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
       void 0,
       { buildInfo }
     );
+    emittedFilesList == null ? void 0 : emittedFilesList.push(buildInfoPath);
   }
   function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo) {
     if (!sourceFileOrBundle || emitOnly || !jsFilePath) {
@@ -114727,6 +114869,12 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
     transform2.dispose();
     if (bundleBuildInfo)
       bundleBuildInfo.js = printer.bundleFileInfo;
+    if (emittedFilesList) {
+      emittedFilesList.push(jsFilePath);
+      if (sourceMapFilePath) {
+        emittedFilesList.push(sourceMapFilePath);
+      }
+    }
   }
   function emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo) {
     if (!sourceFileOrBundle || emitOnly === 0 /* Js */)
@@ -114757,33 +114905,33 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
         emitterDiagnostics.add(diagnostic);
       }
     }
-    const printerOptions = {
-      removeComments: compilerOptions.removeComments,
-      newLine: compilerOptions.newLine,
-      noEmitHelpers: true,
-      module: compilerOptions.module,
-      target: compilerOptions.target,
-      sourceMap: !forceDtsEmit && compilerOptions.declarationMap,
-      inlineSourceMap: compilerOptions.inlineSourceMap,
-      extendedDiagnostics: compilerOptions.extendedDiagnostics,
-      onlyPrintJsDocStyle: true,
-      omitBraceSourceMapPositions: true,
-      writeBundleFileInfo: !!bundleBuildInfo,
-      recordInternalSection: !!bundleBuildInfo,
-      relativeToBuildInfo
-    };
-    const declarationPrinter = createPrinter(printerOptions, {
-      // resolver hooks
-      hasGlobalName: resolver.hasGlobalName,
-      // transform hooks
-      onEmitNode: declarationTransform.emitNodeWithNotification,
-      isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled,
-      substituteNode: declarationTransform.substituteNode
-    });
     const declBlocked = !!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;
     emitSkipped = emitSkipped || declBlocked;
     if (!declBlocked || forceDtsEmit) {
       Debug.assert(declarationTransform.transformed.length === 1, "Should only see one output from the decl transform");
+      const printerOptions = {
+        removeComments: compilerOptions.removeComments,
+        newLine: compilerOptions.newLine,
+        noEmitHelpers: true,
+        module: compilerOptions.module,
+        target: compilerOptions.target,
+        sourceMap: !forceDtsEmit && compilerOptions.declarationMap,
+        inlineSourceMap: compilerOptions.inlineSourceMap,
+        extendedDiagnostics: compilerOptions.extendedDiagnostics,
+        onlyPrintJsDocStyle: true,
+        omitBraceSourceMapPositions: true,
+        writeBundleFileInfo: !!bundleBuildInfo,
+        recordInternalSection: !!bundleBuildInfo,
+        relativeToBuildInfo
+      };
+      const declarationPrinter = createPrinter(printerOptions, {
+        // resolver hooks
+        hasGlobalName: resolver.hasGlobalName,
+        // transform hooks
+        onEmitNode: declarationTransform.emitNodeWithNotification,
+        isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled,
+        substituteNode: declarationTransform.substituteNode
+      });
       printSourceFileOrBundle(
         declarationFilePath,
         declarationMapPath,
@@ -114797,10 +114945,16 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
           // Explicitly do not passthru either `inline` option
         }
       );
+      if (emittedFilesList) {
+        emittedFilesList.push(declarationFilePath);
+        if (declarationMapPath) {
+          emittedFilesList.push(declarationMapPath);
+        }
+      }
+      if (bundleBuildInfo)
+        bundleBuildInfo.dts = declarationPrinter.bundleFileInfo;
     }
     declarationTransform.dispose();
-    if (bundleBuildInfo)
-      bundleBuildInfo.dts = declarationPrinter.bundleFileInfo;
   }
   function collectLinkedAliases(node) {
     if (isExportAssignment(node)) {
@@ -124924,6 +125078,7 @@ function createBuilderProgramState(newProgram, oldState) {
   const copyDeclarationFileDiagnostics = canCopySemanticDiagnostics && !compilerOptions.skipLibCheck === !oldCompilerOptions.skipLibCheck;
   const copyLibFileDiagnostics = copyDeclarationFileDiagnostics && !compilerOptions.skipDefaultLibCheck === !oldCompilerOptions.skipDefaultLibCheck;
   state.fileInfos.forEach((info, sourceFilePath) => {
+    var _a2;
     let oldInfo;
     let newReferences;
     if (!useOldState || // File wasn't present in old state
@@ -124933,22 +125088,28 @@ function createBuilderProgramState(newProgram, oldState) {
     !hasSameKeys(newReferences = referencedMap && referencedMap.getValues(sourceFilePath), oldReferencedMap && oldReferencedMap.getValues(sourceFilePath)) || // Referenced file was deleted in the new program
     newReferences && forEachKey(newReferences, (path) => !state.fileInfos.has(path) && oldState.fileInfos.has(path))) {
       addFileToChangeSet(state, sourceFilePath);
-    } else if (canCopySemanticDiagnostics) {
+    } else {
       const sourceFile = newProgram.getSourceFileByPath(sourceFilePath);
-      if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics)
-        return;
-      if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics)
-        return;
-      const diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath);
-      if (diagnostics) {
-        state.semanticDiagnosticsPerFile.set(
+      const emitDiagnostics = (_a2 = oldState.emitDiagnosticsPerFile) == null ? void 0 : _a2.get(sourceFilePath);
+      if (emitDiagnostics) {
+        (state.emitDiagnosticsPerFile ?? (state.emitDiagnosticsPerFile = /* @__PURE__ */ new Map())).set(
           sourceFilePath,
-          oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : repopulateDiagnostics(diagnostics, newProgram)
+          oldState.hasReusableDiagnostic ? convertToDiagnostics(emitDiagnostics, newProgram) : repopulateDiagnostics(emitDiagnostics, newProgram)
         );
-        if (!state.semanticDiagnosticsFromOldState) {
-          state.semanticDiagnosticsFromOldState = /* @__PURE__ */ new Set();
+      }
+      if (canCopySemanticDiagnostics) {
+        if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics)
+          return;
+        if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics)
+          return;
+        const diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath);
+        if (diagnostics) {
+          state.semanticDiagnosticsPerFile.set(
+            sourceFilePath,
+            oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : repopulateDiagnostics(diagnostics, newProgram)
+          );
+          (state.semanticDiagnosticsFromOldState ?? (state.semanticDiagnosticsFromOldState = /* @__PURE__ */ new Set())).add(sourceFilePath);
         }
-        state.semanticDiagnosticsFromOldState.add(sourceFilePath);
       }
     }
     if (canCopyEmitSignatures) {
@@ -125085,7 +125246,9 @@ function backupBuilderProgramEmitState(state) {
     outSignature: state.outSignature,
     latestChangedDtsFile: state.latestChangedDtsFile,
     hasChangedEmitSignature: state.hasChangedEmitSignature,
-    changedFilesSet: outFilePath ? new Set(state.changedFilesSet) : void 0
+    changedFilesSet: outFilePath ? new Set(state.changedFilesSet) : void 0,
+    buildInfoEmitPending: state.buildInfoEmitPending,
+    emitDiagnosticsPerFile: state.emitDiagnosticsPerFile && new Map(state.emitDiagnosticsPerFile)
   };
 }
 function restoreBuilderProgramEmitState(state, savedEmitState) {
@@ -125096,6 +125259,8 @@ function restoreBuilderProgramEmitState(state, savedEmitState) {
   state.outSignature = savedEmitState.outSignature;
   state.latestChangedDtsFile = savedEmitState.latestChangedDtsFile;
   state.hasChangedEmitSignature = savedEmitState.hasChangedEmitSignature;
+  state.buildInfoEmitPending = savedEmitState.buildInfoEmitPending;
+  state.emitDiagnosticsPerFile = savedEmitState.emitDiagnosticsPerFile;
   if (savedEmitState.changedFilesSet)
     state.changedFilesSet = savedEmitState.changedFilesSet;
 }
@@ -125186,6 +125351,22 @@ function getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles) {
       return { affectedFile, emitKind: pendingKind };
   });
 }
+function getNextPendingEmitDiagnosticsFile(state) {
+  var _a;
+  if (!((_a = state.emitDiagnosticsPerFile) == null ? void 0 : _a.size))
+    return void 0;
+  return forEachEntry(state.emitDiagnosticsPerFile, (diagnostics, path) => {
+    var _a2;
+    const affectedFile = state.program.getSourceFileByPath(path);
+    if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
+      state.emitDiagnosticsPerFile.delete(path);
+      return void 0;
+    }
+    const seenKind = ((_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedFile.resolvedPath)) || 0 /* None */;
+    if (!(seenKind & 24 /* AllDts */))
+      return { affectedFile, diagnostics, seenKind };
+  });
+}
 function removeDiagnosticsOfLibraryFiles(state) {
   if (!state.cleanedDiagnosticsOfLibFiles) {
     state.cleanedDiagnosticsOfLibFiles = true;
@@ -125462,18 +125643,7 @@ function getBuildInfo2(state, bundle) {
       return void 0;
     });
   }
-  let semanticDiagnosticsPerFile;
-  if (state.semanticDiagnosticsPerFile) {
-    for (const key of arrayFrom(state.semanticDiagnosticsPerFile.keys()).sort(compareStringsCaseSensitive)) {
-      const value = state.semanticDiagnosticsPerFile.get(key);
-      (semanticDiagnosticsPerFile || (semanticDiagnosticsPerFile = [])).push(
-        value.length ? [
-          toFileId(key),
-          convertToReusableDiagnostics(value, relativeToBuildInfo)
-        ] : toFileId(key)
-      );
-    }
-  }
+  const semanticDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics(state.semanticDiagnosticsPerFile);
   let affectedFilesPendingEmit;
   if ((_c = state.affectedFilesPendingEmit) == null ? void 0 : _c.size) {
     const fullEmitForOptions = getBuilderFileEmit(state.compilerOptions);
@@ -125503,6 +125673,7 @@ function getBuildInfo2(state, bundle) {
       (changeFileSet || (changeFileSet = [])).push(toFileId(path));
     }
   }
+  const emitDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics(state.emitDiagnosticsPerFile);
   const program = {
     fileNames,
     fileInfos,
@@ -125512,6 +125683,7 @@ function getBuildInfo2(state, bundle) {
     referencedMap,
     exportedModulesMap,
     semanticDiagnosticsPerFile,
+    emitDiagnosticsPerFile,
     affectedFilesPendingEmit,
     changeFileSet,
     emitSignatures,
@@ -125568,73 +125740,87 @@ function getBuildInfo2(state, bundle) {
       if (optionInfo == null ? void 0 : optionInfo.affectsBuildInfo) {
         (result || (result = {}))[name] = convertToReusableCompilerOptionValue(
           optionInfo,
-          options[name],
-          relativeToBuildInfoEnsuringAbsolutePath
+          options[name]
         );
       }
     }
     return result;
   }
-}
-function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) {
-  if (option) {
-    Debug.assert(option.type !== "listOrElement");
-    if (option.type === "list") {
-      const values = value;
-      if (option.element.isFilePath && values.length) {
-        return values.map(relativeToBuildInfo);
+  function convertToReusableCompilerOptionValue(option, value) {
+    if (option) {
+      Debug.assert(option.type !== "listOrElement");
+      if (option.type === "list") {
+        const values = value;
+        if (option.element.isFilePath && values.length) {
+          return values.map(relativeToBuildInfoEnsuringAbsolutePath);
+        }
+      } else if (option.isFilePath) {
+        return relativeToBuildInfoEnsuringAbsolutePath(value);
       }
-    } else if (option.isFilePath) {
-      return relativeToBuildInfo(value);
     }
+    return value;
   }
-  return value;
-}
-function convertToReusableDiagnostics(diagnostics, relativeToBuildInfo) {
-  Debug.assert(!!diagnostics.length);
-  return diagnostics.map((diagnostic) => {
-    const result = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo);
-    result.reportsUnnecessary = diagnostic.reportsUnnecessary;
-    result.reportDeprecated = diagnostic.reportsDeprecated;
-    result.source = diagnostic.source;
-    result.skippedOn = diagnostic.skippedOn;
-    const { relatedInformation } = diagnostic;
-    result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToReusableDiagnosticRelatedInformation(r, relativeToBuildInfo)) : [] : void 0;
+  function convertToProgramBuildInfoDiagnostics(diagnostics) {
+    let result;
+    if (diagnostics) {
+      for (const key of arrayFrom(diagnostics.keys()).sort(compareStringsCaseSensitive)) {
+        const value = diagnostics.get(key);
+        (result || (result = [])).push(
+          value.length ? [
+            toFileId(key),
+            convertToReusableDiagnostics(value)
+          ] : toFileId(key)
+        );
+      }
+    }
     return result;
-  });
-}
-function convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo) {
-  const { file } = diagnostic;
-  return {
-    ...diagnostic,
-    file: file ? relativeToBuildInfo(file.resolvedPath) : void 0,
-    messageText: isString(diagnostic.messageText) ? diagnostic.messageText : convertToReusableDiagnosticMessageChain(diagnostic.messageText)
-  };
-}
-function convertToReusableDiagnosticMessageChain(chain) {
-  if (chain.repopulateInfo) {
+  }
+  function convertToReusableDiagnostics(diagnostics) {
+    Debug.assert(!!diagnostics.length);
+    return diagnostics.map((diagnostic) => {
+      const result = convertToReusableDiagnosticRelatedInformation(diagnostic);
+      result.reportsUnnecessary = diagnostic.reportsUnnecessary;
+      result.reportDeprecated = diagnostic.reportsDeprecated;
+      result.source = diagnostic.source;
+      result.skippedOn = diagnostic.skippedOn;
+      const { relatedInformation } = diagnostic;
+      result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToReusableDiagnosticRelatedInformation(r)) : [] : void 0;
+      return result;
+    });
+  }
+  function convertToReusableDiagnosticRelatedInformation(diagnostic) {
+    const { file } = diagnostic;
     return {
-      info: chain.repopulateInfo(),
-      next: convertToReusableDiagnosticMessageChainArray(chain.next)
+      ...diagnostic,
+      file: file ? relativeToBuildInfo(file.resolvedPath) : void 0,
+      messageText: isString(diagnostic.messageText) ? diagnostic.messageText : convertToReusableDiagnosticMessageChain(diagnostic.messageText)
     };
   }
-  const next = convertToReusableDiagnosticMessageChainArray(chain.next);
-  return next === chain.next ? chain : { ...chain, next };
-}
-function convertToReusableDiagnosticMessageChainArray(array) {
-  if (!array)
-    return array;
-  return forEach(array, (chain, index) => {
-    const reusable = convertToReusableDiagnosticMessageChain(chain);
-    if (chain === reusable)
-      return void 0;
-    const result = index > 0 ? array.slice(0, index - 1) : [];
-    result.push(reusable);
-    for (let i = index + 1; i < array.length; i++) {
-      result.push(convertToReusableDiagnosticMessageChain(array[i]));
+  function convertToReusableDiagnosticMessageChain(chain) {
+    if (chain.repopulateInfo) {
+      return {
+        info: chain.repopulateInfo(),
+        next: convertToReusableDiagnosticMessageChainArray(chain.next)
+      };
     }
-    return result;
-  }) || array;
+    const next = convertToReusableDiagnosticMessageChainArray(chain.next);
+    return next === chain.next ? chain : { ...chain, next };
+  }
+  function convertToReusableDiagnosticMessageChainArray(array) {
+    if (!array)
+      return array;
+    return forEach(array, (chain, index) => {
+      const reusable = convertToReusableDiagnosticMessageChain(chain);
+      if (chain === reusable)
+        return void 0;
+      const result = index > 0 ? array.slice(0, index - 1) : [];
+      result.push(reusable);
+      for (let i = index + 1; i < array.length; i++) {
+        result.push(convertToReusableDiagnosticMessageChain(array[i]));
+      }
+      return result;
+    }) || array;
+  }
 }
 var BuilderProgramKind = /* @__PURE__ */ ((BuilderProgramKind2) => {
   BuilderProgramKind2[BuilderProgramKind2["SemanticDiagnosticsBuilderProgram"] = 0] = "SemanticDiagnosticsBuilderProgram";
@@ -125748,6 +125934,14 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
       if (!outFile(state.compilerOptions)) {
         const pendingAffectedFile = getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles);
         if (!pendingAffectedFile) {
+          const pendingForDiagnostics = getNextPendingEmitDiagnosticsFile(state);
+          if (pendingForDiagnostics) {
+            (state.seenEmittedFiles ?? (state.seenEmittedFiles = /* @__PURE__ */ new Map())).set(pendingForDiagnostics.affectedFile.resolvedPath, pendingForDiagnostics.seenKind | 24 /* AllDts */);
+            return {
+              result: { emitSkipped: true, diagnostics: pendingForDiagnostics.diagnostics },
+              affected: pendingForDiagnostics.affectedFile
+            };
+          }
           if (!state.buildInfoEmitPending)
             return void 0;
           const affected2 = state.program;
@@ -125796,6 +125990,8 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
         (state.affectedFilesPendingEmit ?? (state.affectedFilesPendingEmit = /* @__PURE__ */ new Map())).set(affectedSourceFile.resolvedPath, pendingKind);
       else
         (_c = state.affectedFilesPendingEmit) == null ? void 0 : _c.delete(affectedSourceFile.resolvedPath);
+      if (result.diagnostics.length)
+        (state.emitDiagnosticsPerFile ?? (state.emitDiagnosticsPerFile = /* @__PURE__ */ new Map())).set(affectedSourceFile.resolvedPath, result.diagnostics);
     } else {
       state.changedFilesSet.clear();
     }
@@ -125968,9 +126164,10 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
   }
 }
 function addToAffectedFilesPendingEmit(state, affectedFilePendingEmit, kind) {
-  var _a;
+  var _a, _b;
   const existingKind = ((_a = state.affectedFilesPendingEmit) == null ? void 0 : _a.get(affectedFilePendingEmit)) || 0 /* None */;
   (state.affectedFilesPendingEmit ?? (state.affectedFilesPendingEmit = /* @__PURE__ */ new Map())).set(affectedFilePendingEmit, existingKind | kind);
+  (_b = state.emitDiagnosticsPerFile) == null ? void 0 : _b.delete(affectedFilePendingEmit);
 }
 function toBuilderStateFileInfoForMultiEmit(fileInfo) {
   return isString(fileInfo) ? { version: fileInfo, signature: fileInfo, affectsGlobalScope: void 0, impliedFormat: void 0 } : isString(fileInfo.signature) ? fileInfo : { version: fileInfo.version, signature: fileInfo.signature === false ? void 0 : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
@@ -126035,7 +126232,8 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
       compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
       referencedMap: toManyToManyPathMap(program.referencedMap),
       exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
-      semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && arrayToMap(program.semanticDiagnosticsPerFile, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => isNumber(value) ? emptyArray : value[1]),
+      semanticDiagnosticsPerFile: toPerFileDiagnostics(program.semanticDiagnosticsPerFile),
+      emitDiagnosticsPerFile: toPerFileDiagnostics(program.emitDiagnosticsPerFile),
       hasReusableDiagnostic: true,
       affectedFilesPendingEmit: program.affectedFilesPendingEmit && arrayToMap(program.affectedFilesPendingEmit, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => toBuilderFileEmit(value, fullEmitForOptions)),
       changedFilesSet: new Set(map(program.changeFileSet, toFilePath)),
@@ -126088,6 +126286,9 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
     referenceMap.forEach(([fileId, fileIdListId]) => map2.set(toFilePath(fileId), toFilePathsSet(fileIdListId)));
     return map2;
   }
+  function toPerFileDiagnostics(diagnostics) {
+    return diagnostics && arrayToMap(diagnostics, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => isNumber(value) ? emptyArray : value[1]);
+  }
 }
 function getBuildInfoFileVersionMap(program, buildInfoPath, host) {
   const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
@@ -129734,7 +129935,7 @@ function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime,
   }
 }
 function getUpToDateStatusWorker(state, project, resolvedPath) {
-  var _a, _b;
+  var _a, _b, _c;
   if (!project.fileNames.length && !canJsonReportNoInputFiles(project.raw)) {
     return {
       type: 16 /* ContainerOnly */
@@ -129808,7 +130009,7 @@ function getUpToDateStatusWorker(state, project, resolvedPath) {
       };
     }
     if (buildInfo.program) {
-      if (((_a = buildInfo.program.changeFileSet) == null ? void 0 : _a.length) || (!project.options.noEmit ? (_b = buildInfo.program.affectedFilesPendingEmit) == null ? void 0 : _b.length : some(buildInfo.program.semanticDiagnosticsPerFile, isArray))) {
+      if (((_a = buildInfo.program.changeFileSet) == null ? void 0 : _a.length) || (!project.options.noEmit ? ((_b = buildInfo.program.affectedFilesPendingEmit) == null ? void 0 : _b.length) || ((_c = buildInfo.program.emitDiagnosticsPerFile) == null ? void 0 : _c.length) : some(buildInfo.program.semanticDiagnosticsPerFile, isArray))) {
         return {
           type: 8 /* OutOfDateBuildInfo */,
           buildInfoFile: buildInfoPath
@@ -146021,7 +146222,7 @@ function getPropertySymbolsFromContextualType(node, checker, contextualType, uni
   if (discriminatedPropertySymbols.length === 0) {
     return mapDefined(contextualType.types, (t) => t.getProperty(name));
   }
-  return discriminatedPropertySymbols;
+  return deduplicate(discriminatedPropertySymbols, equateValues);
 }
 function isArgumentOfElementAccessExpression(node) {
   return node && node.parent && node.parent.kind === 212 /* ElementAccessExpression */ && node.parent.argumentExpression === node;
@@ -165120,6 +165321,7 @@ function provideInlayHints(context) {
     visitForDisplayParts(typeNode);
     return parts;
     function visitForDisplayParts(node) {
+      var _a, _b;
       if (!node) {
         return;
       }
@@ -165134,9 +165336,9 @@ function provideInlayHints(context) {
       }
       switch (node.kind) {
         case 80 /* Identifier */:
-          const identifier = node;
-          const identifierText = idText(identifier);
-          const name = identifier.symbol && identifier.symbol.declarations && identifier.symbol.declarations.length && getNameOfDeclaration(identifier.symbol.declarations[0]);
+          Debug.assertNode(node, isIdentifier);
+          const identifierText = idText(node);
+          const name = node.symbol && node.symbol.declarations && node.symbol.declarations.length && getNameOfDeclaration(node.symbol.declarations[0]);
           if (name) {
             parts.push(getNodeDisplayPart(identifierText, name));
           } else {
@@ -165144,252 +165346,307 @@ function provideInlayHints(context) {
           }
           break;
         case 166 /* QualifiedName */:
-          const qualifiedName = node;
-          visitForDisplayParts(qualifiedName.left);
+          Debug.assertNode(node, isQualifiedName);
+          visitForDisplayParts(node.left);
           parts.push({ text: "." });
-          visitForDisplayParts(qualifiedName.right);
+          visitForDisplayParts(node.right);
           break;
         case 182 /* TypePredicate */:
-          const predicate = node;
-          if (predicate.assertsModifier) {
+          Debug.assertNode(node, isTypePredicateNode);
+          if (node.assertsModifier) {
             parts.push({ text: "asserts " });
           }
-          visitForDisplayParts(predicate.parameterName);
-          if (predicate.type) {
+          visitForDisplayParts(node.parameterName);
+          if (node.type) {
             parts.push({ text: " is " });
-            visitForDisplayParts(predicate.type);
+            visitForDisplayParts(node.type);
           }
           break;
         case 183 /* TypeReference */:
-          const typeReference = node;
-          visitForDisplayParts(typeReference.typeName);
-          if (typeReference.typeArguments) {
+          Debug.assertNode(node, isTypeReferenceNode);
+          visitForDisplayParts(node.typeName);
+          if (node.typeArguments) {
             parts.push({ text: "<" });
-            visitDisplayPartList(typeReference.typeArguments, ", ");
+            visitDisplayPartList(node.typeArguments, ", ");
             parts.push({ text: ">" });
           }
           break;
         case 168 /* TypeParameter */:
-          const typeParameter = node;
-          if (typeParameter.modifiers) {
-            visitDisplayPartList(typeParameter.modifiers, " ");
+          Debug.assertNode(node, isTypeParameterDeclaration);
+          if (node.modifiers) {
+            visitDisplayPartList(node.modifiers, " ");
           }
-          visitForDisplayParts(typeParameter.name);
-          if (typeParameter.constraint) {
+          visitForDisplayParts(node.name);
+          if (node.constraint) {
             parts.push({ text: " extends " });
-            visitForDisplayParts(typeParameter.constraint);
+            visitForDisplayParts(node.constraint);
           }
-          if (typeParameter.default) {
+          if (node.default) {
             parts.push({ text: " = " });
-            visitForDisplayParts(typeParameter.default);
+            visitForDisplayParts(node.default);
           }
           break;
         case 169 /* Parameter */:
-          const parameter = node;
-          if (parameter.modifiers) {
-            visitDisplayPartList(parameter.modifiers, " ");
+          Debug.assertNode(node, isParameter);
+          if (node.modifiers) {
+            visitDisplayPartList(node.modifiers, " ");
           }
-          if (parameter.dotDotDotToken) {
+          if (node.dotDotDotToken) {
             parts.push({ text: "..." });
           }
-          visitForDisplayParts(parameter.name);
-          if (parameter.questionToken) {
+          visitForDisplayParts(node.name);
+          if (node.questionToken) {
             parts.push({ text: "?" });
           }
-          if (parameter.type) {
+          if (node.type) {
             parts.push({ text: ": " });
-            visitForDisplayParts(parameter.type);
+            visitForDisplayParts(node.type);
           }
           break;
         case 185 /* ConstructorType */:
-          const constructorType = node;
+          Debug.assertNode(node, isConstructorTypeNode);
           parts.push({ text: "new " });
-          if (constructorType.typeParameters) {
-            parts.push({ text: "<" });
-            visitDisplayPartList(constructorType.typeParameters, ", ");
-            parts.push({ text: ">" });
-          }
-          parts.push({ text: "(" });
-          visitDisplayPartList(constructorType.parameters, ", ");
-          parts.push({ text: ")" });
+          visitParametersAndTypeParameters(node);
           parts.push({ text: " => " });
-          visitForDisplayParts(constructorType.type);
+          visitForDisplayParts(node.type);
           break;
         case 186 /* TypeQuery */:
-          const typeQuery = node;
+          Debug.assertNode(node, isTypeQueryNode);
           parts.push({ text: "typeof " });
-          visitForDisplayParts(typeQuery.exprName);
-          if (typeQuery.typeArguments) {
+          visitForDisplayParts(node.exprName);
+          if (node.typeArguments) {
             parts.push({ text: "<" });
-            visitDisplayPartList(typeQuery.typeArguments, ", ");
+            visitDisplayPartList(node.typeArguments, ", ");
             parts.push({ text: ">" });
           }
           break;
         case 187 /* TypeLiteral */:
-          const typeLiteral = node;
+          Debug.assertNode(node, isTypeLiteralNode);
           parts.push({ text: "{" });
-          if (typeLiteral.members.length) {
+          if (node.members.length) {
             parts.push({ text: " " });
-            visitDisplayPartList(typeLiteral.members, "; ");
+            visitDisplayPartList(node.members, "; ");
             parts.push({ text: " " });
           }
           parts.push({ text: "}" });
           break;
         case 188 /* ArrayType */:
+          Debug.assertNode(node, isArrayTypeNode);
           visitForDisplayParts(node.elementType);
           parts.push({ text: "[]" });
           break;
         case 189 /* TupleType */:
+          Debug.assertNode(node, isTupleTypeNode);
           parts.push({ text: "[" });
           visitDisplayPartList(node.elements, ", ");
           parts.push({ text: "]" });
           break;
         case 202 /* NamedTupleMember */:
-          const member = node;
-          if (member.dotDotDotToken) {
+          Debug.assertNode(node, isNamedTupleMember);
+          if (node.dotDotDotToken) {
             parts.push({ text: "..." });
           }
-          visitForDisplayParts(member.name);
-          if (member.questionToken) {
+          visitForDisplayParts(node.name);
+          if (node.questionToken) {
             parts.push({ text: "?" });
           }
           parts.push({ text: ": " });
-          visitForDisplayParts(member.type);
+          visitForDisplayParts(node.type);
           break;
         case 190 /* OptionalType */:
+          Debug.assertNode(node, isOptionalTypeNode);
           visitForDisplayParts(node.type);
           parts.push({ text: "?" });
           break;
         case 191 /* RestType */:
+          Debug.assertNode(node, isRestTypeNode);
           parts.push({ text: "..." });
           visitForDisplayParts(node.type);
           break;
         case 192 /* UnionType */:
+          Debug.assertNode(node, isUnionTypeNode);
           visitDisplayPartList(node.types, " | ");
           break;
         case 193 /* IntersectionType */:
+          Debug.assertNode(node, isIntersectionTypeNode);
           visitDisplayPartList(node.types, " & ");
           break;
         case 194 /* ConditionalType */:
-          const conditionalType = node;
-          visitForDisplayParts(conditionalType.checkType);
+          Debug.assertNode(node, isConditionalTypeNode);
+          visitForDisplayParts(node.checkType);
           parts.push({ text: " extends " });
-          visitForDisplayParts(conditionalType.extendsType);
+          visitForDisplayParts(node.extendsType);
           parts.push({ text: " ? " });
-          visitForDisplayParts(conditionalType.trueType);
+          visitForDisplayParts(node.trueType);
           parts.push({ text: " : " });
-          visitForDisplayParts(conditionalType.falseType);
+          visitForDisplayParts(node.falseType);
           break;
         case 195 /* InferType */:
+          Debug.assertNode(node, isInferTypeNode);
           parts.push({ text: "infer " });
           visitForDisplayParts(node.typeParameter);
           break;
         case 196 /* ParenthesizedType */:
+          Debug.assertNode(node, isParenthesizedTypeNode);
           parts.push({ text: "(" });
           visitForDisplayParts(node.type);
           parts.push({ text: ")" });
           break;
         case 198 /* TypeOperator */:
-          const typeOperator = node;
-          parts.push({ text: `${tokenToString(typeOperator.operator)} ` });
-          visitForDisplayParts(typeOperator.type);
+          Debug.assertNode(node, isTypeOperatorNode);
+          parts.push({ text: `${tokenToString(node.operator)} ` });
+          visitForDisplayParts(node.type);
           break;
         case 199 /* IndexedAccessType */:
-          const indexedAccess = node;
-          visitForDisplayParts(indexedAccess.objectType);
+          Debug.assertNode(node, isIndexedAccessTypeNode);
+          visitForDisplayParts(node.objectType);
           parts.push({ text: "[" });
-          visitForDisplayParts(indexedAccess.indexType);
+          visitForDisplayParts(node.indexType);
           parts.push({ text: "]" });
           break;
         case 200 /* MappedType */:
-          const mappedType = node;
+          Debug.assertNode(node, isMappedTypeNode);
           parts.push({ text: "{ " });
-          if (mappedType.readonlyToken) {
-            if (mappedType.readonlyToken.kind === 40 /* PlusToken */) {
+          if (node.readonlyToken) {
+            if (node.readonlyToken.kind === 40 /* PlusToken */) {
               parts.push({ text: "+" });
-            } else if (mappedType.readonlyToken.kind === 41 /* MinusToken */) {
+            } else if (node.readonlyToken.kind === 41 /* MinusToken */) {
               parts.push({ text: "-" });
             }
             parts.push({ text: "readonly " });
           }
           parts.push({ text: "[" });
-          visitForDisplayParts(mappedType.typeParameter);
-          if (mappedType.nameType) {
+          visitForDisplayParts(node.typeParameter);
+          if (node.nameType) {
             parts.push({ text: " as " });
-            visitForDisplayParts(mappedType.nameType);
+            visitForDisplayParts(node.nameType);
           }
           parts.push({ text: "]" });
-          if (mappedType.questionToken) {
-            if (mappedType.questionToken.kind === 40 /* PlusToken */) {
+          if (node.questionToken) {
+            if (node.questionToken.kind === 40 /* PlusToken */) {
               parts.push({ text: "+" });
-            } else if (mappedType.questionToken.kind === 41 /* MinusToken */) {
+            } else if (node.questionToken.kind === 41 /* MinusToken */) {
               parts.push({ text: "-" });
             }
             parts.push({ text: "?" });
           }
           parts.push({ text: ": " });
-          if (mappedType.type) {
-            visitForDisplayParts(mappedType.type);
+          if (node.type) {
+            visitForDisplayParts(node.type);
           }
           parts.push({ text: "; }" });
           break;
         case 201 /* LiteralType */:
+          Debug.assertNode(node, isLiteralTypeNode);
           visitForDisplayParts(node.literal);
           break;
         case 184 /* FunctionType */:
-          const functionType = node;
-          if (functionType.typeParameters) {
-            parts.push({ text: "<" });
-            visitDisplayPartList(functionType.typeParameters, ", ");
-            parts.push({ text: ">" });
-          }
-          parts.push({ text: "(" });
-          visitDisplayPartList(functionType.parameters, ", ");
-          parts.push({ text: ")" });
+          Debug.assertNode(node, isFunctionTypeNode);
+          visitParametersAndTypeParameters(node);
           parts.push({ text: " => " });
-          visitForDisplayParts(functionType.type);
+          visitForDisplayParts(node.type);
           break;
         case 205 /* ImportType */:
-          const importType = node;
-          if (importType.isTypeOf) {
+          Debug.assertNode(node, isImportTypeNode);
+          if (node.isTypeOf) {
             parts.push({ text: "typeof " });
           }
           parts.push({ text: "import(" });
-          visitForDisplayParts(importType.argument);
-          if (importType.assertions) {
+          visitForDisplayParts(node.argument);
+          if (node.assertions) {
             parts.push({ text: ", { assert: " });
-            visitDisplayPartList(importType.assertions.assertClause.elements, ", ");
+            visitDisplayPartList(node.assertions.assertClause.elements, ", ");
             parts.push({ text: " }" });
           }
           parts.push({ text: ")" });
-          if (importType.qualifier) {
+          if (node.qualifier) {
             parts.push({ text: "." });
-            visitForDisplayParts(importType.qualifier);
+            visitForDisplayParts(node.qualifier);
           }
-          if (importType.typeArguments) {
+          if (node.typeArguments) {
             parts.push({ text: "<" });
-            visitDisplayPartList(importType.typeArguments, ", ");
+            visitDisplayPartList(node.typeArguments, ", ");
             parts.push({ text: ">" });
           }
           break;
         case 171 /* PropertySignature */:
-          const propertySignature = node;
-          if (propertySignature.modifiers) {
-            visitDisplayPartList(propertySignature.modifiers, " ");
+          Debug.assertNode(node, isPropertySignature);
+          if ((_a = node.modifiers) == null ? void 0 : _a.length) {
+            visitDisplayPartList(node.modifiers, " ");
+            parts.push({ text: " " });
+          }
+          visitForDisplayParts(node.name);
+          if (node.questionToken) {
+            parts.push({ text: "?" });
+          }
+          if (node.type) {
+            parts.push({ text: ": " });
+            visitForDisplayParts(node.type);
           }
-          visitForDisplayParts(propertySignature.name);
-          if (propertySignature.questionToken) {
+          break;
+        case 173 /* MethodSignature */:
+          Debug.assertNode(node, isMethodSignature);
+          if ((_b = node.modifiers) == null ? void 0 : _b.length) {
+            visitDisplayPartList(node.modifiers, " ");
+            parts.push({ text: " " });
+          }
+          visitForDisplayParts(node.name);
+          if (node.questionToken) {
             parts.push({ text: "?" });
           }
-          if (propertySignature.type) {
+          visitParametersAndTypeParameters(node);
+          if (node.type) {
             parts.push({ text: ": " });
-            visitForDisplayParts(propertySignature.type);
+            visitForDisplayParts(node.type);
           }
           break;
+        case 179 /* CallSignature */:
+          Debug.assertNode(node, isCallSignatureDeclaration);
+          visitParametersAndTypeParameters(node);
+          if (node.type) {
+            parts.push({ text: ": " });
+            visitForDisplayParts(node.type);
+          }
+          break;
+        case 207 /* ArrayBindingPattern */:
+          Debug.assertNode(node, isArrayBindingPattern);
+          parts.push({ text: "[" });
+          visitDisplayPartList(node.elements, ", ");
+          parts.push({ text: "]" });
+          break;
+        case 206 /* ObjectBindingPattern */:
+          Debug.assertNode(node, isObjectBindingPattern);
+          parts.push({ text: "{" });
+          if (node.elements.length) {
+            parts.push({ text: " " });
+            visitDisplayPartList(node.elements, ", ");
+            parts.push({ text: " " });
+          }
+          parts.push({ text: "}" });
+          break;
+        case 208 /* BindingElement */:
+          Debug.assertNode(node, isBindingElement);
+          visitForDisplayParts(node.name);
+          break;
+        case 224 /* PrefixUnaryExpression */:
+          Debug.assertNode(node, isPrefixUnaryExpression);
+          parts.push({ text: tokenToString(node.operator) });
+          visitForDisplayParts(node.operand);
+          break;
         default:
           Debug.failBadSyntaxKind(node);
       }
     }
+    function visitParametersAndTypeParameters(signatureDeclaration) {
+      if (signatureDeclaration.typeParameters) {
+        parts.push({ text: "<" });
+        visitDisplayPartList(signatureDeclaration.typeParameters, ", ");
+        parts.push({ text: ">" });
+      }
+      parts.push({ text: "(" });
+      visitDisplayPartList(signatureDeclaration.parameters, ", ");
+      parts.push({ text: ")" });
+    }
     function visitDisplayPartList(nodes, separator) {
       nodes.forEach((node, index) => {
         if (index > 0) {
@@ -170153,7 +170410,7 @@ function getAllRules() {
   const typeNames = [80 /* Identifier */, ...typeKeywords];
   const functionOpenBraceLeftTokenRange = anyTokenIncludingMultilineComments;
   const typeScriptOpenBraceLeftTokenRange = tokenRangeFrom([80 /* Identifier */, 3 /* MultiLineCommentTrivia */, 86 /* ClassKeyword */, 95 /* ExportKeyword */, 102 /* ImportKeyword */]);
-  const controlOpenBraceLeftTokenRange = tokenRangeFrom([22 /* CloseParenToken */, 3 /* MultiLineCommentTrivia */, 92 /* DoKeyword */, 113 /* TryKeyword */, 98 /* FinallyKeyword */, 93 /* ElseKeyword */]);
+  const controlOpenBraceLeftTokenRange = tokenRangeFrom([22 /* CloseParenToken */, 3 /* MultiLineCommentTrivia */, 92 /* DoKeyword */, 113 /* TryKeyword */, 98 /* FinallyKeyword */, 93 /* ElseKeyword */, 85 /* CatchKeyword */]);
   const highPriorityCommonRules = [
     // Leave comments alone
     rule("IgnoreBeforeComment", anyToken, comments, anyContext, 1 /* StopProcessingSpaceActions */),
@@ -174141,6 +174398,8 @@ __export(ts_exports2, {
   isSignedNumericLiteral: () => isSignedNumericLiteral,
   isSimpleCopiableExpression: () => isSimpleCopiableExpression,
   isSimpleInlineableExpression: () => isSimpleInlineableExpression,
+  isSimpleParameter: () => isSimpleParameter,
+  isSimpleParameterList: () => isSimpleParameterList,
   isSingleOrDoubleQuote: () => isSingleOrDoubleQuote,
   isSourceFile: () => isSourceFile,
   isSourceFileFromLibrary: () => isSourceFileFromLibrary,
@@ -174855,9 +175114,9 @@ function buildOverload(name) {
 
 // src/deprecatedCompat/5.0/identifierProperties.ts
 addObjectAllocatorPatcher((objectAllocator2) => {
-  const Identifier78 = objectAllocator2.getIdentifierConstructor();
-  if (!hasProperty(Identifier78.prototype, "originalKeywordKind")) {
-    Object.defineProperty(Identifier78.prototype, "originalKeywordKind", {
+  const Identifier79 = objectAllocator2.getIdentifierConstructor();
+  if (!hasProperty(Identifier79.prototype, "originalKeywordKind")) {
+    Object.defineProperty(Identifier79.prototype, "originalKeywordKind", {
       get: deprecate(function() {
         return identifierToKeywordKind(this);
       }, {
@@ -174869,8 +175128,8 @@ addObjectAllocatorPatcher((objectAllocator2) => {
       })
     });
   }
-  if (!hasProperty(Identifier78.prototype, "isInJSDocNamespace")) {
-    Object.defineProperty(Identifier78.prototype, "isInJSDocNamespace", {
+  if (!hasProperty(Identifier79.prototype, "isInJSDocNamespace")) {
+    Object.defineProperty(Identifier79.prototype, "isInJSDocNamespace", {
       get: deprecate(function() {
         return this.flags & 4096 /* IdentifierIsInJSDocNamespace */ ? true : void 0;
       }, {
@@ -188801,6 +189060,8 @@ start(initializeNodeSystem(), require("os").platform());
   isSignedNumericLiteral,
   isSimpleCopiableExpression,
   isSimpleInlineableExpression,
+  isSimpleParameter,
+  isSimpleParameterList,
   isSingleOrDoubleQuote,
   isSourceFile,
   isSourceFileFromLibrary,