typescript 5.4.0-dev.20231103 → 5.4.0-dev.20231104

package/lib/lib.es2016.d.ts

@@ -18,3 +18,4 @@ and limitations under the License.
 
 /// <reference lib="es2015" />
 /// <reference lib="es2016.array.include" />
+/// <reference lib="es2016.intl" />

package/lib/lib.es2016.intl.d.ts

@@ -0,0 +1,31 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+    /**
+     * The `Intl.getCanonicalLocales()` method returns an array containing
+     * the canonical locale names. Duplicates will be omitted and elements
+     * will be validated as structurally valid language tags.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales)
+     *
+     * @param locale A list of String values for which to get the canonical locale names
+     * @returns An array containing the canonical and validated locale names.
+     */
+    function getCanonicalLocales(locale?: string | string[]): string[];
+}

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231103`;
+var version = `${versionMajorMinor}.0-dev.20231104`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -23404,7 +23404,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*/
@@ -23414,8 +23414,7 @@ function createEmitHelperFactory(context) {
       void 0,
       /*typeParameters*/
       void 0,
-      /*parameters*/
-      [],
+      parameters ?? [],
       /*type*/
       void 0,
       body
@@ -23427,7 +23426,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
       ]
@@ -33842,6 +33841,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"],
@@ -34173,6 +34173,7 @@ var targetOptionDeclaration = {
   affectsModuleResolution: true,
   affectsEmit: true,
   affectsBuildInfo: true,
+  deprecatedKeys: /* @__PURE__ */ new Set(["es3"]),
   paramType: Diagnostics.VERSION,
   showInSimplifiedHelpView: true,
   category: Diagnostics.Language_and_Environment,
@@ -40034,6 +40035,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 */:
@@ -66866,15 +66870,23 @@ function createTypeChecker(host) {
         error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers);
         return errorType;
       }
-      const container = getContainingFunction(node);
-      if (languageVersion < 2 /* ES2015 */) {
-        if (container.kind === 219 /* ArrowFunction */) {
-          error(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 */)) {
-          error(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 */) {
+            error(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 */)) {
+            error(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)) {
@@ -86741,6 +86753,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
 function flattenDestructuringAssignment(node, visitor, context, level, needsValue, createAssignmentCallback) {
@@ -94217,6 +94235,7 @@ function transformES2017(context) {
   let enclosingFunctionParameterNames;
   let capturedSuperProperties;
   let hasSuperElementAccess;
+  let lexicalArgumentsBinding;
   const substitutedSuperAccessors = [];
   let contextFlags = 0 /* None */;
   const previousOnEmitNode = context.onEmitNode;
@@ -94267,9 +94286,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 */:
@@ -94427,15 +94467,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,
@@ -94444,14 +94492,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,
@@ -94460,55 +94512,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) {
@@ -94602,13 +94674,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) {
@@ -94620,27 +94770,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();
@@ -94650,6 +94796,9 @@ function transformES2017(context) {
           insertStatementsAfterStandardPrologue(statements, [variableStatement]);
         }
       }
+      if (captureLexicalArguments) {
+        insertStatementsAfterStandardPrologue(statements, [createCaptureArgumentsStatement()]);
+      }
       const block = factory2.createBlock(
         statements,
         /*multiLine*/
@@ -94665,24 +94814,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;
   }
@@ -95798,7 +95946,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) : transformFunctionBody(node)
@@ -95819,7 +95967,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) : transformFunctionBody(node)
@@ -95860,7 +96008,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) : transformFunctionBody(node)
@@ -95869,21 +96017,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(
@@ -95893,14 +96058,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 */)
       )
@@ -95910,11 +96071,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);
@@ -125887,7 +126047,10 @@ function generateOptionOutput(sys2, option, rightAlignOfLeft, leftAlignOfRight)
         default:
           const inverted = {};
           option3.type.forEach((value, name2) => {
-            (inverted[value] || (inverted[value] = [])).push(name2);
+            var _a2;
+            if (!((_a2 = option3.deprecatedKeys) == null ? void 0 : _a2.has(name2))) {
+              (inverted[value] || (inverted[value] = [])).push(name2);
+            }
           });
           return Object.entries(inverted).map(([, synonyms]) => synonyms.join("/")).join(", ");
       }