@danielx/civet 0.6.49 → 0.6.51

package/dist/main.js

@@ -2051,6 +2051,20 @@ var require_lib = __commonJS({
         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) {
       return str.replace(/(^.?|[^\\]{2})(\\\\)*\n/g, "$1$2\\n");
     }
@@ -3684,6 +3698,7 @@ var require_lib = __commonJS({
       literalValue,
       makeAsConst,
       makeEmptyBlock,
+      makeExpressionStatement,
       makeGetterMethod,
       makeLeftHandSideExpression,
       makeRef,
@@ -3748,6 +3763,7 @@ var require_parser = __commonJS({
       NestedTopLevelStatements,
       TopLevelSingleLineStatements,
       TopLevelStatement,
+      ExtendedCommaExpression,
       ExtendedExpression,
       SingleLineExtendedExpression,
       NonPipelineExtendedExpression,
@@ -3756,7 +3772,7 @@ var require_parser = __commonJS({
       ExpressionizedStatementWithTrailingCallExpressions,
       ExpressionizedStatement,
       _ExpressionizedStatement,
-      Expression,
+      CommaExpression,
       Arguments,
       ImplicitArguments,
       ExplicitArguments,
@@ -3901,15 +3917,18 @@ var require_parser = __commonJS({
       BareBlock,
       ThenClause,
       BracedOrEmptyBlock,
+      NoCommaBracedOrEmptyBlock,
       NoPostfixBracedOrEmptyBlock,
       EmptyBlock,
       EmptyBareBlock,
       BracedBlock,
       NoPostfixBracedBlock,
+      NoCommaBracedBlock,
       NonSingleBracedBlock,
       DeclarationOrStatement,
       SingleLineStatements,
       PostfixedSingleLineStatements,
+      PostfixedSingleLineNoCommaStatements,
       BracedContent,
       NestedBlockStatements,
       NestedBlockStatement,
@@ -3977,11 +3996,15 @@ var require_parser = __commonJS({
       ModuleItem,
       StatementListItem,
       PostfixedStatement,
+      NoCommaStatementListItem,
+      PostfixedNoCommaStatement,
       PostfixedExpression,
+      PostfixedCommaExpression,
       NonPipelinePostfixedExpression,
       PostfixStatement,
       _PostfixStatement,
       Statement,
+      NoCommaStatement,
       EmptyStatement,
       BlockStatement,
       LabelledStatement,
@@ -4065,6 +4088,7 @@ var require_parser = __commonJS({
       NewlineBinaryOpAllowed,
       AllowAll,
       RestoreAll,
+      CommaExpressionStatement,
       ExpressionStatement,
       KeywordStatement,
       DebuggerStatement,
@@ -4801,6 +4825,12 @@ var require_parser = __commonJS({
     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];
@@ -4879,13 +4909,13 @@ var require_parser = __commonJS({
     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) {
@@ -5290,11 +5320,14 @@ var require_parser = __commonJS({
     function TrailingDeclaration(ctx, state) {
       return $EVENT(ctx, state, "TrailingDeclaration", TrailingDeclaration$0);
     }
-    var FatArrowBody$0 = $T($S($N(EOS), NonPipelinePostfixedExpression, $N(TrailingDeclaration), $N(SemicolonDelimiter)), function(value) {
-      var exp = value[1];
+    var FatArrowBody$0 = $TS($S($N(EOS), NonPipelinePostfixedExpression, $N(TrailingDeclaration), $N(SemicolonDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var exp = $2;
+      if (exp.type === "ObjectExpression") {
+        return makeLeftHandSideExpression(exp);
+      }
       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$$);
@@ -5406,7 +5439,7 @@ var require_parser = __commonJS({
     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;
@@ -6800,7 +6833,7 @@ var require_parser = __commonJS({
     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;
@@ -6942,6 +6975,12 @@ var require_parser = __commonJS({
     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];
@@ -7011,6 +7050,25 @@ var require_parser = __commonJS({
     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;
@@ -7078,6 +7136,22 @@ var require_parser = __commonJS({
     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) {
@@ -8472,6 +8546,22 @@ var require_parser = __commonJS({
     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;
@@ -8482,6 +8572,19 @@ var require_parser = __commonJS({
     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;
@@ -8515,17 +8618,26 @@ var require_parser = __commonJS({
     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 || [] };
     });
@@ -9004,14 +9116,14 @@ var require_parser = __commonJS({
     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,
@@ -9587,8 +9699,18 @@ var require_parser = __commonJS({
     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$$);
@@ -12222,7 +12344,7 @@ var require_parser = __commonJS({
         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$$);
@@ -12871,19 +12993,45 @@ var require_parser = __commonJS({
           };
           module2.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
         },
+        Falsy(FalsyRef) {
+          module2.prelude.push(["", [{
+            ts: true,
+            children: ["type ", FalsyRef, " = false | 0 | '' | 0n | null | undefined;", "\n"]
+          }]]);
+        },
         xor(xorRef) {
+          const Falsy = module2.getRef("Falsy");
           const typeSuffix = {
             ts: true,
-            children: [": (a: unknown, b: unknown) => boolean"]
+            children: [
+              ": <A, B>(a: A, b: B) => A extends ",
+              Falsy,
+              " ? B : B extends ",
+              Falsy,
+              " ? A : (false | (A & ",
+              Falsy,
+              " extends never ? never : B) | (B & ",
+              Falsy,
+              " extends never ? never : A))"
+            ]
           };
-          module2.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
+          module2.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => (a ? !b && a : b)", asAny, ";", "\n"]]);
         },
         xnor(xnorRef) {
+          const Falsy = module2.getRef("Falsy");
           const typeSuffix = {
             ts: true,
-            children: [": (a: unknown, b: unknown) => boolean"]
+            children: [
+              ": <A, B>(a: A, b: B) => A & ",
+              Falsy,
+              " extends never ? B : (true | (B extends ",
+              Falsy,
+              " ? never : A) | (A extends ",
+              Falsy,
+              " ? never : B))"
+            ]
           };
-          module2.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
+          module2.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => (a ? b : !b || a)", asAny, ";", "\n"]]);
         },
         returnSymbol(ref) {
           module2.prelude.push({
@@ -13111,6 +13259,7 @@ var require_parser = __commonJS({
     exports.NestedTopLevelStatements = NestedTopLevelStatements;
     exports.TopLevelSingleLineStatements = TopLevelSingleLineStatements;
     exports.TopLevelStatement = TopLevelStatement;
+    exports.ExtendedCommaExpression = ExtendedCommaExpression;
     exports.ExtendedExpression = ExtendedExpression;
     exports.SingleLineExtendedExpression = SingleLineExtendedExpression;
     exports.NonPipelineExtendedExpression = NonPipelineExtendedExpression;
@@ -13119,7 +13268,7 @@ var require_parser = __commonJS({
     exports.ExpressionizedStatementWithTrailingCallExpressions = ExpressionizedStatementWithTrailingCallExpressions;
     exports.ExpressionizedStatement = ExpressionizedStatement;
     exports._ExpressionizedStatement = _ExpressionizedStatement;
-    exports.Expression = Expression;
+    exports.CommaExpression = CommaExpression;
     exports.Arguments = Arguments;
     exports.ImplicitArguments = ImplicitArguments;
     exports.ExplicitArguments = ExplicitArguments;
@@ -13264,15 +13413,18 @@ var require_parser = __commonJS({
     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;
@@ -13340,11 +13492,15 @@ var require_parser = __commonJS({
     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;
@@ -13428,6 +13584,7 @@ var require_parser = __commonJS({
     exports.NewlineBinaryOpAllowed = NewlineBinaryOpAllowed;
     exports.AllowAll = AllowAll;
     exports.RestoreAll = RestoreAll;
+    exports.CommaExpressionStatement = CommaExpressionStatement;
     exports.ExpressionStatement = ExpressionStatement;
     exports.KeywordStatement = KeywordStatement;
     exports.DebuggerStatement = DebuggerStatement;
@@ -13817,6 +13974,7 @@ var require_parser = __commonJS({
       lastAccessInCallExpression,
       literalValue,
       makeEmptyBlock,
+      makeExpressionStatement,
       makeGetterMethod,
       makeLeftHandSideExpression,
       makeRef,