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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20231103`;
+      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);
@@ -144003,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;
@@ -169713,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 */),
@@ -172246,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);
             }, {
@@ -172260,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;
             }, {
@@ -185510,6 +185670,8 @@ ${e.message}`;
     isSignedNumericLiteral: () => isSignedNumericLiteral,
     isSimpleCopiableExpression: () => isSimpleCopiableExpression,
     isSimpleInlineableExpression: () => isSimpleInlineableExpression,
+    isSimpleParameter: () => isSimpleParameter,
+    isSimpleParameterList: () => isSimpleParameterList,
     isSingleOrDoubleQuote: () => isSingleOrDoubleQuote,
     isSourceFile: () => isSourceFile,
     isSourceFileFromLibrary: () => isSourceFileFromLibrary,
@@ -187918,6 +188080,8 @@ ${e.message}`;
     isSignedNumericLiteral: () => isSignedNumericLiteral,
     isSimpleCopiableExpression: () => isSimpleCopiableExpression,
     isSimpleInlineableExpression: () => isSimpleInlineableExpression,
+    isSimpleParameter: () => isSimpleParameter,
+    isSimpleParameterList: () => isSimpleParameterList,
     isSingleOrDoubleQuote: () => isSingleOrDoubleQuote,
     isSourceFile: () => isSourceFile,
     isSourceFileFromLibrary: () => isSourceFileFromLibrary,