@danielx/civet 0.6.48 → 0.6.50

package/dist/main.mjs

@@ -496,6 +496,7 @@ var require_lib = __commonJS({
         }
         return;
       }
+      node = node;
       node.parent = parent;
       if (node.children) {
         for (const child of node.children) {
@@ -514,6 +515,7 @@ var require_lib = __commonJS({
         }
         return;
       }
+      node = node;
       if (parent != null)
         node.parent = parent;
       if (depth && node.children) {
@@ -522,20 +524,24 @@ var require_lib = __commonJS({
         }
       }
     }
+    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;
       }
@@ -649,6 +655,7 @@ var require_lib = __commonJS({
           });
         }
         const expressions = [...prefixStatements, ...block.expressions];
+        addParentPointers(prefixStatements, block);
         block = {
           ...block,
           expressions,
@@ -658,6 +665,7 @@ var require_lib = __commonJS({
           block.children = [[" {"], ...block.children, "}"];
           block.bare = false;
         }
+        updateParentPointers(block);
       }
       return block;
     }
@@ -675,10 +683,11 @@ var require_lib = __commonJS({
         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);
@@ -892,6 +901,7 @@ var require_lib = __commonJS({
       if (subtype === "DoStatement") {
         insertReturn(block);
         children.splice(i, 1, ...wrapIIFE(["", statement, void 0], async));
+        updateParentPointers(exp);
         return;
       }
       const resultsRef = makeRef("results");
@@ -906,6 +916,7 @@ var require_lib = __commonJS({
           ["", wrapWithReturn(resultsRef)]
         ], async)
       );
+      updateParentPointers(exp);
     }
     function processBinaryOpExpression($0) {
       const expandedOps = expandChainedComparisons($0);
@@ -1199,10 +1210,10 @@ var require_lib = __commonJS({
     }
     function wrapWithReturn(expression) {
       const children = expression ? ["return ", expression] : ["return"];
-      return {
+      return makeNode({
         type: "ReturnStatement",
         children
-      };
+      });
     }
     function isExistence(exp) {
       if (exp.type === "ParenthesizedExpression" && exp.implicit) {
@@ -1497,6 +1508,7 @@ var require_lib = __commonJS({
         const indent = expressions[index][0];
         expressions.splice(index, 0, [indent, dec, ";"]);
       }
+      addParentPointers(dec, block);
     }
     function patternAsValue(pattern) {
       switch (pattern.type) {
@@ -1575,7 +1587,8 @@ var require_lib = __commonJS({
         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":
@@ -1584,7 +1597,8 @@ var require_lib = __commonJS({
               "",
               {
                 type: "ReturnStatement",
-                children: [";return ", exp.id]
+                children: [";return ", exp.id],
+                parent: exp
               }
             ]);
             return;
@@ -1606,7 +1620,8 @@ var require_lib = __commonJS({
             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":
@@ -2026,13 +2041,26 @@ var require_lib = __commonJS({
         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) {
@@ -2240,7 +2268,7 @@ var require_lib = __commonJS({
       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,
@@ -2248,9 +2276,9 @@ var require_lib = __commonJS({
         suffix,
         thisAssignments,
         children: [id, suffix, initializer]
-      };
+      });
       const children = [decl, binding];
-      return {
+      return makeNode({
         type: "Declaration",
         names: id.names,
         decl,
@@ -2258,9 +2286,9 @@ var require_lib = __commonJS({
         splices,
         thisAssignments,
         children
-      };
+      });
     }
-    function processDeclarationCondition(condition, rootCondition) {
+    function processDeclarationCondition(condition, rootCondition, parent) {
       if (!(condition.type === "DeclarationCondition")) {
         return;
       }
@@ -2279,6 +2307,7 @@ var require_lib = __commonJS({
         pattern,
         ref
       });
+      addParentPointers(condition, parent);
       Object.assign(rootCondition, {
         blockPrefix: [
           ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
@@ -2302,7 +2331,7 @@ var require_lib = __commonJS({
         const type = [type1, type2];
         expression = expression2;
       }
-      processDeclarationCondition(expression, condition.expression);
+      processDeclarationCondition(expression, condition.expression, s);
       const { ref, pattern } = expression;
       if (pattern) {
         let conditions = [];
@@ -2352,10 +2381,12 @@ var require_lib = __commonJS({
             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;
@@ -3588,12 +3619,12 @@ var require_lib = __commonJS({
           children: ["await "]
         };
       }
-      const block = {
+      const block = makeNode({
         type: "BlockStatement",
         expressions,
         children: ["{", expressions, "}"],
         bare: false
-      };
+      });
       const parameters = {
         type: "Parameters",
         children: ["()"],
@@ -3605,7 +3636,7 @@ var require_lib = __commonJS({
         },
         returnType: void 0
       };
-      const fn = {
+      const fn = makeNode({
         type: "ArrowFunction",
         signature,
         parameters,
@@ -3614,12 +3645,11 @@ var require_lib = __commonJS({
         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])];
       }
@@ -3666,6 +3696,7 @@ var require_lib = __commonJS({
       literalValue,
       makeAsConst,
       makeEmptyBlock,
+      makeExpressionStatement,
       makeGetterMethod,
       makeLeftHandSideExpression,
       makeRef,
@@ -3730,6 +3761,7 @@ var require_parser = __commonJS({
       NestedTopLevelStatements,
       TopLevelSingleLineStatements,
       TopLevelStatement,
+      ExtendedCommaExpression,
       ExtendedExpression,
       SingleLineExtendedExpression,
       NonPipelineExtendedExpression,
@@ -3738,7 +3770,7 @@ var require_parser = __commonJS({
       ExpressionizedStatementWithTrailingCallExpressions,
       ExpressionizedStatement,
       _ExpressionizedStatement,
-      Expression,
+      CommaExpression,
       Arguments,
       ImplicitArguments,
       ExplicitArguments,
@@ -3883,15 +3915,18 @@ var require_parser = __commonJS({
       BareBlock,
       ThenClause,
       BracedOrEmptyBlock,
+      NoCommaBracedOrEmptyBlock,
       NoPostfixBracedOrEmptyBlock,
       EmptyBlock,
       EmptyBareBlock,
       BracedBlock,
       NoPostfixBracedBlock,
+      NoCommaBracedBlock,
       NonSingleBracedBlock,
       DeclarationOrStatement,
       SingleLineStatements,
       PostfixedSingleLineStatements,
+      PostfixedSingleLineNoCommaStatements,
       BracedContent,
       NestedBlockStatements,
       NestedBlockStatement,
@@ -3959,11 +3994,15 @@ var require_parser = __commonJS({
       ModuleItem,
       StatementListItem,
       PostfixedStatement,
+      NoCommaStatementListItem,
+      PostfixedNoCommaStatement,
       PostfixedExpression,
+      PostfixedCommaExpression,
       NonPipelinePostfixedExpression,
       PostfixStatement,
       _PostfixStatement,
       Statement,
+      NoCommaStatement,
       EmptyStatement,
       BlockStatement,
       LabelledStatement,
@@ -4047,6 +4086,7 @@ var require_parser = __commonJS({
       NewlineBinaryOpAllowed,
       AllowAll,
       RestoreAll,
+      CommaExpressionStatement,
       ExpressionStatement,
       KeywordStatement,
       DebuggerStatement,
@@ -4783,6 +4823,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];
@@ -4861,13 +4907,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) {
@@ -5276,7 +5322,7 @@ var require_parser = __commonJS({
       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$$);
@@ -5388,7 +5434,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;
@@ -6782,7 +6828,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;
@@ -6924,6 +6970,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];
@@ -6993,6 +7045,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;
@@ -7060,6 +7131,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) {
@@ -8454,6 +8541,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;
@@ -8464,6 +8567,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;
@@ -8497,17 +8613,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 || [] };
     });
@@ -8986,14 +9111,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,
@@ -9569,8 +9694,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$$);
@@ -12204,7 +12339,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$$);
@@ -13093,6 +13228,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;
@@ -13101,7 +13237,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;
@@ -13246,15 +13382,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;
@@ -13322,11 +13461,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;
@@ -13410,6 +13553,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;
@@ -13799,6 +13943,7 @@ var require_parser = __commonJS({
       lastAccessInCallExpression,
       literalValue,
       makeEmptyBlock,
+      makeExpressionStatement,
       makeGetterMethod,
       makeLeftHandSideExpression,
       makeRef,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielx/civet",
   "type": "commonjs",
-  "version": "0.6.48",
+  "version": "0.6.50",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",