@danielx/civet 0.5.88 → 0.5.90

package/dist/browser.js

@@ -44,7 +44,7 @@ var Civet = (() => {
             children: block.children === block.expressions ? expressions : block.children.map((c) => c === block.expressions ? expressions : c)
           };
           if (block.bare) {
-            block.children = [[" {\n", indent], ...block.children, "}"];
+            block.children = [[" {"], ...block.children, "}"];
             block.bare = false;
           }
         }
@@ -152,8 +152,16 @@ var Civet = (() => {
       }
       function getIndent(statement) {
         let indent = statement?.[0];
-        if (Array.isArray(indent))
-          indent = indent[indent.length - 1];
+        if (Array.isArray(indent)) {
+          indent = indent.flat(Infinity);
+          return indent.filter((n) => n && !(n.type === "Comment")).map((n) => {
+            if (typeof n === "string")
+              return n;
+            if (n.token != null)
+              return n.token;
+            return "";
+          });
+        }
         return indent;
       }
       function hasAwait(exp) {
@@ -319,7 +327,7 @@ var Civet = (() => {
             varLet = [",", ...varName, " = ", counterRef];
           } else {
             blockPrefix = [
-              ["", forDeclaration, " = ", counterRef, ";\n"]
+              ["", forDeclaration, " = ", counterRef, ";"]
             ];
           }
         } else if (forDeclaration) {
@@ -428,16 +436,18 @@ var Civet = (() => {
         }
         let [splices, thisAssignments] = gatherBindingCode(id);
         splices = splices.map((s) => [", ", s]);
-        thisAssignments = thisAssignments.map((a) => [";", a]);
+        thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
         const binding = [c, id, suffix, ...ws];
-        const initializer = [ca, e, ...splices, ...thisAssignments];
+        const initializer = [ca, e];
         const children = [binding, initializer];
         return {
           type: "Declaration",
           names: id.names,
           children,
           binding,
-          initializer
+          initializer,
+          splices,
+          thisAssignments
         };
       }
       function processLetAssignmentDeclaration(l, id, suffix, ws, la, e) {
@@ -450,18 +460,87 @@ var Civet = (() => {
         };
         let [splices, thisAssignments] = gatherBindingCode(id);
         splices = splices.map((s) => [", ", s]);
-        thisAssignments = thisAssignments.map((a) => [";", a]);
+        thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
         const binding = [l, id, suffix, ...ws];
-        const initializer = [la, e, ...splices, ...thisAssignments];
+        const initializer = [la, e];
         const children = [binding, initializer];
         return {
           type: "Declaration",
           names: id.names,
           children,
           binding,
-          initializer
+          initializer,
+          splices,
+          thisAssignments
         };
       }
+      function processUnaryExpression(pre, exp, post) {
+        if (post?.token === "?") {
+          post = {
+            $loc: post.$loc,
+            token: " != null"
+          };
+          switch (exp.type) {
+            case "Identifier":
+            case "Literal":
+              return {
+                ...exp,
+                children: [...pre, ...exp.children, post]
+              };
+            default:
+              const expression = {
+                ...exp,
+                children: [...pre, "(", exp.children, ")", post]
+              };
+              return {
+                type: "ParenthesizedExpression",
+                children: ["(", expression, ")"],
+                expression
+              };
+          }
+        }
+        if (exp.type === "Literal") {
+          if (pre.length === 1 && pre[0].token === "-") {
+            const children = [pre[0], ...exp.children];
+            if (post)
+              exp.children.push(post);
+            return {
+              type: "Literal",
+              children,
+              raw: `-${exp.raw}`
+            };
+          }
+        }
+        const l = pre.length;
+        if (l) {
+          const last = pre[l - 1];
+          if (last.type === "Await" && last.op) {
+            if (exp.type !== "ParenthesizedExpression") {
+              exp = ["(", exp, ")"];
+            }
+            exp = {
+              type: "CallExpression",
+              children: [" Promise", last.op, exp]
+            };
+          }
+        }
+        if (exp.children) {
+          const children = [...pre, ...exp.children];
+          if (post)
+            children.push(post);
+          return Object.assign({}, exp, { children });
+        } else if (Array.isArray(exp)) {
+          const children = [...pre, ...exp];
+          if (post)
+            children.push(post);
+          return { children };
+        } else {
+          const children = [...pre, exp];
+          if (post)
+            children.push(post);
+          return { children };
+        }
+      }
       module.exports = {
         blockWithPrefix,
         clone,
@@ -485,6 +564,7 @@ var Civet = (() => {
         processCoffeeInterpolation,
         processConstAssignmentDeclaration,
         processLetAssignmentDeclaration,
+        processUnaryExpression,
         quoteString,
         removeParentPointers
       };
@@ -1033,6 +1113,7 @@ ${input.slice(result.pos)}
         OperatorDeclaration,
         OperatorSignature,
         AmpersandBlockRHS,
+        AmpersandBlockRHSBody,
         AmpersandUnaryPrefix,
         ThinArrowFunction,
         Arrow,
@@ -1107,6 +1188,7 @@ ${input.slice(result.pos)}
         Xor,
         Xnor,
         UnaryOp,
+        AwaitOp,
         ModuleItem,
         StatementListItem,
         PostfixedStatement,
@@ -1786,7 +1868,8 @@ ${input.slice(result.pos)}
           type: "BlockStatement",
           expressions: statements,
           children: [statements],
-          bare: true
+          bare: true,
+          root: true
         });
         return $0;
       });
@@ -2245,7 +2328,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ArgumentsWithTrailingMemberExpressions$0 = $TS($S(Arguments, TrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
+      var ArgumentsWithTrailingMemberExpressions$0 = $TS($S(Arguments, AllowedTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
         var args = $1;
         var trailing = $2;
         const call = {
@@ -2649,7 +2732,7 @@ ${input.slice(result.pos)}
         var pre = $1;
         var exp = $2;
         var post = $3;
-        return module.processUnaryExpression(pre, exp, post);
+        return processUnaryExpression(pre, exp, post);
       });
       var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
         var ws = $3;
@@ -6263,7 +6346,34 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var AmpersandBlockRHS$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E($S($N($EXPECT($R3, fail, "AmpersandBlockRHS /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2) {
+      var AmpersandBlockRHS$0 = $TS($S(ForbidTrailingMemberProperty, $E(AmpersandBlockRHSBody), RestoreTrailingMemberProperty), function($skip, $loc, $0, $1, $2, $3) {
+        if (!$2)
+          return $skip;
+        return $2;
+      });
+      function AmpersandBlockRHS(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("AmpersandBlockRHS", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("AmpersandBlockRHS", state, AmpersandBlockRHS$0(state));
+          if (state.events)
+            state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+          return result;
+        } else {
+          const result = AmpersandBlockRHS$0(state);
+          if (state.events)
+            state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+          return result;
+        }
+      }
+      var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E($S($N($EXPECT($R3, fail, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2) {
         var callExpRest = $1;
         var binopRHS = $2;
         if (!callExpRest && !binopRHS)
@@ -6290,10 +6400,10 @@ ${input.slice(result.pos)}
         }
         return exp;
       });
-      function AmpersandBlockRHS(state) {
+      function AmpersandBlockRHSBody(state) {
         let eventData;
         if (state.events) {
-          const result = state.events.enter?.("AmpersandBlockRHS", state);
+          const result = state.events.enter?.("AmpersandBlockRHSBody", state);
           if (result) {
             if (result.cache)
               return result.cache;
@@ -6301,14 +6411,14 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("AmpersandBlockRHS", state, AmpersandBlockRHS$0(state));
+          const result = $TOKEN("AmpersandBlockRHSBody", state, AmpersandBlockRHSBody$0(state));
           if (state.events)
-            state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+            state.events.exit?.("AmpersandBlockRHSBody", state, result, eventData);
           return result;
         } else {
-          const result = AmpersandBlockRHS$0(state);
+          const result = AmpersandBlockRHSBody$0(state);
           if (state.events)
-            state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+            state.events.exit?.("AmpersandBlockRHSBody", state, result, eventData);
           return result;
         }
       }
@@ -6890,17 +7000,10 @@ ${input.slice(result.pos)}
         if (!statements.length)
           return $skip;
         statements = statements.flat();
-        const first = statements[0];
-        const ws = first[0];
-        const indent = ws.at(-1);
-        statements = [
-          [indent, ...first.slice(1)],
-          ...statements.slice(1)
-        ];
         return {
           type: "BlockStatement",
           expressions: statements,
-          children: [ws.slice(0, -1), statements],
+          children: [statements],
           bare: true
         };
       });
@@ -9040,8 +9143,9 @@ ${input.slice(result.pos)}
       var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
-      var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
-      var UnaryOp$2 = Not;
+      var UnaryOp$1 = AwaitOp;
+      var UnaryOp$2 = $S($C(Delete, Void, Typeof), $E(_));
+      var UnaryOp$3 = Not;
       function UnaryOp(state) {
         let eventData;
         if (state.events) {
@@ -9053,17 +9157,52 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state));
+          const result = $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state) || UnaryOp$3(state));
           if (state.events)
             state.events.exit?.("UnaryOp", state, result, eventData);
           return result;
         } else {
-          const result = UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state);
+          const result = UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state) || UnaryOp$3(state);
           if (state.events)
             state.events.exit?.("UnaryOp", state, result, eventData);
           return result;
         }
       }
+      var AwaitOp$0 = $TS($S(Await, $E($S(Dot, IdentifierName)), $C(_, $Y(OpenParen))), function($skip, $loc, $0, $1, $2, $3) {
+        var a = $1;
+        var op = $2;
+        var ws = $3;
+        if (op) {
+          return {
+            ...a,
+            op,
+            children: [a, ...ws || []]
+          };
+        }
+        return [a, ...ws || []];
+      });
+      function AwaitOp(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("AwaitOp", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("AwaitOp", state, AwaitOp$0(state));
+          if (state.events)
+            state.events.exit?.("AwaitOp", state, result, eventData);
+          return result;
+        } else {
+          const result = AwaitOp$0(state);
+          if (state.events)
+            state.events.exit?.("AwaitOp", state, result, eventData);
+          return result;
+        }
+      }
       var ModuleItem$0 = ImportDeclaration;
       var ModuleItem$1 = ExportDeclaration;
       var ModuleItem$2 = StatementListItem;
@@ -10099,13 +10238,12 @@ ${input.slice(result.pos)}
       });
       var ForStatementControl$1 = $TS($S(CoffeeForLoopsEnabled, CoffeeForStatementParameters, $E(WhenCondition)), function($skip, $loc, $0, $1, $2, $3) {
         if ($3) {
-          const indent = module.currentIndent.token + "  ";
-          const block = "continue\n";
+          const block = "continue;";
           $2 = {
             ...$2,
             blockPrefix: [
               ...$2.blockPrefix,
-              [indent, {
+              ["", {
                 type: "IfStatement",
                 then: block,
                 children: ["if (!(", insertTrimmingSpace($3, ""), ")) ", block]
@@ -10172,7 +10310,6 @@ ${input.slice(result.pos)}
         var step = $8;
         var close = $9;
         let blockPrefix = [];
-        const indent = module.currentIndent.token + "  ";
         exp = insertTrimmingSpace(exp, "");
         declaration = insertTrimmingSpace(declaration, "");
         if (kind.token === "from") {
@@ -10186,14 +10323,14 @@ ${input.slice(result.pos)}
           }
           if (declaration.own) {
             const hasPropRef = module.getRef("hasProp");
-            blockPrefix.push([indent, "if (!", hasPropRef, ".call(", exp, ", ", declaration, ")) continue\n"]);
+            blockPrefix.push(["", "if (!", hasPropRef, ".call(", exp, ", ", declaration, ")) continue", ";"]);
           }
           if (index) {
-            blockPrefix.push([indent, {
+            blockPrefix.push(["", {
               type: "AssignmentExpression",
               children: [index, " = ", exp, "[", declaration, "]"],
               names: index.names
-            }, ";\n"]);
+            }, ";"]);
           }
           kind.token = "in";
         } else if (kind.token === "in") {
@@ -10229,11 +10366,11 @@ ${input.slice(result.pos)}
             assignmentNames.push(...index.names);
           }
           const expRefDec = expRef !== exp ? [expRef, " = ", insertTrimmingSpace(exp, ""), ", "] : [];
-          blockPrefix.push([indent, {
+          blockPrefix.push(["", {
             type: "AssignmentExpression",
-            children: [varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
+            children: [varRef, " = ", expRef, "[", indexAssignment, counterRef, "]"],
             names: assignmentNames
-          }]);
+          }, ";"]);
           declaration = {
             type: "Declaration",
             children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", expRef, ".length"],
@@ -11152,12 +11289,15 @@ ${input.slice(result.pos)}
           type: "Ref",
           base: "ref"
         };
-        const { binding, initializer } = dec;
+        const { binding, initializer, splices, thisAssignments } = dec;
         const initCondition = {
           type: "AssignmentExpression",
           children: [ref, " ", initializer],
           hoistDec: [["", ["let ", ref], ";"]],
-          blockPrefix: [["", [binding, "= ", ref], ";\n"]]
+          blockPrefix: [
+            ["", [binding, "= ", ref, ...splices], ";"],
+            ...thisAssignments
+          ]
         };
         return initCondition;
       });
@@ -12552,7 +12692,20 @@ ${input.slice(result.pos)}
       }
       var Declaration$0 = HoistableDeclaration;
       var Declaration$1 = ClassDeclaration;
-      var Declaration$2 = LexicalDeclaration;
+      var Declaration$2 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
+        var d = $0;
+        if (d.thisAssignments?.length)
+          return {
+            ...d,
+            children: [...d.children, ...d.splices, ";", ...d.thisAssignments]
+          };
+        if (d.splices?.length)
+          return {
+            ...d,
+            children: [...d.children, ...d.splices]
+          };
+        return d;
+      });
       var Declaration$3 = TypeDeclaration;
       var Declaration$4 = EnumDeclaration;
       var Declaration$5 = OperatorDeclaration;
@@ -12602,12 +12755,21 @@ ${input.slice(result.pos)}
         }
       }
       var LexicalDeclaration$0 = $TS($S(LetOrConst, LexicalBinding, $Q($S(__, Comma, LexicalBinding))), function($skip, $loc, $0, $1, $2, $3) {
+        var d = $1;
         var binding = $2;
         var tail = $3;
+        const { splices, thisAssignments } = binding;
         return {
           type: "Declaration",
           children: $0,
-          names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names))
+          names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names)),
+          binding: {
+            ...binding.binding,
+            children: [d, ...binding.binding.children]
+          },
+          initializer: binding.initializer,
+          splices,
+          thisAssignments
         };
       });
       var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
@@ -12694,25 +12856,51 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
-        const children = [...$1.children];
-        if ($2)
-          children.push($2);
-        children.push($3);
+      var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), $E(_), Initializer), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var binding = $1;
+        var suffix = $2;
+        var ws = $3;
+        var initializer = $4;
+        const bindingChildren = [...binding.children];
+        if (suffix)
+          bindingChildren.push(suffix);
+        if (ws)
+          bindingChildren.push(...ws);
+        binding = {
+          ...binding,
+          children: bindingChildren
+        };
+        const [splices, thisAssignments] = gatherBindingCode(binding.children);
         return {
-          children,
-          names: $1.names
+          children: [binding, initializer],
+          names: binding.names,
+          binding,
+          initializer,
+          splices: splices.map((s) => [",", s]),
+          thisAssignments: thisAssignments.map((s) => ["", s, ";"])
         };
       });
-      var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
-        const children = [...$1.children];
-        if ($2)
-          children.push($2);
-        if ($3)
-          children.push($3);
+      var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(_), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var binding = $1;
+        var suffix = $2;
+        var ws = $3;
+        var initializer = $4;
+        const bindingChildren = [...binding.children];
+        if (suffix)
+          bindingChildren.push(suffix);
+        if (ws)
+          bindingChildren.push(...ws);
+        binding = {
+          ...binding,
+          children: bindingChildren
+        };
         return {
-          children,
-          names: $1.names
+          children: [binding, initializer],
+          names: binding.names,
+          binding,
+          initializer,
+          splices: [],
+          thisAssignments: []
         };
       });
       function LexicalBinding(state) {
@@ -13869,7 +14057,7 @@ ${input.slice(result.pos)}
         }
       }
       var JSSingleLineComment$0 = $TR($EXPECT($R41, fail, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
-        return { $loc, token: $0 };
+        return { type: "Comment", $loc, token: $0 };
       });
       function JSSingleLineComment(state) {
         let eventData;
@@ -13918,7 +14106,7 @@ ${input.slice(result.pos)}
         }
       }
       var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L94, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L95, fail, 'JSMultiLineComment "*/"')), $EXPECT($R42, fail, "JSMultiLineComment /./"))), $EXPECT($L95, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
-        return { $loc, token: $1 };
+        return { type: "Comment", $loc, token: $1 };
       });
       function JSMultiLineComment(state) {
         let eventData;
@@ -13943,7 +14131,7 @@ ${input.slice(result.pos)}
         }
       }
       var CoffeeSingleLineComment$0 = $TR($EXPECT($R43, fail, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
-        return { $loc, token: `//${$1}` };
+        return { type: "Comment", $loc, token: `//${$1}` };
       });
       function CoffeeSingleLineComment(state) {
         let eventData;
@@ -13969,7 +14157,7 @@ ${input.slice(result.pos)}
       }
       var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R44, fail, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
         $2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
-        return { $loc, token: `/*${$2}*/` };
+        return { type: "Comment", $loc, token: `/*${$2}*/` };
       });
       function CoffeeMultiLineComment(state) {
         let eventData;
@@ -17271,7 +17459,7 @@ ${input.slice(result.pos)}
         var pre = $1;
         var exp = $2;
         var post = $3;
-        return module.processUnaryExpression(pre, exp, post);
+        return processUnaryExpression(pre, exp, post);
       });
       function InlineJSXUnaryExpression(state) {
         let eventData;
@@ -21161,60 +21349,6 @@ ${input.slice(result.pos)}
           }
           return node;
         };
-        module.processUnaryExpression = (pre, exp, post) => {
-          if (post?.token === "?") {
-            post = {
-              $loc: post.$loc,
-              token: " != null"
-            };
-            switch (exp.type) {
-              case "Identifier":
-              case "Literal":
-                return {
-                  ...exp,
-                  children: [...pre, ...exp.children, post]
-                };
-              default:
-                const expression = {
-                  ...exp,
-                  children: [...pre, "(", exp.children, ")", post]
-                };
-                return {
-                  type: "ParenthesizedExpression",
-                  children: ["(", expression, ")"],
-                  expression
-                };
-            }
-          }
-          if (exp.type === "Literal") {
-            if (pre.length === 1 && pre[0].token === "-") {
-              const children = [pre[0], ...exp.children];
-              if (post)
-                exp.children.push(post);
-              return {
-                type: "Literal",
-                children,
-                raw: `-${exp.raw}`
-              };
-            }
-          }
-          if (exp.children) {
-            const children = [...pre, ...exp.children];
-            if (post)
-              children.push(post);
-            return Object.assign({}, exp, { children });
-          } else if (Array.isArray(exp)) {
-            const children = [...pre, ...exp];
-            if (post)
-              children.push(post);
-            return { children };
-          } else {
-            const children = [...pre, exp];
-            if (post)
-              children.push(post);
-            return { children };
-          }
-        };
         module.needsRef = function(expression, base = "ref") {
           switch (expression.type) {
             case "Ref":
@@ -21481,7 +21615,10 @@ ${input.slice(result.pos)}
               if (exp.else)
                 insertReturn(exp.else[2]);
               else
-                exp.children.push(["\n", indent, wrapWithReturn()]);
+                exp.children.push(["", {
+                  type: "ReturnStatement",
+                  children: [";return"]
+                }]);
               return;
             case "PatternMatchingStatement":
               insertReturn(exp.children[0][0]);
@@ -21890,11 +22027,15 @@ ${input.slice(result.pos)}
           const [splices, thisAssignments] = gatherBindingCode(parameters, {
             injectParamProps: f.name === "constructor"
           });
+          const delimiter = {
+            type: "SemicolonDelimiter",
+            children: [";"]
+          };
           const prefix = splices.map((s) => ["let ", s]).concat(thisAssignments).map(
             (s) => s.type ? {
               ...s,
-              children: [indent, ...s.children, ";\n"]
-            } : [indent, s, ";\n"]
+              children: [indent, ...s.children, delimiter]
+            } : [indent, s, delimiter]
           );
           expressions.unshift(...prefix);
         }
@@ -21953,9 +22094,10 @@ ${input.slice(result.pos)}
               getIndent(block.expressions[0]),
               {
                 type: "Declaration",
-                children: ["let ", ref, returnType, ";\n"],
+                children: ["let ", ref, returnType],
                 names: []
-              }
+              },
+              ";"
             ]);
           }
           gatherRecursiveWithinFunction(
@@ -21967,7 +22109,7 @@ ${input.slice(result.pos)}
           });
           if (block.children.at(-2)?.type !== "ReturnStatement") {
             block.expressions.push([
-              ["\n", getIndent(block.expressions.at(-1))],
+              [getIndent(block.expressions.at(-1))],
               {
                 type: "ReturnStatement",
                 expression: ref,
@@ -22451,11 +22593,11 @@ ${input.slice(result.pos)}
                   let [splices, thisAssignments] = gatherBindingCode(pattern);
                   const patternBindings = nonMatcherBindings(pattern);
                   splices = splices.map((s2) => [", ", nonMatcherBindings(s2)]);
-                  thisAssignments = thisAssignments.map((a) => [indent, a, ";\n"]);
+                  thisAssignments = thisAssignments.map((a) => [indent, a, ";"]);
                   const duplicateDeclarations = aggregateDuplicateBindings([patternBindings, splices]);
-                  prefix.push([indent, "const ", patternBindings, " = ", ref, splices, ";\n"]);
+                  prefix.push([indent, "const ", patternBindings, " = ", ref, splices, ";"]);
                   prefix.push(...thisAssignments);
-                  prefix.push(...duplicateDeclarations.map((d) => [indent, d, ";\n"]));
+                  prefix.push(...duplicateDeclarations.map((d) => [indent, d, ";"]));
                   break;
                 }
               }
@@ -22610,6 +22752,11 @@ ${input.slice(result.pos)}
           });
         }
         module.processProgram = function(root) {
+          assert.equal(module.forbidClassImplicitCall.length, 1, "forbidClassImplicitCall");
+          assert.equal(module.forbidIndentedApplication.length, 1, "forbidIndentedApplication");
+          assert.equal(module.forbidTrailingMemberProperty.length, 1, "forbidTrailingMemberProperty");
+          assert.equal(module.forbidMultiLineImplicitObjectLiteral.length, 1, "forbidMultiLineImplicitObjectLiteral");
+          assert.equal(module.JSXTagStack.length, 0, "JSXTagStack should be empty");
           addParentPointers(root);
           const { expressions: statements } = root;
           processPipelineExpressions(statements);
@@ -22703,7 +22850,11 @@ ${input.slice(result.pos)}
           });
           if (varIds.length) {
             const indent = getIndent(statements[0]);
-            statements.unshift([indent, "var ", varIds.join(", "), "\n"]);
+            let delimiter = ";";
+            if (statements[0][1]?.parent?.root) {
+              delimiter = ";\n";
+            }
+            statements.unshift([indent, "var ", varIds.join(", "), delimiter]);
           }
           scopes.pop();
         }
@@ -23141,9 +23292,17 @@ ${input.slice(result.pos)}
         processCoffeeInterpolation,
         processConstAssignmentDeclaration,
         processLetAssignmentDeclaration,
+        processUnaryExpression,
         quoteString,
         removeParentPointers
       } = require_lib();
+      var assert = {
+        equal(a, b, msg) {
+          if (a !== b) {
+            throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`);
+          }
+        }
+      };
     }
   });
 
@@ -23580,7 +23739,7 @@ ${input.slice(result.pos)}
   var uncacheable;
   ({ parse } = import_parser.default);
   ({ SourceMap: SourceMap2, base64Encode: base64Encode2 } = util_exports);
-  uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "AllowAll", "AllowClassImplicitCall", "AllowIndentedApplication", "AllowTrailingMemberProperty", "AllowedTrailingMemberExpressions", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "ClassImplicitCallForbidden", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElementListWithIndentedApplicationForbidden", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationForbidden", "ExtendedExpression", "FatArrowBody", "ForbidClassImplicitCall", "ForbidIndentedApplication", "ForbidTrailingMemberProperty", "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", "NestedClassSignatureElement", "NestedClassSignatureElements", "NestedDeclareElement", "NestedDeclareElements", "NestedElement", "NestedElementList", "NestedImplicitObjectLiteral", "NestedImplicitPropertyDefinition", "NestedImplicitPropertyDefinitions", "NestedInterfaceProperty", "NestedJSXChildExpression", "NestedModuleItem", "NestedModuleItems", "NestedObject", "NestedPropertyDefinitions", "NonSingleBracedBlock", "NotDedented", "ObjectLiteral", "PopIndent", "PopJSXStack", "PostfixedExpression", "PostfixedStatement", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "RestoreAll", "RestoreClassImplicitCall", "RestoreIndentedApplication", "RestoreTrailingMemberProperty", "RHS", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuffixedExpression", "SuffixedStatement", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
+  uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "AllowAll", "AllowClassImplicitCall", "AllowIndentedApplication", "AllowMultiLineImplicitObjectLiteral", "AllowTrailingMemberProperty", "AllowedTrailingMemberExpressions", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "ClassImplicitCallForbidden", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElementListWithIndentedApplicationForbidden", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationForbidden", "ExtendedExpression", "FatArrowBody", "ForbidClassImplicitCall", "ForbidIndentedApplication", "ForbidMultiLineImplicitObjectLiteral", "ForbidTrailingMemberProperty", "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", "NestedClassSignatureElement", "NestedClassSignatureElements", "NestedDeclareElement", "NestedDeclareElements", "NestedElement", "NestedElementList", "NestedImplicitObjectLiteral", "NestedImplicitPropertyDefinition", "NestedImplicitPropertyDefinitions", "NestedInterfaceProperty", "NestedJSXChildExpression", "NestedModuleItem", "NestedModuleItems", "NestedObject", "NestedPropertyDefinitions", "NonSingleBracedBlock", "NotDedented", "ObjectLiteral", "PopIndent", "PopJSXStack", "PostfixedExpression", "PostfixedStatement", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "RestoreAll", "RestoreClassImplicitCall", "RestoreMultiLineImplicitObjectLiteral", "RestoreIndentedApplication", "RestoreTrailingMemberProperty", "RHS", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuffixedExpression", "SuffixedStatement", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
   var compile = function(src, options) {
     var ast, code, events, filename, ref, result, sm, srcMapJSON;
     if (!options) {