@danielx/civet 0.5.61 → 0.5.62

package/dist/main.js

@@ -563,10 +563,14 @@ ${input.slice(result.pos)}
       Block,
       ThenClause,
       BracedOrEmptyBlock,
+      NoPostfixBracedOrEmptyBlock,
       EmptyBlock,
       EmptyBareBlock,
       BracedBlock,
+      NoPostfixBracedBlock,
+      NonSingleBracedBlock,
       SingleLineStatements,
+      PostfixedSingleLineStatements,
       BracedContent,
       NestedBlockStatements,
       NestedBlockStatement,
@@ -622,6 +626,8 @@ ${input.slice(result.pos)}
       UnaryOp,
       ModuleItem,
       StatementListItem,
+      PostfixedStatement,
+      PostfixedExpression,
       PostfixStatement,
       Statement,
       EmptyStatement,
@@ -1170,7 +1176,7 @@ ${input.slice(result.pos)}
     var $L170 = $L("infer");
     var $L171 = $L("[]");
     var $L172 = $L("civet");
-    var $R0 = $R(new RegExp("(as|for|of|satisfies|then|when|implements)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
+    var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
     var $R1 = $R(new RegExp("[0-9]", "suy"));
     var $R2 = $R(new RegExp("[&]", "suy"));
     var $R3 = $R(new RegExp("[!~+-]+", "suy"));
@@ -1551,7 +1557,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|of|satisfies|then|when|implements)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
+    var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
     var ForbiddenImplicitCalls$1 = $EXPECT($L0, fail, 'ForbiddenImplicitCalls "/ "');
     var ForbiddenImplicitCalls$2 = AtAt;
     var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L1, fail, 'ForbiddenImplicitCalls "="'), Whitespace);
@@ -2346,10 +2352,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var FatArrowBody$0 = ExplicitBlock;
-    var FatArrowBody$1 = ImplicitNestedBlock;
-    var FatArrowBody$2 = AssignmentExpression;
-    var FatArrowBody$3 = EmptyBlock;
+    var FatArrowBody$0 = $T($S($N(EOS), PostfixedExpression, $N(SemicolonDelimiter)), function(value) {
+      var exp = value[1];
+      return exp;
+    });
+    var FatArrowBody$1 = BracedOrEmptyBlock;
     function FatArrowBody(state) {
       let eventData;
       if (state.events) {
@@ -2361,12 +2368,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("FatArrowBody", state, FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state));
+        const result = $TOKEN("FatArrowBody", state, FatArrowBody$0(state) || FatArrowBody$1(state));
         if (state.events)
           state.events.exit?.("FatArrowBody", state, result, eventData);
         return result;
       } else {
-        const result = FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state);
+        const result = FatArrowBody$0(state) || FatArrowBody$1(state);
         if (state.events)
           state.events.exit?.("FatArrowBody", state, result, eventData);
         return result;
@@ -2607,11 +2614,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ParenthesizedExpression$0 = $TS($S(OpenParen, ExtendedExpression, $E($S($Q(TrailingComment), PostfixStatement)), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var ParenthesizedExpression$0 = $TS($S(OpenParen, PostfixedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
       var exp = $2;
-      var post = $3;
-      if (post) {
-        return module2.attachPostfixStatementAsExpression(exp, post);
+      switch (exp.type) {
+        case "IterationExpression":
+          return $2;
       }
       return {
         type: "ParenthesizedExpression",
@@ -3273,7 +3280,12 @@ ${input.slice(result.pos)}
       }
     }
     var CallExpressionRest$0 = MemberExpressionRest;
-    var CallExpressionRest$1 = TemplateLiteral;
+    var CallExpressionRest$1 = $TV($C(TemplateLiteral, StringLiteral), function($skip, $loc, $0, $1) {
+      if ($1.type === "StringLiteral") {
+        return "`" + $1.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
+      }
+      return $1;
+    });
     var CallExpressionRest$2 = $TS($S($E($C(OptionalShorthand, NonNullAssertion)), ArgumentsWithTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
       if (!$1)
         return $2;
@@ -3421,7 +3433,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var MemberBracketContent$0 = $TS($S(OpenBracket, $C(SliceParameters, ExtendedExpression), __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var MemberBracketContent$0 = $TS($S(OpenBracket, $C(SliceParameters, PostfixedExpression), __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
       var open = $1;
       var exp = $2;
       var ws = $3;
@@ -3610,7 +3622,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var SuperProperty$0 = $S($EXPECT($L16, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
+    var SuperProperty$0 = $S($EXPECT($L16, fail, 'SuperProperty "super["'), PostfixedExpression, __, CloseBracket);
     var SuperProperty$1 = $S($EXPECT($L12, fail, 'SuperProperty "super"'), $N($C(QuestionMark, NonNullAssertion)), PropertyAccess);
     function SuperProperty(state) {
       let eventData;
@@ -5031,7 +5043,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var FunctionDeclaration$0 = FunctionExpression;
+    var FunctionDeclaration$0 = $TS($S(FunctionExpression), function($skip, $loc, $0, $1) {
+      if ($1.id)
+        return $1;
+      return module2.makeLeftHandSideExpression($1);
+    });
     function FunctionDeclaration(state) {
       let eventData;
       if (state.events) {
@@ -5545,6 +5561,30 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var NoPostfixBracedOrEmptyBlock$0 = NoPostfixBracedBlock;
+    var NoPostfixBracedOrEmptyBlock$1 = EmptyBlock;
+    function NoPostfixBracedOrEmptyBlock(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NoPostfixBracedOrEmptyBlock", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NoPostfixBracedOrEmptyBlock", state, NoPostfixBracedOrEmptyBlock$0(state) || NoPostfixBracedOrEmptyBlock$1(state));
+        if (state.events)
+          state.events.exit?.("NoPostfixBracedOrEmptyBlock", state, result, eventData);
+        return result;
+      } else {
+        const result = NoPostfixBracedOrEmptyBlock$0(state) || NoPostfixBracedOrEmptyBlock$1(state);
+        if (state.events)
+          state.events.exit?.("NoPostfixBracedOrEmptyBlock", state, result, eventData);
+        return result;
+      }
+    }
     var EmptyBlock$0 = $TS($S(InsertOpenBrace, InsertCloseBrace), function($skip, $loc, $0, $1, $2) {
       const expressions = [];
       return {
@@ -5608,26 +5648,44 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var BracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, BracedContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-      var block = $3;
-      return {
-        type: "BlockStatement",
-        expressions: block.expressions,
-        children: [$1, $2, ...block.children, $4, $5],
-        bare: false
-      };
-      return block;
-    });
-    var BracedBlock$1 = ImplicitNestedBlock;
-    var BracedBlock$2 = $TS($S(InsertOpenBrace, $Y(EOS), ObjectLiteral, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var BracedBlock$0 = NonSingleBracedBlock;
+    var BracedBlock$1 = $TS($S(InsertOpenBrace, $N(EOS), PostfixedSingleLineStatements, 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],
-        children: [$1, s, $3]
+        expressions: s.expressions,
+        children: [o, s.children, ws, c]
       };
     });
-    var BracedBlock$3 = $TS($S(InsertOpenBrace, $N(EOS), SingleLineStatements, InsertSpace, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    function BracedBlock(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("BracedBlock", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("BracedBlock", state, BracedBlock$0(state) || BracedBlock$1(state));
+        if (state.events)
+          state.events.exit?.("BracedBlock", state, result, eventData);
+        return result;
+      } else {
+        const result = BracedBlock$0(state) || BracedBlock$1(state);
+        if (state.events)
+          state.events.exit?.("BracedBlock", state, result, eventData);
+        return result;
+      }
+    }
+    var NoPostfixBracedBlock$0 = NonSingleBracedBlock;
+    var NoPostfixBracedBlock$1 = $TS($S(InsertOpenBrace, $N(EOS), SingleLineStatements, InsertSpace, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var o = $1;
       var s = $3;
       var ws = $4;
@@ -5640,10 +5698,10 @@ ${input.slice(result.pos)}
         children: [o, s.children, ws, c]
       };
     });
-    function BracedBlock(state) {
+    function NoPostfixBracedBlock(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("BracedBlock", state);
+        const result = state.events.enter?.("NoPostfixBracedBlock", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -5651,14 +5709,55 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("BracedBlock", state, BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state) || BracedBlock$3(state));
+        const result = $TOKEN("NoPostfixBracedBlock", state, NoPostfixBracedBlock$0(state) || NoPostfixBracedBlock$1(state));
         if (state.events)
-          state.events.exit?.("BracedBlock", state, result, eventData);
+          state.events.exit?.("NoPostfixBracedBlock", state, result, eventData);
         return result;
       } else {
-        const result = BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state) || BracedBlock$3(state);
+        const result = NoPostfixBracedBlock$0(state) || NoPostfixBracedBlock$1(state);
         if (state.events)
-          state.events.exit?.("BracedBlock", state, result, eventData);
+          state.events.exit?.("NoPostfixBracedBlock", state, result, eventData);
+        return result;
+      }
+    }
+    var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, BracedContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var block = $3;
+      return {
+        type: "BlockStatement",
+        expressions: block.expressions,
+        children: [$1, $2, ...block.children, $4, $5],
+        bare: false
+      };
+      return block;
+    });
+    var NonSingleBracedBlock$1 = ImplicitNestedBlock;
+    var NonSingleBracedBlock$2 = $TS($S(InsertOpenBrace, $Y(EOS), ObjectLiteral, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var s = $3;
+      return {
+        type: "BlockStatement",
+        expressions: [s],
+        children: [$1, s, $3]
+      };
+    });
+    function NonSingleBracedBlock(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NonSingleBracedBlock", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NonSingleBracedBlock", state, NonSingleBracedBlock$0(state) || NonSingleBracedBlock$1(state) || NonSingleBracedBlock$2(state));
+        if (state.events)
+          state.events.exit?.("NonSingleBracedBlock", state, result, eventData);
+        return result;
+      } else {
+        const result = NonSingleBracedBlock$0(state) || NonSingleBracedBlock$1(state) || NonSingleBracedBlock$2(state);
+        if (state.events)
+          state.events.exit?.("NonSingleBracedBlock", state, result, eventData);
         return result;
       }
     }
@@ -5697,6 +5796,41 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var PostfixedSingleLineStatements$0 = $TS($S($Q($S($S($E(_), $N(EOS)), PostfixedStatement, SemicolonDelimiter)), $E($S($S($E(_), $N(EOS)), PostfixedStatement, $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 PostfixedSingleLineStatements(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("PostfixedSingleLineStatements", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("PostfixedSingleLineStatements", state, PostfixedSingleLineStatements$0(state));
+        if (state.events)
+          state.events.exit?.("PostfixedSingleLineStatements", state, result, eventData);
+        return result;
+      } else {
+        const result = PostfixedSingleLineStatements$0(state);
+        if (state.events)
+          state.events.exit?.("PostfixedSingleLineStatements", state, result, eventData);
+        return result;
+      }
+    }
     var BracedContent$0 = NestedBlockStatements;
     var BracedContent$1 = $TS($S($Q(TrailingComment), Statement), function($skip, $loc, $0, $1, $2) {
       const expressions = [["", $2]];
@@ -6997,7 +7131,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ComputedPropertyName$0 = $TS($S(OpenBracket, ExtendedExpression, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var ComputedPropertyName$0 = $TS($S(OpenBracket, PostfixedExpression, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
       var expression = $2;
       return {
         type: "ComputedPropertyName",
@@ -7541,7 +7675,12 @@ ${input.slice(result.pos)}
       return "??";
     });
     var BinaryOpSymbol$28 = $TS($S($EXPECT($L75, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-      return $1;
+      return {
+        $loc,
+        token: $1,
+        relational: true,
+        special: true
+      };
     });
     var BinaryOpSymbol$29 = $TS($S($EXPECT($L50, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L75, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       return {
@@ -7699,13 +7838,7 @@ ${input.slice(result.pos)}
       }
     }
     var StatementListItem$0 = Declaration;
-    var StatementListItem$1 = $TS($S(Statement, $E($S($Q(TrailingComment), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
-      var statement = $1;
-      var post = $2;
-      if (post)
-        return module2.addPostfixStatement(statement, ...post);
-      return statement;
-    });
+    var StatementListItem$1 = PostfixedStatement;
     function StatementListItem(state) {
       let eventData;
       if (state.events) {
@@ -7728,6 +7861,64 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var PostfixedStatement$0 = $TS($S(Statement, $E($S($Q(TrailingComment), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
+      var statement = $1;
+      var post = $2;
+      if (post)
+        return module2.addPostfixStatement(statement, ...post);
+      return statement;
+    });
+    function PostfixedStatement(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("PostfixedStatement", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("PostfixedStatement", state, PostfixedStatement$0(state));
+        if (state.events)
+          state.events.exit?.("PostfixedStatement", state, result, eventData);
+        return result;
+      } else {
+        const result = PostfixedStatement$0(state);
+        if (state.events)
+          state.events.exit?.("PostfixedStatement", state, result, eventData);
+        return result;
+      }
+    }
+    var PostfixedExpression$0 = $TS($S(ExtendedExpression, $E($S($Q(TrailingComment), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
+      var expression = $1;
+      var post = $2;
+      if (post)
+        return module2.attachPostfixStatementAsExpression(expression, post);
+      return expression;
+    });
+    function PostfixedExpression(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("PostfixedExpression", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("PostfixedExpression", state, PostfixedExpression$0(state));
+        if (state.events)
+          state.events.exit?.("PostfixedExpression", state, result, eventData);
+        return result;
+      } else {
+        const result = PostfixedExpression$0(state);
+        if (state.events)
+          state.events.exit?.("PostfixedExpression", state, result, eventData);
+        return result;
+      }
+    }
     var PostfixStatement$0 = ForClause;
     var PostfixStatement$1 = IfClause;
     var PostfixStatement$2 = LoopClause;
@@ -7763,12 +7954,8 @@ ${input.slice(result.pos)}
     var Statement$5 = TryStatement;
     var Statement$6 = EmptyStatement;
     var Statement$7 = $TS($S(ExpressionStatement), function($skip, $loc, $0, $1) {
-      if ($1.type === "ObjectExpression") {
-        return {
-          type: "ParenthesizedExpression",
-          children: ["(", $1, ")"],
-          expression: $1
-        };
+      if ($1.type === "ObjectExpression" || $1.type === "FunctionExpression" && !$1.id) {
+        return module2.makeLeftHandSideExpression($1);
       }
       return $1;
     });
@@ -7856,6 +8043,8 @@ ${input.slice(result.pos)}
         children.push(e);
       return {
         type: "IfStatement",
+        then: block,
+        else: e,
         children
       };
     });
@@ -7933,7 +8122,7 @@ ${input.slice(result.pos)}
     var UnlessClause$0 = $TS($S(Unless, Condition), function($skip, $loc, $0, $1, $2) {
       var kind = $1;
       var condition = $2;
-      kind.token = "if";
+      kind = { ...kind, token: "if" };
       return {
         type: "IfStatement",
         children: [kind, ["(!", condition, ")"]]
@@ -8162,16 +8351,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var NestedBlockExpression$0 = $TS($S(Nested, ExtendedExpression, $E($S($Q(TrailingComment), PostfixStatement)), ExpressionDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
-      var ws = $1;
-      var exp = $2;
-      var post = $3;
-      var d = $4;
-      if (post) {
-        return [ws, module2.attachPostfixStatementAsExpression(exp, post), d];
-      }
-      return [ws, exp, d];
-    });
+    var NestedBlockExpression$0 = $S(Nested, PostfixedExpression, ExpressionDelimiter);
     function NestedBlockExpression(state) {
       let eventData;
       if (state.events) {
@@ -8307,7 +8487,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var DoWhileStatement$0 = $T($S(Do, BracedBlock, __, WhileClause), function(value) {
+    var DoWhileStatement$0 = $T($S(Do, NoPostfixBracedBlock, __, WhileClause), function(value) {
       var block = value[1];
       return { "type": "IterationStatement", "children": value, "block": block };
     });
@@ -8475,9 +8655,11 @@ ${input.slice(result.pos)}
     var ForStatementControl$1 = $TS($S(CoffeeForLoopsEnabled, CoffeeForStatementParameters, $E(WhenCondition)), function($skip, $loc, $0, $1, $2, $3) {
       if ($3) {
         const indent = module2.currentIndent.token + "  ";
+        const block = "continue\n";
         $2.blockPrefix.push([indent, {
           type: "IfStatement",
-          children: ["if (!(", module2.insertTrimmingSpace($3, ""), ")) continue\n"]
+          then: block,
+          children: ["if (!(", module2.insertTrimmingSpace($3, ""), ")) ", block]
         }]);
       }
       return $2;
@@ -9261,7 +9443,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TryStatement$0 = $TS($S(Try, BracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var TryStatement$0 = $TS($S(Try, NoPostfixBracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4) {
       var t = $1;
       var b = $2;
       var c = $3;
@@ -10757,7 +10939,7 @@ ${input.slice(result.pos)}
       }
     }
     var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
-      return { $loc, token: $1 };
+      return { type: "NumericLiteral", $loc, token: $1 };
     });
     function NumericLiteral(state) {
       let eventData;
@@ -11028,6 +11210,7 @@ ${input.slice(result.pos)}
     var StringLiteral$0 = $TS($S(DoubleQuote, DoubleStringCharacters, DoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
       var str = $2;
       return {
+        type: "StringLiteral",
         token: `"${module2.modifyString(str.token)}"`,
         $loc
       };
@@ -11035,6 +11218,7 @@ ${input.slice(result.pos)}
     var StringLiteral$1 = $TS($S(SingleQuote, SingleStringCharacters, SingleQuote), function($skip, $loc, $0, $1, $2, $3) {
       var str = $2;
       return {
+        type: "StringLiteral",
         token: `'${module2.modifyString(str.token)}'`,
         $loc
       };
@@ -11161,7 +11345,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var CoffeeStringSubstitution$0 = $S(CoffeeSubstitutionStart, ExtendedExpression, __, CloseBrace);
+    var CoffeeStringSubstitution$0 = $S(CoffeeSubstitutionStart, PostfixedExpression, __, CloseBrace);
     function CoffeeStringSubstitution(state) {
       let eventData;
       if (state.events) {
@@ -11601,7 +11785,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TemplateSubstitution$0 = $S(SubstitutionStart, ExtendedExpression, __, CloseBrace);
+    var TemplateSubstitution$0 = $S(SubstitutionStart, PostfixedExpression, __, CloseBrace);
     function TemplateSubstitution(state) {
       let eventData;
       if (state.events) {
@@ -12148,7 +12332,7 @@ ${input.slice(result.pos)}
       }
     }
     var StatementDelimiter$0 = SemicolonDelimiter;
-    var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L92, fail, 'StatementDelimiter "["'), $EXPECT($L93, fail, 'StatementDelimiter "`"'), $EXPECT($L56, fail, 'StatementDelimiter "+"'), $EXPECT($L15, fail, 'StatementDelimiter "-"'), $EXPECT($L52, fail, 'StatementDelimiter "*"'), $EXPECT($L53, fail, 'StatementDelimiter "/"'), ObjectLiteral))), InsertSemicolon);
+    var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L92, fail, 'StatementDelimiter "["'), $EXPECT($L93, fail, 'StatementDelimiter "`"'), $EXPECT($L56, fail, 'StatementDelimiter "+"'), $EXPECT($L15, fail, 'StatementDelimiter "-"'), $EXPECT($L52, fail, 'StatementDelimiter "*"'), $EXPECT($L53, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
     var StatementDelimiter$2 = $Y(EOS);
     function StatementDelimiter(state) {
       let eventData;
@@ -14916,7 +15100,7 @@ ${input.slice(result.pos)}
       return ["{", $1, "}"];
     });
     var JSXShorthandString$2 = StringLiteral;
-    var JSXShorthandString$3 = $S(OpenBrace, ExtendedExpression, $E(Whitespace), CloseBrace);
+    var JSXShorthandString$3 = $S(OpenBrace, PostfixedExpression, $E(Whitespace), CloseBrace);
     function JSXShorthandString(state) {
       let eventData;
       if (state.events) {
@@ -14986,7 +15170,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var JSXAttributeValue$0 = $S(OpenBrace, ExtendedExpression, $E(Whitespace), CloseBrace);
+    var JSXAttributeValue$0 = $S(OpenBrace, PostfixedExpression, $E(Whitespace), CloseBrace);
     var JSXAttributeValue$1 = JSXElement;
     var JSXAttributeValue$2 = JSXFragment;
     var JSXAttributeValue$3 = $TS($S(InsertInlineOpenBrace, InlineJSXAttributeValue, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3) {
@@ -15177,7 +15361,7 @@ ${input.slice(result.pos)}
       }
     }
     var InlineJSXCallExpression$0 = $S($EXPECT($L12, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments);
-    var InlineJSXCallExpression$1 = $S($EXPECT($L13, fail, 'InlineJSXCallExpression "import"'), OpenParen, ExtendedExpression, __, CloseParen);
+    var InlineJSXCallExpression$1 = $S($EXPECT($L13, fail, 'InlineJSXCallExpression "import"'), OpenParen, PostfixedExpression, __, CloseParen);
     var InlineJSXCallExpression$2 = $TS($S(InlineJSXMemberExpression, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2) {
       if ($2.length)
         return $0;
@@ -15599,7 +15783,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var JSXChildExpression$0 = $S($E(Whitespace), $E($S(DotDotDot, $E(Whitespace))), ExtendedExpression);
+    var JSXChildExpression$0 = $S($E(Whitespace), $E($S(DotDotDot, $E(Whitespace))), PostfixedExpression);
     function JSXChildExpression(state) {
       let eventData;
       if (state.events) {
@@ -18416,10 +18600,11 @@ ${input.slice(result.pos)}
         children.push(block);
         if (!module2.isWhitespaceOrEmpty(ws))
           children.push(ws);
-        return Object.assign({}, post, {
-          children,
-          block
-        });
+        post = { ...post, children, block };
+        if (post.type === "IfStatement") {
+          post.then = block;
+        }
+        return post;
       };
       function expressionizeIteration(exp) {
         const resultsRef = {
@@ -18492,9 +18677,9 @@ ${input.slice(result.pos)}
             insertPush(exp.expressions[exp.expressions.length - 1], ref);
             return;
           case "IfStatement":
-            insertPush(exp.children[2], ref);
-            if (exp.children[3])
-              insertPush(exp.children[3][2], ref);
+            insertPush(exp.then, ref);
+            if (exp.else)
+              insertPush(exp.else[2], ref);
             else
               exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
             return;
@@ -18550,7 +18735,9 @@ ${input.slice(result.pos)}
         }
         if (!Array.isArray(node))
           return;
-        const [, exp] = node;
+        const [, exp, semi] = node;
+        if (semi?.type === "SemicolonDelimiter")
+          return;
         let indent = node[0];
         if (Array.isArray(indent))
           indent = indent[indent.length - 1];
@@ -18573,9 +18760,9 @@ ${input.slice(result.pos)}
             insertReturn(exp.expressions[exp.expressions.length - 1]);
             return;
           case "IfStatement":
-            insertReturn(exp.children[2]);
-            if (exp.children[3])
-              insertReturn(exp.children[3][2]);
+            insertReturn(exp.then);
+            if (exp.else)
+              insertReturn(exp.else[2]);
             else
               exp.children.push(["\n", indent, wrapWithReturn()]);
             return;
@@ -18636,6 +18823,14 @@ ${input.slice(result.pos)}
           const op = expandedOps[i];
           if (op.special) {
             let [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
+            if (op2.token === "instanceof" && b.type === "Literal" && b.children?.[0]?.type === "StringLiteral") {
+              a = ["typeof ", module2.makeLeftHandSideExpression(a)];
+              if (op2.negated) {
+                op2 = { ...op2, token: "!==", negated: false };
+              } else {
+                op2 = { ...op2, token: "===" };
+              }
+            }
             if (op2.asConst) {
               a = module2.makeAsConst(a);
               b = module2.makeAsConst(b);
@@ -18676,7 +18871,7 @@ ${input.slice(result.pos)}
         return expandedOps;
       };
       module2.expandChainedComparisons = function([first, binops]) {
-        const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
+        const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"];
         const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
         let results = [];
         let i = 0;
@@ -19237,7 +19432,7 @@ ${input.slice(result.pos)}
                       break;
                     case "Literal":
                     case "StringLiteral":
-                    case void 0:
+                    case "NumericLiteral":
                       conditions.push([name, " in ", ref]);
                       subRef = [ref, "[", name, "]"];
                       break;
@@ -19300,7 +19495,8 @@ ${input.slice(result.pos)}
                   switch (name.type) {
                     case "ComputedPropertyName":
                     case "Literal":
-                    case void 0:
+                    case "StringLiteral":
+                    case "NumericLiteral":
                       return {
                         ...p,
                         children: [ws, name, ": ", match, sep]
@@ -19423,7 +19619,9 @@ ${input.slice(result.pos)}
             const e = i < l - 1 ? ["\nelse "] : [];
             prev.push({
               type: "IfStatement",
-              children: ["if", condition, block, ...e, next]
+              children: ["if", condition, block, ...e, next],
+              then: block,
+              else: e
             });
             prev = next;
           });
@@ -20340,7 +20538,7 @@ var parse;
 var uncacheable;
 ({ parse } = import_parser.default);
 ({ SourceMap: SourceMap2, base64Encode: base64Encode2 } = util_exports);
-uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationSuppressed", "ExtendedExpression", "FatArrowBody", "FunctionDeclaration", "FunctionExpression", "HoistableDeclaration", "ImplicitArguments", "ImplicitInlineObjectPropertyDelimiter", "ImplicitNestedBlock", "IndentedApplicationAllowed", "IndentedFurther", "IndentedJSXChildExpression", "InlineObjectLiteral", "InsertIndent", "JSXChild", "JSXChildren", "JSXElement", "JSXFragment", "JSXImplicitFragment", "JSXMixedChildren", "JSXNested", "JSXNestedChildren", "JSXOptionalClosingElement", "JSXOptionalClosingFragment", "JSXTag", "LeftHandSideExpression", "MemberExpression", "MemberExpressionRest", "Nested", "NestedBindingElement", "NestedBindingElements", "NestedBlockExpression", "NestedBlockExpression", "NestedBlockStatement", "NestedBlockStatements", "NestedElement", "NestedElementList", "NestedImplicitObjectLiteral", "NestedImplicitPropertyDefinition", "NestedImplicitPropertyDefinitions", "NestedInterfaceProperty", "NestedJSXChildExpression", "NestedObject", "NestedPropertyDefinitions", "NonSuppressedTrailingMemberExpressions", "ObjectLiteral", "PopIndent", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "RHS", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuppressIndentedApplication", "SuppressTrailingMemberProperty", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
+uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationSuppressed", "ExtendedExpression", "FatArrowBody", "FunctionDeclaration", "FunctionExpression", "HoistableDeclaration", "ImplicitArguments", "ImplicitInlineObjectPropertyDelimiter", "ImplicitNestedBlock", "IndentedApplicationAllowed", "IndentedFurther", "IndentedJSXChildExpression", "InlineObjectLiteral", "InsertIndent", "JSXChild", "JSXChildren", "JSXElement", "JSXFragment", "JSXImplicitFragment", "JSXMixedChildren", "JSXNested", "JSXNestedChildren", "JSXOptionalClosingElement", "JSXOptionalClosingFragment", "JSXTag", "LeftHandSideExpression", "MemberExpression", "MemberExpressionRest", "Nested", "NestedBindingElement", "NestedBindingElements", "NestedBlockExpression", "NestedBlockExpression", "NestedBlockStatement", "NestedBlockStatements", "NestedElement", "NestedElementList", "NestedImplicitObjectLiteral", "NestedImplicitPropertyDefinition", "NestedImplicitPropertyDefinitions", "NestedInterfaceProperty", "NestedJSXChildExpression", "NestedObject", "NestedPropertyDefinitions", "NonSingleBracedBlock", "NonSuppressedTrailingMemberExpressions", "ObjectLiteral", "PopIndent", "PostfixedExpression", "PostfixedStatement", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "RHS", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuffixedExpression", "SuffixedStatement", "SuppressIndentedApplication", "SuppressTrailingMemberProperty", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
 var compile = function(src, options) {
   var ast, code, events, filename, ref, result, sm, srcMapJSON;
   if (!options) {