@danielx/civet 0.6.48 → 0.6.50

package/dist/browser.js

@@ -506,6 +506,7 @@ ${input.slice(result.pos)}
           }
           return;
         }
+        node = node;
         node.parent = parent;
         if (node.children) {
           for (const child of node.children) {
@@ -524,6 +525,7 @@ ${input.slice(result.pos)}
           }
           return;
         }
+        node = node;
         if (parent != null)
           node.parent = parent;
         if (depth && node.children) {
@@ -532,20 +534,24 @@ ${input.slice(result.pos)}
           }
         }
       }
+      function makeNode(node) {
+        updateParentPointers(node);
+        return node;
+      }
       function addPostfixStatement(statement, ws, post) {
         const expressions = [
           ...post.blockPrefix || [],
           ["", statement]
         ];
-        const block = {
+        const block = makeNode({
           type: "BlockStatement",
           children: [" { ", expressions, " }"],
           expressions
-        };
+        });
         const children = [...post.children, block];
         if (!isWhitespaceOrEmpty(ws))
           children.push(ws);
-        post = { ...post, children, block };
+        post = makeNode({ ...post, children, block });
         if (post.type === "IfStatement") {
           post.then = block;
         }
@@ -659,6 +665,7 @@ ${input.slice(result.pos)}
             });
           }
           const expressions = [...prefixStatements, ...block.expressions];
+          addParentPointers(prefixStatements, block);
           block = {
             ...block,
             expressions,
@@ -668,6 +675,7 @@ ${input.slice(result.pos)}
             block.children = [[" {"], ...block.children, "}"];
             block.bare = false;
           }
+          updateParentPointers(block);
         }
         return block;
       }
@@ -685,10 +693,11 @@ ${input.slice(result.pos)}
           const { ref, body } = expr;
           ref.type = "PipedExpression";
           ref.children = [makeLeftHandSideExpression(arg)];
-          return {
+          updateParentPointers(ref);
+          return makeNode({
             type: "UnwrappedExpression",
             children: [skipIfOnlyWS(fn.leadingComment), body, skipIfOnlyWS(fn.trailingComment)]
-          };
+          });
         }
         expr = fn.expr;
         const lhs = makeLeftHandSideExpression(expr);
@@ -902,6 +911,7 @@ ${input.slice(result.pos)}
         if (subtype === "DoStatement") {
           insertReturn(block);
           children.splice(i, 1, ...wrapIIFE(["", statement, void 0], async));
+          updateParentPointers(exp);
           return;
         }
         const resultsRef = makeRef("results");
@@ -916,6 +926,7 @@ ${input.slice(result.pos)}
             ["", wrapWithReturn(resultsRef)]
           ], async)
         );
+        updateParentPointers(exp);
       }
       function processBinaryOpExpression($0) {
         const expandedOps = expandChainedComparisons($0);
@@ -1209,10 +1220,10 @@ ${input.slice(result.pos)}
       }
       function wrapWithReturn(expression) {
         const children = expression ? ["return ", expression] : ["return"];
-        return {
+        return makeNode({
           type: "ReturnStatement",
           children
-        };
+        });
       }
       function isExistence(exp) {
         if (exp.type === "ParenthesizedExpression" && exp.implicit) {
@@ -1507,6 +1518,7 @@ ${input.slice(result.pos)}
           const indent = expressions[index][0];
           expressions.splice(index, 0, [indent, dec, ";"]);
         }
+        addParentPointers(dec, block);
       }
       function patternAsValue(pattern) {
         switch (pattern.type) {
@@ -1585,7 +1597,8 @@ ${input.slice(result.pos)}
           case "Declaration":
             exp.children.push(["", {
               type: "ReturnStatement",
-              children: [";return ", patternAsValue(exp.bindings.at(-1).pattern)]
+              children: [";return ", patternAsValue(exp.bindings.at(-1).pattern)],
+              parent: exp
             }]);
             return;
           case "FunctionExpression":
@@ -1594,7 +1607,8 @@ ${input.slice(result.pos)}
                 "",
                 {
                   type: "ReturnStatement",
-                  children: [";return ", exp.id]
+                  children: [";return ", exp.id],
+                  parent: exp
                 }
               ]);
               return;
@@ -1616,7 +1630,8 @@ ${input.slice(result.pos)}
               exp.children.push(["", {
                 type: "ReturnStatement",
                 // NOTE: add a prefixed semi-colon because the if block may not be braced
-                children: [";return"]
+                children: [";return"],
+                parent: exp
               }]);
             return;
           case "PatternMatchingStatement":
@@ -2036,13 +2051,26 @@ ${input.slice(result.pos)}
           case "ThrowExpression":
           case "TryExpression":
             return expression;
-          default:
-            return {
-              type: "ParenthesizedExpression",
-              children: ["(", expression, ")"],
-              expression,
-              implicit: true
-            };
+        }
+        return makeNode({
+          type: "ParenthesizedExpression",
+          children: ["(", expression, ")"],
+          expression,
+          implicit: true
+        });
+      }
+      function makeExpressionStatement(expression) {
+        if (Array.isArray(expression) && expression[1]?.[0]?.[0]?.[1]?.token === ",") {
+          return [
+            makeExpressionStatement(expression[0]),
+            expression[1].map(([comma, exp]) => {
+              return [comma, makeExpressionStatement(exp)];
+            })
+          ];
+        } else if (expression?.type === "ObjectExpression" || expression?.type === "FunctionExpression" && !expression.id) {
+          return makeLeftHandSideExpression(expression);
+        } else {
+          return expression;
         }
       }
       function modifyString(str) {
@@ -2250,7 +2278,7 @@ ${input.slice(result.pos)}
         splices = splices.map((s) => [", ", s]);
         thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
         const initializer = [ws, assign, e];
-        const binding = {
+        const binding = makeNode({
           type: "Binding",
           pattern: id,
           initializer,
@@ -2258,9 +2286,9 @@ ${input.slice(result.pos)}
           suffix,
           thisAssignments,
           children: [id, suffix, initializer]
-        };
+        });
         const children = [decl, binding];
-        return {
+        return makeNode({
           type: "Declaration",
           names: id.names,
           decl,
@@ -2268,9 +2296,9 @@ ${input.slice(result.pos)}
           splices,
           thisAssignments,
           children
-        };
+        });
       }
-      function processDeclarationCondition(condition, rootCondition) {
+      function processDeclarationCondition(condition, rootCondition, parent) {
         if (!(condition.type === "DeclarationCondition")) {
           return;
         }
@@ -2289,6 +2317,7 @@ ${input.slice(result.pos)}
           pattern,
           ref
         });
+        addParentPointers(condition, parent);
         Object.assign(rootCondition, {
           blockPrefix: [
             ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
@@ -2312,7 +2341,7 @@ ${input.slice(result.pos)}
           const type = [type1, type2];
           expression = expression2;
         }
-        processDeclarationCondition(expression, condition.expression);
+        processDeclarationCondition(expression, condition.expression, s);
         const { ref, pattern } = expression;
         if (pattern) {
           let conditions = [];
@@ -2362,10 +2391,12 @@ ${input.slice(result.pos)}
               parent: s
             };
             s.children[1] = s.condition;
+            updateParentPointers(s);
             const block = blockWithPrefix([["", [{
               type: "Declaration",
               children: ["let ", ...condition.expression.children]
             }], ";"], ...blockPrefix], makeEmptyBlock());
+            updateParentPointers(block, s.parent);
             replaceBlockExpression(s.parent, s, block);
             block.expressions.push(["", s]);
             s.parent = block;
@@ -3598,12 +3629,12 @@ ${input.slice(result.pos)}
             children: ["await "]
           };
         }
-        const block = {
+        const block = makeNode({
           type: "BlockStatement",
           expressions,
           children: ["{", expressions, "}"],
           bare: false
-        };
+        });
         const parameters = {
           type: "Parameters",
           children: ["()"],
@@ -3615,7 +3646,7 @@ ${input.slice(result.pos)}
           },
           returnType: void 0
         };
-        const fn = {
+        const fn = makeNode({
           type: "ArrowFunction",
           signature,
           parameters,
@@ -3624,12 +3655,11 @@ ${input.slice(result.pos)}
           async,
           block,
           children: [async, parameters, "=>", block]
-        };
-        updateParentPointers(block, fn);
-        const exp = {
+        });
+        const exp = makeNode({
           type: "CallExpression",
           children: [makeLeftHandSideExpression(fn), "()"]
-        };
+        });
         if (prefix) {
           return [makeLeftHandSideExpression([prefix, exp])];
         }
@@ -3676,6 +3706,7 @@ ${input.slice(result.pos)}
         literalValue,
         makeAsConst,
         makeEmptyBlock,
+        makeExpressionStatement,
         makeGetterMethod,
         makeLeftHandSideExpression,
         makeRef,
@@ -3740,6 +3771,7 @@ ${input.slice(result.pos)}
         NestedTopLevelStatements,
         TopLevelSingleLineStatements,
         TopLevelStatement,
+        ExtendedCommaExpression,
         ExtendedExpression,
         SingleLineExtendedExpression,
         NonPipelineExtendedExpression,
@@ -3748,7 +3780,7 @@ ${input.slice(result.pos)}
         ExpressionizedStatementWithTrailingCallExpressions,
         ExpressionizedStatement,
         _ExpressionizedStatement,
-        Expression,
+        CommaExpression,
         Arguments,
         ImplicitArguments,
         ExplicitArguments,
@@ -3893,15 +3925,18 @@ ${input.slice(result.pos)}
         BareBlock,
         ThenClause,
         BracedOrEmptyBlock,
+        NoCommaBracedOrEmptyBlock,
         NoPostfixBracedOrEmptyBlock,
         EmptyBlock,
         EmptyBareBlock,
         BracedBlock,
         NoPostfixBracedBlock,
+        NoCommaBracedBlock,
         NonSingleBracedBlock,
         DeclarationOrStatement,
         SingleLineStatements,
         PostfixedSingleLineStatements,
+        PostfixedSingleLineNoCommaStatements,
         BracedContent,
         NestedBlockStatements,
         NestedBlockStatement,
@@ -3969,11 +4004,15 @@ ${input.slice(result.pos)}
         ModuleItem,
         StatementListItem,
         PostfixedStatement,
+        NoCommaStatementListItem,
+        PostfixedNoCommaStatement,
         PostfixedExpression,
+        PostfixedCommaExpression,
         NonPipelinePostfixedExpression,
         PostfixStatement,
         _PostfixStatement,
         Statement,
+        NoCommaStatement,
         EmptyStatement,
         BlockStatement,
         LabelledStatement,
@@ -4057,6 +4096,7 @@ ${input.slice(result.pos)}
         NewlineBinaryOpAllowed,
         AllowAll,
         RestoreAll,
+        CommaExpressionStatement,
         ExpressionStatement,
         KeywordStatement,
         DebuggerStatement,
@@ -4793,6 +4833,12 @@ ${input.slice(result.pos)}
       function TopLevelStatement(ctx, state) {
         return $EVENT(ctx, state, "TopLevelStatement", TopLevelStatement$0);
       }
+      var ExtendedCommaExpression$0 = NonAssignmentExtendedExpression;
+      var ExtendedCommaExpression$1 = CommaExpression;
+      var ExtendedCommaExpression$$ = [ExtendedCommaExpression$0, ExtendedCommaExpression$1];
+      function ExtendedCommaExpression(ctx, state) {
+        return $EVENT_C(ctx, state, "ExtendedCommaExpression", ExtendedCommaExpression$$);
+      }
       var ExtendedExpression$0 = NonAssignmentExtendedExpression;
       var ExtendedExpression$1 = AssignmentExpression;
       var ExtendedExpression$$ = [ExtendedExpression$0, ExtendedExpression$1];
@@ -4871,13 +4917,13 @@ ${input.slice(result.pos)}
       function _ExpressionizedStatement(ctx, state) {
         return $EVENT_C(ctx, state, "_ExpressionizedStatement", _ExpressionizedStatement$$);
       }
-      var Expression$0 = $TS($S(AssignmentExpression, $Q($S(CommaDelimiter, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
+      var CommaExpression$0 = $TS($S(AssignmentExpression, $Q($S(CommaDelimiter, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
         if ($2.length == 0)
           return $1;
         return $0;
       });
-      function Expression(ctx, state) {
-        return $EVENT(ctx, state, "Expression", Expression$0);
+      function CommaExpression(ctx, state) {
+        return $EVENT(ctx, state, "CommaExpression", CommaExpression$0);
       }
       var Arguments$0 = ExplicitArguments;
       var Arguments$1 = $TS($S(ForbidTrailingMemberProperty, $E(ImplicitArguments), RestoreTrailingMemberProperty), function($skip, $loc, $0, $1, $2, $3) {
@@ -5286,7 +5332,7 @@ ${input.slice(result.pos)}
         var exp = value[1];
         return exp;
       });
-      var FatArrowBody$1 = BracedOrEmptyBlock;
+      var FatArrowBody$1 = NoCommaBracedOrEmptyBlock;
       var FatArrowBody$$ = [FatArrowBody$0, FatArrowBody$1];
       function FatArrowBody(ctx, state) {
         return $EVENT_C(ctx, state, "FatArrowBody", FatArrowBody$$);
@@ -5398,7 +5444,7 @@ ${input.slice(result.pos)}
       function PrimaryExpression(ctx, state) {
         return $EVENT_C(ctx, state, "PrimaryExpression", PrimaryExpression$$);
       }
-      var ParenthesizedExpression$0 = $TS($S(OpenParen, AllowAll, $E($S(PostfixedExpression, __, CloseParen)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ParenthesizedExpression$0 = $TS($S(OpenParen, AllowAll, $E($S(PostfixedCommaExpression, __, CloseParen)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
         var open = $1;
         if (!$3)
           return $skip;
@@ -6792,7 +6838,7 @@ ${input.slice(result.pos)}
       function AmpersandUnaryPrefix(ctx, state) {
         return $EVENT(ctx, state, "AmpersandUnaryPrefix", AmpersandUnaryPrefix$0);
       }
-      var ThinArrowFunction$0 = $TS($S($E($S(Async, _)), ArrowParameters, $E(ReturnTypeSuffix), $E(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var ThinArrowFunction$0 = $TS($S($E($S(Async, _)), ArrowParameters, $E(ReturnTypeSuffix), $E(_), Arrow, NoCommaBracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         var async = $1;
         var parameters = $2;
         var suffix = $3;
@@ -6934,6 +6980,12 @@ ${input.slice(result.pos)}
       function BracedOrEmptyBlock(ctx, state) {
         return $EVENT_C(ctx, state, "BracedOrEmptyBlock", BracedOrEmptyBlock$$);
       }
+      var NoCommaBracedOrEmptyBlock$0 = NoCommaBracedBlock;
+      var NoCommaBracedOrEmptyBlock$1 = EmptyBlock;
+      var NoCommaBracedOrEmptyBlock$$ = [NoCommaBracedOrEmptyBlock$0, NoCommaBracedOrEmptyBlock$1];
+      function NoCommaBracedOrEmptyBlock(ctx, state) {
+        return $EVENT_C(ctx, state, "NoCommaBracedOrEmptyBlock", NoCommaBracedOrEmptyBlock$$);
+      }
       var NoPostfixBracedOrEmptyBlock$0 = NoPostfixBracedBlock;
       var NoPostfixBracedOrEmptyBlock$1 = EmptyBlock;
       var NoPostfixBracedOrEmptyBlock$$ = [NoPostfixBracedOrEmptyBlock$0, NoPostfixBracedOrEmptyBlock$1];
@@ -7003,6 +7055,25 @@ ${input.slice(result.pos)}
       function NoPostfixBracedBlock(ctx, state) {
         return $EVENT_C(ctx, state, "NoPostfixBracedBlock", NoPostfixBracedBlock$$);
       }
+      var NoCommaBracedBlock$0 = NonSingleBracedBlock;
+      var NoCommaBracedBlock$1 = $TS($S(InsertOpenBrace, $N(EOS), PostfixedSingleLineNoCommaStatements, InsertSpace, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+        var o = $1;
+        var s = $3;
+        var ws = $4;
+        var c = $5;
+        if (!s.children.length)
+          return $skip;
+        return {
+          type: "BlockStatement",
+          expressions: s.expressions,
+          // Remove !EOS assertion
+          children: [o, s.children, ws, c]
+        };
+      });
+      var NoCommaBracedBlock$$ = [NoCommaBracedBlock$0, NoCommaBracedBlock$1];
+      function NoCommaBracedBlock(ctx, state) {
+        return $EVENT_C(ctx, state, "NoCommaBracedBlock", NoCommaBracedBlock$$);
+      }
       var NonSingleBracedBlock$0 = $TS($S($E(_), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var ws1 = $1;
         var open = $2;
@@ -7070,6 +7141,22 @@ ${input.slice(result.pos)}
       function PostfixedSingleLineStatements(ctx, state) {
         return $EVENT(ctx, state, "PostfixedSingleLineStatements", PostfixedSingleLineStatements$0);
       }
+      var PostfixedSingleLineNoCommaStatements$0 = $TS($S($Q($S($S($E(_), $N(EOS)), NoCommaStatementListItem, SemicolonDelimiter)), $E($S($S($E(_), $N(EOS)), NoCommaStatementListItem, $E(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
+        var stmts = $1;
+        var last = $2;
+        const children = [...stmts];
+        if (last)
+          children.push(last);
+        return {
+          type: "BlockStatement",
+          expressions: children,
+          children,
+          bare: true
+        };
+      });
+      function PostfixedSingleLineNoCommaStatements(ctx, state) {
+        return $EVENT(ctx, state, "PostfixedSingleLineNoCommaStatements", PostfixedSingleLineNoCommaStatements$0);
+      }
       var BracedContent$0 = NestedBlockStatements;
       var BracedContent$1 = SingleLineStatements;
       var BracedContent$2 = $TV($Y($S(__, $EXPECT($L25, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
@@ -8464,6 +8551,22 @@ ${input.slice(result.pos)}
       function PostfixedStatement(ctx, state) {
         return $EVENT(ctx, state, "PostfixedStatement", PostfixedStatement$0);
       }
+      var NoCommaStatementListItem$0 = Declaration;
+      var NoCommaStatementListItem$1 = PostfixedNoCommaStatement;
+      var NoCommaStatementListItem$$ = [NoCommaStatementListItem$0, NoCommaStatementListItem$1];
+      function NoCommaStatementListItem(ctx, state) {
+        return $EVENT_C(ctx, state, "NoCommaStatementListItem", NoCommaStatementListItem$$);
+      }
+      var PostfixedNoCommaStatement$0 = $TS($S(NoCommaStatement, $E($S($E(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
+        var statement = $1;
+        var post = $2;
+        if (post)
+          return addPostfixStatement(statement, ...post);
+        return statement;
+      });
+      function PostfixedNoCommaStatement(ctx, state) {
+        return $EVENT(ctx, state, "PostfixedNoCommaStatement", PostfixedNoCommaStatement$0);
+      }
       var PostfixedExpression$0 = $TS($S(ExtendedExpression, $E($S($E(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
         var expression = $1;
         var post = $2;
@@ -8474,6 +8577,19 @@ ${input.slice(result.pos)}
       function PostfixedExpression(ctx, state) {
         return $EVENT(ctx, state, "PostfixedExpression", PostfixedExpression$0);
       }
+      var PostfixedCommaExpression$0 = $TS($S(PostfixedExpression, $C($S($E(_), PostfixStatement), $Q($S(CommaDelimiter, AssignmentExpression)))), function($skip, $loc, $0, $1, $2) {
+        var expression = $1;
+        var post = $2;
+        if (!post.length)
+          return $1;
+        if (post.length === 2 && !Array.isArray(post[1])) {
+          return attachPostfixStatementAsExpression(expression, post);
+        }
+        return $0;
+      });
+      function PostfixedCommaExpression(ctx, state) {
+        return $EVENT(ctx, state, "PostfixedCommaExpression", PostfixedCommaExpression$0);
+      }
       var NonPipelinePostfixedExpression$0 = $TS($S(NonPipelineExtendedExpression, $E($S($E(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
         var expression = $1;
         var post = $2;
@@ -8507,17 +8623,26 @@ ${input.slice(result.pos)}
       var Statement$5 = TryStatement;
       var Statement$6 = EmptyStatement;
       var Statement$7 = LabelledStatement;
-      var Statement$8 = $TS($S(ExpressionStatement), function($skip, $loc, $0, $1) {
-        if ($1.type === "ObjectExpression" || $1.type === "FunctionExpression" && !$1.id) {
-          return makeLeftHandSideExpression($1);
-        }
-        return $1;
-      });
+      var Statement$8 = CommaExpressionStatement;
       var Statement$9 = BlockStatement;
       var Statement$$ = [Statement$0, Statement$1, Statement$2, Statement$3, Statement$4, Statement$5, Statement$6, Statement$7, Statement$8, Statement$9];
       function Statement(ctx, state) {
         return $EVENT_C(ctx, state, "Statement", Statement$$);
       }
+      var NoCommaStatement$0 = KeywordStatement;
+      var NoCommaStatement$1 = VariableStatement;
+      var NoCommaStatement$2 = IfStatement;
+      var NoCommaStatement$3 = IterationStatement;
+      var NoCommaStatement$4 = SwitchStatement;
+      var NoCommaStatement$5 = TryStatement;
+      var NoCommaStatement$6 = EmptyStatement;
+      var NoCommaStatement$7 = LabelledStatement;
+      var NoCommaStatement$8 = ExpressionStatement;
+      var NoCommaStatement$9 = BlockStatement;
+      var NoCommaStatement$$ = [NoCommaStatement$0, NoCommaStatement$1, NoCommaStatement$2, NoCommaStatement$3, NoCommaStatement$4, NoCommaStatement$5, NoCommaStatement$6, NoCommaStatement$7, NoCommaStatement$8, NoCommaStatement$9];
+      function NoCommaStatement(ctx, state) {
+        return $EVENT_C(ctx, state, "NoCommaStatement", NoCommaStatement$$);
+      }
       var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L99, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
         return { type: "EmptyStatement", children: $1 || [] };
       });
@@ -8996,14 +9121,14 @@ ${input.slice(result.pos)}
       function CoffeeForDeclaration(ctx, state) {
         return $EVENT(ctx, state, "CoffeeForDeclaration", CoffeeForDeclaration$0);
       }
-      var ForStatementParameters$0 = $TS($S(OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
+      var ForStatementParameters$0 = $TS($S(OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(CommaExpression)), __, Semicolon, $E(CommaExpression), Semicolon, $E(CommaExpression), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
         var declaration = $3;
         return {
           declaration,
           children: $0
         };
       });
-      var ForStatementParameters$1 = $TS($S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E($S($N(EOS), ExpressionWithIndentedApplicationForbidden)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var ForStatementParameters$1 = $TS($S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(CommaExpression)), __, Semicolon, $E(CommaExpression), Semicolon, $E($S($N(EOS), ExpressionWithIndentedApplicationForbidden)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         var declaration = $3;
         return {
           declaration,
@@ -9579,8 +9704,18 @@ ${input.slice(result.pos)}
       function RestoreAll(ctx, state) {
         return $EVENT(ctx, state, "RestoreAll", RestoreAll$0);
       }
+      var CommaExpressionStatement$0 = IterationExpression;
+      var CommaExpressionStatement$1 = $TS($S(CommaExpression), function($skip, $loc, $0, $1) {
+        return makeExpressionStatement($1);
+      });
+      var CommaExpressionStatement$$ = [CommaExpressionStatement$0, CommaExpressionStatement$1];
+      function CommaExpressionStatement(ctx, state) {
+        return $EVENT_C(ctx, state, "CommaExpressionStatement", CommaExpressionStatement$$);
+      }
       var ExpressionStatement$0 = IterationExpression;
-      var ExpressionStatement$1 = Expression;
+      var ExpressionStatement$1 = $TS($S(AssignmentExpression), function($skip, $loc, $0, $1) {
+        return makeExpressionStatement($1);
+      });
       var ExpressionStatement$$ = [ExpressionStatement$0, ExpressionStatement$1];
       function ExpressionStatement(ctx, state) {
         return $EVENT_C(ctx, state, "ExpressionStatement", ExpressionStatement$$);
@@ -12214,7 +12349,7 @@ ${input.slice(result.pos)}
           args
         };
       });
-      var TypePrimary$8 = $S(__, OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
+      var TypePrimary$8 = $S($E(_), OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
       var TypePrimary$$ = [TypePrimary$0, TypePrimary$1, TypePrimary$2, TypePrimary$3, TypePrimary$4, TypePrimary$5, TypePrimary$6, TypePrimary$7, TypePrimary$8];
       function TypePrimary(ctx, state) {
         return $EVENT_C(ctx, state, "TypePrimary", TypePrimary$$);
@@ -13103,6 +13238,7 @@ ${input.slice(result.pos)}
       exports.NestedTopLevelStatements = NestedTopLevelStatements;
       exports.TopLevelSingleLineStatements = TopLevelSingleLineStatements;
       exports.TopLevelStatement = TopLevelStatement;
+      exports.ExtendedCommaExpression = ExtendedCommaExpression;
       exports.ExtendedExpression = ExtendedExpression;
       exports.SingleLineExtendedExpression = SingleLineExtendedExpression;
       exports.NonPipelineExtendedExpression = NonPipelineExtendedExpression;
@@ -13111,7 +13247,7 @@ ${input.slice(result.pos)}
       exports.ExpressionizedStatementWithTrailingCallExpressions = ExpressionizedStatementWithTrailingCallExpressions;
       exports.ExpressionizedStatement = ExpressionizedStatement;
       exports._ExpressionizedStatement = _ExpressionizedStatement;
-      exports.Expression = Expression;
+      exports.CommaExpression = CommaExpression;
       exports.Arguments = Arguments;
       exports.ImplicitArguments = ImplicitArguments;
       exports.ExplicitArguments = ExplicitArguments;
@@ -13256,15 +13392,18 @@ ${input.slice(result.pos)}
       exports.BareBlock = BareBlock;
       exports.ThenClause = ThenClause;
       exports.BracedOrEmptyBlock = BracedOrEmptyBlock;
+      exports.NoCommaBracedOrEmptyBlock = NoCommaBracedOrEmptyBlock;
       exports.NoPostfixBracedOrEmptyBlock = NoPostfixBracedOrEmptyBlock;
       exports.EmptyBlock = EmptyBlock;
       exports.EmptyBareBlock = EmptyBareBlock;
       exports.BracedBlock = BracedBlock;
       exports.NoPostfixBracedBlock = NoPostfixBracedBlock;
+      exports.NoCommaBracedBlock = NoCommaBracedBlock;
       exports.NonSingleBracedBlock = NonSingleBracedBlock;
       exports.DeclarationOrStatement = DeclarationOrStatement;
       exports.SingleLineStatements = SingleLineStatements;
       exports.PostfixedSingleLineStatements = PostfixedSingleLineStatements;
+      exports.PostfixedSingleLineNoCommaStatements = PostfixedSingleLineNoCommaStatements;
       exports.BracedContent = BracedContent;
       exports.NestedBlockStatements = NestedBlockStatements;
       exports.NestedBlockStatement = NestedBlockStatement;
@@ -13332,11 +13471,15 @@ ${input.slice(result.pos)}
       exports.ModuleItem = ModuleItem;
       exports.StatementListItem = StatementListItem;
       exports.PostfixedStatement = PostfixedStatement;
+      exports.NoCommaStatementListItem = NoCommaStatementListItem;
+      exports.PostfixedNoCommaStatement = PostfixedNoCommaStatement;
       exports.PostfixedExpression = PostfixedExpression;
+      exports.PostfixedCommaExpression = PostfixedCommaExpression;
       exports.NonPipelinePostfixedExpression = NonPipelinePostfixedExpression;
       exports.PostfixStatement = PostfixStatement;
       exports._PostfixStatement = _PostfixStatement;
       exports.Statement = Statement;
+      exports.NoCommaStatement = NoCommaStatement;
       exports.EmptyStatement = EmptyStatement;
       exports.BlockStatement = BlockStatement;
       exports.LabelledStatement = LabelledStatement;
@@ -13420,6 +13563,7 @@ ${input.slice(result.pos)}
       exports.NewlineBinaryOpAllowed = NewlineBinaryOpAllowed;
       exports.AllowAll = AllowAll;
       exports.RestoreAll = RestoreAll;
+      exports.CommaExpressionStatement = CommaExpressionStatement;
       exports.ExpressionStatement = ExpressionStatement;
       exports.KeywordStatement = KeywordStatement;
       exports.DebuggerStatement = DebuggerStatement;
@@ -13809,6 +13953,7 @@ ${input.slice(result.pos)}
         lastAccessInCallExpression,
         literalValue,
         makeEmptyBlock,
+        makeExpressionStatement,
         makeGetterMethod,
         makeLeftHandSideExpression,
         makeRef,