typescript 5.3.1-rc → 5.4.0-dev.20231104

package/lib/typescript.js

@@ -34,8 +34,8 @@ var ts = (() => {
   var init_corePublic = __esm({
     "src/compiler/corePublic.ts"() {
       "use strict";
-      versionMajorMinor = "5.3";
-      version = "5.3.1-rc";
+      versionMajorMinor = "5.4";
+      version = `${versionMajorMinor}.0-dev.20231104`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -3034,7 +3034,7 @@ ${lanes.join("\n")}
   function tryGetNodePerformanceHooks() {
     if (isNodeLikeSystem()) {
       try {
-        const { performance: performance2, PerformanceObserver: PerformanceObserver2 } =   require("perf_hooks");
+        const { performance: performance2, PerformanceObserver: PerformanceObserver2 } = require("perf_hooks");
         if (hasRequiredAPI(performance2, PerformanceObserver2)) {
           return {
             // By default, only write native events when generating a cpu profile or using the v8 profiler.
@@ -3068,7 +3068,7 @@ ${lanes.join("\n")}
       "use strict";
       try {
         const etwModulePath = process.env.TS_ETW_MODULE_PATH ?? "./node_modules/@microsoft/typescript-etw";
-        etwModule =   require(etwModulePath);
+        etwModule = require(etwModulePath);
       } catch (e) {
         etwModule = void 0;
       }
@@ -3233,7 +3233,7 @@ ${lanes.join("\n")}
           Debug.assert(!tracing, "Tracing already started");
           if (fs === void 0) {
             try {
-              fs =   require("fs");
+              fs = require("fs");
             } catch (e) {
               throw new Error(`tracing requires having fs
 (original error: ${e.message || e})`);
@@ -6125,18 +6125,18 @@ ${lanes.join("\n")}
         const byteOrderMarkIndicator = "\uFEFF";
         function getNodeSystem() {
           const nativePattern = /^native |^\([^)]+\)$|^(internal[\\/]|[a-zA-Z0-9_\s]+(\.js)?$)/;
-          const _fs =   require("fs");
-          const _path =   require("path");
-          const _os =   require("os");
+          const _fs = require("fs");
+          const _path = require("path");
+          const _os = require("os");
           let _crypto;
           try {
-            _crypto =   require("crypto");
+            _crypto = require("crypto");
           } catch {
             _crypto = void 0;
           }
           let activeSession;
           let profilePath = "./profile.cpuprofile";
-          const Buffer2 =   require("buffer").Buffer;
+          const Buffer2 = require("buffer").Buffer;
           const isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
           const platform = _os.platform();
           const useCaseSensitiveFileNames2 = isFileSystemCaseSensitive();
@@ -6235,7 +6235,7 @@ ${lanes.join("\n")}
             debugMode: !!process.env.NODE_INSPECTOR_IPC || !!process.env.VSCODE_INSPECTOR_OPTIONS || some(process.execArgv, (arg) => /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg)) || !!process.recordreplay,
             tryEnableSourceMapsForHost() {
               try {
-                  require("source-map-support").install();
+                require("source-map-support").install();
               } catch {
               }
             },
@@ -6257,7 +6257,7 @@ ${lanes.join("\n")}
             require: (baseDir, moduleName) => {
               try {
                 const modulePath = resolveJSModule(moduleName, baseDir, nodeSystem);
-                return { module:   require(modulePath), modulePath, error: void 0 };
+                return { module: require(modulePath), modulePath, error: void 0 };
               } catch (error2) {
                 return { module: void 0, modulePath: void 0, error: error2 };
               }
@@ -6272,7 +6272,7 @@ ${lanes.join("\n")}
               cb();
               return false;
             }
-            const inspector =   require("inspector");
+            const inspector = require("inspector");
             if (!inspector || !inspector.Session) {
               cb();
               return false;
@@ -25497,7 +25497,7 @@ ${lanes.join("\n")}
         ]
       );
     }
-    function createAwaiterHelper(hasLexicalThis, hasLexicalArguments, promiseConstructor, body) {
+    function createAwaiterHelper(hasLexicalThis, argumentsExpression, promiseConstructor, parameters, body) {
       context.requestEmitHelper(awaiterHelper);
       const generatorFunc = factory2.createFunctionExpression(
         /*modifiers*/
@@ -25507,8 +25507,7 @@ ${lanes.join("\n")}
         void 0,
         /*typeParameters*/
         void 0,
-        /*parameters*/
-        [],
+        parameters ?? [],
         /*type*/
         void 0,
         body
@@ -25520,7 +25519,7 @@ ${lanes.join("\n")}
         void 0,
         [
           hasLexicalThis ? factory2.createThis() : factory2.createVoidZero(),
-          hasLexicalArguments ? factory2.createIdentifier("arguments") : factory2.createVoidZero(),
+          argumentsExpression ?? factory2.createVoidZero(),
           promiseConstructor ? createExpressionFromEntityName(factory2, promiseConstructor) : factory2.createVoidZero(),
           generatorFunc
         ]
@@ -37729,6 +37728,7 @@ ${lanes.join("\n")}
         ["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"],
@@ -38060,6 +38060,7 @@ ${lanes.join("\n")}
         affectsModuleResolution: true,
         affectsEmit: true,
         affectsBuildInfo: true,
+        deprecatedKeys: /* @__PURE__ */ new Set(["es3"]),
         paramType: Diagnostics.VERSION,
         showInSimplifiedHelpView: true,
         category: Diagnostics.Language_and_Environment,
@@ -42540,6 +42541,9 @@ ${lanes.join("\n")}
         case 213 /* CallExpression */:
           return hasNarrowableArgument(expr);
         case 217 /* ParenthesizedExpression */:
+          if (isJSDocTypeAssertion(expr)) {
+            return false;
+          }
         case 235 /* NonNullExpression */:
           return isNarrowingExpression(expr.expression);
         case 226 /* BinaryExpression */:
@@ -69337,15 +69341,23 @@ ${lanes.join("\n")}
           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)) {
@@ -89442,6 +89454,12 @@ ${lanes.join("\n")}
   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);
+  }
   var IdentifierNameMap, IdentifierNameMultiMap;
   var init_utilities3 = __esm({
     "src/compiler/transformers/utilities.ts"() {
@@ -97071,6 +97089,7 @@ ${lanes.join("\n")}
     let enclosingFunctionParameterNames;
     let capturedSuperProperties;
     let hasSuperElementAccess;
+    let lexicalArgumentsBinding;
     const substitutedSuperAccessors = [];
     let contextFlags = 0 /* None */;
     const previousOnEmitNode = context.onEmitNode;
@@ -97121,9 +97140,30 @@ ${lanes.join("\n")}
     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 */:
@@ -97281,15 +97321,23 @@ ${lanes.join("\n")}
       );
     }
     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,
@@ -97298,14 +97346,18 @@ ${lanes.join("\n")}
         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,
@@ -97314,55 +97366,75 @@ ${lanes.join("\n")}
         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) {
@@ -97456,13 +97528,91 @@ ${lanes.join("\n")}
       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) {
@@ -97474,27 +97624,23 @@ ${lanes.join("\n")}
         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();
@@ -97504,6 +97650,9 @@ ${lanes.join("\n")}
             insertStatementsAfterStandardPrologue(statements, [variableStatement]);
           }
         }
+        if (captureLexicalArguments) {
+          insertStatementsAfterStandardPrologue(statements, [createCaptureArgumentsStatement()]);
+        }
         const block = factory2.createBlock(
           statements,
           /*multiLine*/
@@ -97519,24 +97668,23 @@ ${lanes.join("\n")}
         }
         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;
     }
@@ -98658,7 +98806,7 @@ ${lanes.join("\n")}
         ),
         /*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)
@@ -98679,7 +98827,7 @@ ${lanes.join("\n")}
         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)
@@ -98720,7 +98868,7 @@ ${lanes.join("\n")}
         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)
@@ -98729,21 +98877,38 @@ ${lanes.join("\n")}
       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(
@@ -98753,14 +98918,10 @@ ${lanes.join("\n")}
             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 */)
         )
@@ -98770,11 +98931,10 @@ ${lanes.join("\n")}
         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);
@@ -112726,27 +112886,6 @@ ${lanes.join("\n")}
       (_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));
       }
@@ -112774,6 +112913,7 @@ ${lanes.join("\n")}
         void 0,
         { buildInfo }
       );
+      emittedFilesList == null ? void 0 : emittedFilesList.push(buildInfoPath);
     }
     function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo) {
       if (!sourceFileOrBundle || emitOnly || !jsFilePath) {
@@ -112819,6 +112959,12 @@ ${lanes.join("\n")}
       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 */)
@@ -112849,33 +112995,33 @@ ${lanes.join("\n")}
           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,
@@ -112889,10 +113035,16 @@ ${lanes.join("\n")}
             // 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)) {
@@ -123042,6 +123194,7 @@ ${lanes.join("\n")}
     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
@@ -123051,22 +123204,28 @@ ${lanes.join("\n")}
       !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) {
@@ -123203,7 +123362,9 @@ ${lanes.join("\n")}
       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) {
@@ -123214,6 +123375,8 @@ ${lanes.join("\n")}
     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;
   }
@@ -123304,6 +123467,22 @@ ${lanes.join("\n")}
         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;
@@ -123580,18 +123759,7 @@ ${lanes.join("\n")}
         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);
@@ -123621,6 +123789,7 @@ ${lanes.join("\n")}
         (changeFileSet || (changeFileSet = [])).push(toFileId(path));
       }
     }
+    const emitDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics(state.emitDiagnosticsPerFile);
     const program = {
       fileNames,
       fileInfos,
@@ -123630,6 +123799,7 @@ ${lanes.join("\n")}
       referencedMap,
       exportedModulesMap,
       semanticDiagnosticsPerFile,
+      emitDiagnosticsPerFile,
       affectedFilesPendingEmit,
       changeFileSet,
       emitSignatures,
@@ -123686,73 +123856,87 @@ ${lanes.join("\n")}
         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;
+    }
   }
   function getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) {
     let host;
@@ -123861,6 +124045,14 @@ ${lanes.join("\n")}
         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;
@@ -123909,6 +124101,8 @@ ${lanes.join("\n")}
           (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();
       }
@@ -124081,9 +124275,10 @@ ${lanes.join("\n")}
     }
   }
   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 };
@@ -124148,7 +124343,8 @@ ${lanes.join("\n")}
         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)),
@@ -124201,6 +124397,9 @@ ${lanes.join("\n")}
       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()));
@@ -127895,7 +128094,7 @@ ${lanes.join("\n")}
     }
   }
   function getUpToDateStatusWorker(state, project, resolvedPath) {
-    var _a, _b;
+    var _a, _b, _c;
     if (!project.fileNames.length && !canJsonReportNoInputFiles(project.raw)) {
       return {
         type: 16 /* ContainerOnly */
@@ -127969,7 +128168,7 @@ ${lanes.join("\n")}
         };
       }
       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
@@ -143964,7 +144163,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     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;
@@ -164466,6 +164665,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       visitForDisplayParts(typeNode);
       return parts;
       function visitForDisplayParts(node) {
+        var _a, _b;
         if (!node) {
           return;
         }
@@ -164480,9 +164680,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
         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 {
@@ -164490,252 +164690,307 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             }
             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) {
@@ -169618,7 +169873,7 @@ ${options.prefix}` : "\n" : options.prefix
     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 */),
@@ -172151,9 +172406,9 @@ ${options.prefix}` : "\n" : options.prefix
       init_ts5();
       init_deprecate();
       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);
             }, {
@@ -172165,8 +172420,8 @@ ${options.prefix}` : "\n" : options.prefix
             })
           });
         }
-        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;
             }, {
@@ -185415,6 +185670,8 @@ ${e.message}`;
     isSignedNumericLiteral: () => isSignedNumericLiteral,
     isSimpleCopiableExpression: () => isSimpleCopiableExpression,
     isSimpleInlineableExpression: () => isSimpleInlineableExpression,
+    isSimpleParameter: () => isSimpleParameter,
+    isSimpleParameterList: () => isSimpleParameterList,
     isSingleOrDoubleQuote: () => isSingleOrDoubleQuote,
     isSourceFile: () => isSourceFile,
     isSourceFileFromLibrary: () => isSourceFileFromLibrary,
@@ -187823,6 +188080,8 @@ ${e.message}`;
     isSignedNumericLiteral: () => isSignedNumericLiteral,
     isSimpleCopiableExpression: () => isSimpleCopiableExpression,
     isSimpleInlineableExpression: () => isSimpleInlineableExpression,
+    isSimpleParameter: () => isSimpleParameter,
+    isSimpleParameterList: () => isSimpleParameterList,
     isSingleOrDoubleQuote: () => isSingleOrDoubleQuote,
     isSourceFile: () => isSourceFile,
     isSourceFileFromLibrary: () => isSourceFileFromLibrary,