@danielx/civet 0.6.49 → 0.6.51

package/dist/browser.js

@@ -2059,6 +2059,20 @@ ${input.slice(result.pos)}
           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");
       }
@@ -3692,6 +3706,7 @@ ${input.slice(result.pos)}
         literalValue,
         makeAsConst,
         makeEmptyBlock,
+        makeExpressionStatement,
         makeGetterMethod,
         makeLeftHandSideExpression,
         makeRef,
@@ -3756,6 +3771,7 @@ ${input.slice(result.pos)}
         NestedTopLevelStatements,
         TopLevelSingleLineStatements,
         TopLevelStatement,
+        ExtendedCommaExpression,
         ExtendedExpression,
         SingleLineExtendedExpression,
         NonPipelineExtendedExpression,
@@ -3764,7 +3780,7 @@ ${input.slice(result.pos)}
         ExpressionizedStatementWithTrailingCallExpressions,
         ExpressionizedStatement,
         _ExpressionizedStatement,
-        Expression,
+        CommaExpression,
         Arguments,
         ImplicitArguments,
         ExplicitArguments,
@@ -3909,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,
@@ -3985,11 +4004,15 @@ ${input.slice(result.pos)}
         ModuleItem,
         StatementListItem,
         PostfixedStatement,
+        NoCommaStatementListItem,
+        PostfixedNoCommaStatement,
         PostfixedExpression,
+        PostfixedCommaExpression,
         NonPipelinePostfixedExpression,
         PostfixStatement,
         _PostfixStatement,
         Statement,
+        NoCommaStatement,
         EmptyStatement,
         BlockStatement,
         LabelledStatement,
@@ -4073,6 +4096,7 @@ ${input.slice(result.pos)}
         NewlineBinaryOpAllowed,
         AllowAll,
         RestoreAll,
+        CommaExpressionStatement,
         ExpressionStatement,
         KeywordStatement,
         DebuggerStatement,
@@ -4809,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];
@@ -4887,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) {
@@ -5298,11 +5328,14 @@ ${input.slice(result.pos)}
       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$$);
@@ -5414,7 +5447,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;
@@ -6808,7 +6841,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;
@@ -6950,6 +6983,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];
@@ -7019,6 +7058,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;
@@ -7086,6 +7144,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) {
@@ -8480,6 +8554,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;
@@ -8490,6 +8580,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;
@@ -8523,17 +8626,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 || [] };
       });
@@ -9012,14 +9124,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,
@@ -9595,8 +9707,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$$);
@@ -12230,7 +12352,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$$);
@@ -12879,19 +13001,45 @@ ${input.slice(result.pos)}
             };
             module.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
           },
+          Falsy(FalsyRef) {
+            module.prelude.push(["", [{
+              ts: true,
+              children: ["type ", FalsyRef, " = false | 0 | '' | 0n | null | undefined;", "\n"]
+            }]]);
+          },
           xor(xorRef) {
+            const Falsy = module.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))"
+              ]
             };
-            module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
+            module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => (a ? !b && a : b)", asAny, ";", "\n"]]);
           },
           xnor(xnorRef) {
+            const Falsy = module.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))"
+              ]
             };
-            module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
+            module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => (a ? b : !b || a)", asAny, ";", "\n"]]);
           },
           returnSymbol(ref) {
             module.prelude.push({
@@ -13119,6 +13267,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;
@@ -13127,7 +13276,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;
@@ -13272,15 +13421,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;
@@ -13348,11 +13500,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;
@@ -13436,6 +13592,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;
@@ -13825,6 +13982,7 @@ ${input.slice(result.pos)}
         lastAccessInCallExpression,
         literalValue,
         makeEmptyBlock,
+        makeExpressionStatement,
         makeGetterMethod,
         makeLeftHandSideExpression,
         makeRef,

package/dist/esbuild.js

@@ -42,14 +42,46 @@ var fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_typescript = __toESM(require("typescript"));
 var tsvfs = __toESM(require("@typescript/vfs"));
+var import_os = __toESM(require("os"));
 var formatHost = {
   getCurrentDirectory: () => import_typescript.default.sys.getCurrentDirectory(),
   getNewLine: () => import_typescript.default.sys.newLine,
   getCanonicalFileName: import_typescript.default.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
 };
 var isCivet = (id) => /\.civet$/.test(id);
-var isCivetTranspiled = (id) => /\.civet\.(m?)(j|t)s(x?)(\?transform)?$/.test(id);
-var isCivetTranspiledTS = (id) => /\.civet\.(m?)ts(x?)$/.test(id);
+var isCivetTranspiled = (id) => /\.civet\.[jt]sx(\?transform)?$/.test(id);
+var isCivetTranspiledTS = (id) => /\.civet\.tsx$/.test(id);
+var postfixRE = /(\.[jt]sx)?[?#].*$/s;
+var isWindows = import_os.default.platform() === "win32";
+var windowsSlashRE = /\\/g;
+function cleanCivetId(id) {
+  return id.replace(postfixRE, "");
+}
+function tryStatSync(file) {
+  try {
+    return fs.statSync(file, { throwIfNoEntry: false });
+  } catch {
+    return void 0;
+  }
+}
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+function normalizePath(id) {
+  return import_path.default.posix.normalize(isWindows ? slash(id) : id);
+}
+function tryFsResolve(file) {
+  const fileStat = tryStatSync(file);
+  if (fileStat?.isFile())
+    return normalizePath(file);
+  return void 0;
+}
+function resolveAbsolutePath(rootDir, id) {
+  const resolved = tryFsResolve(import_path.default.join(rootDir, id));
+  if (!resolved)
+    return tryFsResolve(id);
+  return resolved;
+}
 var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
   if (options.dts && options.js) {
     throw new Error("Can't have both `dts` and `js` be set to `true`.");
@@ -62,7 +94,7 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
   let fsMap = /* @__PURE__ */ new Map();
   const sourceMaps = /* @__PURE__ */ new Map();
   let compilerOptions;
-  let rootDir;
+  let rootDir = process.cwd();
   return {
     name: "unplugin-civet",
     enforce: "pre",
@@ -162,10 +194,11 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
         return null;
       if (!isCivet(id) && !isCivetTranspiled(id))
         return null;
-      const absolutePath = rootDir != null && import_path.default.isAbsolute(id) ? import_path.default.join(rootDir, id) : import_path.default.resolve(import_path.default.dirname(importer ?? ""), id);
+      id = cleanCivetId(id);
+      const absolutePath = import_path.default.isAbsolute(id) ? resolveAbsolutePath(rootDir, id) : import_path.default.resolve(import_path.default.dirname(importer ?? ""), id);
+      if (!absolutePath)
+        return null;
       const relativeId = import_path.default.relative(process.cwd(), absolutePath);
-      if (isCivetTranspiled(id))
-        return relativeId.replace(/\?transform$/, "");
       const relativePath = relativeId + outExt;
       return relativePath;
     },
@@ -206,9 +239,9 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
       if (options.dts || options.typecheck) {
         const resolved = import_path.default.resolve(process.cwd(), id);
         fsMap.set(resolved, code);
-        const slash = resolved.replace(/\\/g, "/");
-        if (resolved !== slash)
-          fsMap.set(slash, code);
+        const slashed = slash(resolved);
+        if (resolved !== slashed)
+          fsMap.set(slashed, code);
       }
       return null;
     },