@danielx/civet 0.5.52 → 0.5.54

package/dist/browser.js

@@ -429,6 +429,7 @@ ${input.slice(result.pos)}
         Program,
         TopLevelStatement,
         ExtendedExpression,
+        SingleLineExtendedExpression,
         NonPipelineExtendedExpression,
         NonAssignmentExtendedExpression,
         ExpressionizedStatement,
@@ -741,6 +742,7 @@ ${input.slice(result.pos)}
         __,
         Whitespace,
         ExpressionDelimiter,
+        SimpleStatementDelimiter,
         StatementDelimiter,
         SemicolonDelimiter,
         NonIdContinue,
@@ -1270,6 +1272,30 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var SingleLineExtendedExpression$0 = NonAssignmentExtendedExpression;
+      var SingleLineExtendedExpression$1 = SingleLineAssignmentExpression;
+      function SingleLineExtendedExpression(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("SingleLineExtendedExpression", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("SingleLineExtendedExpression", state, SingleLineExtendedExpression$0(state) || SingleLineExtendedExpression$1(state));
+          if (state.events)
+            state.events.exit?.("SingleLineExtendedExpression", state, result, eventData);
+          return result;
+        } else {
+          const result = SingleLineExtendedExpression$0(state) || SingleLineExtendedExpression$1(state);
+          if (state.events)
+            state.events.exit?.("SingleLineExtendedExpression", state, result, eventData);
+          return result;
+        }
+      }
       var NonPipelineExtendedExpression$0 = NonAssignmentExtendedExpression;
       var NonPipelineExtendedExpression$1 = NonPipelineAssignmentExpression;
       function NonPipelineExtendedExpression(state) {
@@ -1967,20 +1993,7 @@ ${input.slice(result.pos)}
         }
       }
       var AssignmentExpression$0 = PipelineExpression;
-      var AssignmentExpression$1 = $TS($S($Q(TrailingComment), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
-        var ws = $1;
-        var tail = $2;
-        if (ws.length) {
-          if (tail.children && tail.type !== "IterationExpression") {
-            return {
-              ...tail,
-              children: [...ws, ...tail.children]
-            };
-          }
-          return $0;
-        }
-        return tail;
-      });
+      var AssignmentExpression$1 = SingleLineAssignmentExpression;
       var AssignmentExpression$2 = $S(__, AssignmentExpressionTail);
       function AssignmentExpression(state) {
         let eventData;
@@ -4908,7 +4921,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var SingleLineStatements$0 = $TS($S($Q($S($Q(_), Statement, SemicolonDelimiter)), $E($S($Q(_), Statement, $E(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
+      var SingleLineStatements$0 = $TS($S($Q($S($S($E(_), $N(EOS)), Statement, SemicolonDelimiter)), $E($S($S($E(_), $N(EOS)), Statement, $E(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
         var stmts = $1;
         var last = $2;
         const children = [...stmts];
@@ -9384,7 +9397,12 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ExportVarDec$0 = $S(InsertVar, VariableDeclarationList);
+      var ExportVarDec$0 = $TS($S(InsertVar, VariableDeclarationList), function($skip, $loc, $0, $1, $2) {
+        return {
+          ...$2,
+          children: [$1, ...$2.children]
+        };
+      });
       function ExportVarDec(state) {
         let eventData;
         if (state.events) {
@@ -11207,6 +11225,30 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var SimpleStatementDelimiter$0 = SemicolonDelimiter;
+      var SimpleStatementDelimiter$1 = $Y(EOS);
+      function SimpleStatementDelimiter(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("SimpleStatementDelimiter", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("SimpleStatementDelimiter", state, SimpleStatementDelimiter$0(state) || SimpleStatementDelimiter$1(state));
+          if (state.events)
+            state.events.exit?.("SimpleStatementDelimiter", state, result, eventData);
+          return result;
+        } else {
+          const result = SimpleStatementDelimiter$0(state) || SimpleStatementDelimiter$1(state);
+          if (state.events)
+            state.events.exit?.("SimpleStatementDelimiter", state, result, eventData);
+          return result;
+        }
+      }
       var StatementDelimiter$0 = SemicolonDelimiter;
       var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L92, fail, 'StatementDelimiter "("'), $EXPECT($L93, fail, 'StatementDelimiter "["'), $EXPECT($L94, fail, 'StatementDelimiter "`"'), $EXPECT($L54, fail, 'StatementDelimiter "+"'), $EXPECT($L55, fail, 'StatementDelimiter "-"'), $EXPECT($L50, fail, 'StatementDelimiter "*"'), $EXPECT($L51, fail, 'StatementDelimiter "/"'), ObjectLiteral))), InsertSemicolon);
       var StatementDelimiter$2 = $Y(EOS);
@@ -15946,11 +15988,11 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var CivetPrologue$0 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
+      var CivetPrologue$0 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
         var content = value[2];
         return content;
       });
-      var CivetPrologue$1 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
+      var CivetPrologue$1 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
         var content = value[2];
         return content;
       });
@@ -16042,7 +16084,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var UnknownPrologue$0 = $S($R$0($EXPECT($R54, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
+      var UnknownPrologue$0 = $S($R$0($EXPECT($R54, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
       function UnknownPrologue(state) {
         let eventData;
         if (state.events) {
@@ -18104,9 +18146,6 @@ ${input.slice(result.pos)}
           scopes.pop();
         }
         function createLetDecs(statements, scopes) {
-          function hasDec(name) {
-            return scopes.some((s) => s.has(name));
-          }
           function findVarDecs(statements2, decs) {
             const declarationNames = gatherRecursive(
               statements2,
@@ -18114,52 +18153,68 @@ ${input.slice(result.pos)}
             ).filter((node) => node.type === "Declaration").flatMap((node) => node.names);
             return new Set(declarationNames);
           }
-          function insertBeforeAssignment(assignment, content) {
-            if (assignment.children && assignment.children.length) {
-              let indent = assignment.children[0][0][0];
-              if (Array.isArray(indent))
-                indent = indent[indent.length - 1];
-              assignment.children.unshift([indent, ...content]);
-            }
+          let declaredIdentifiers = findVarDecs(statements);
+          function hasDec(name) {
+            return declaredIdentifiers.has(name) || scopes.some((s) => s.has(name));
+          }
+          function gatherBlockOrOther(statement) {
+            return gatherNodes(statement, (s) => s.type === "BlockStatement" || s.type === "AssignmentExpression" || s.type === "Declaration").flatMap((node) => {
+              if (node.type == "BlockStatement")
+                return node.bare ? gatherBlockOrOther(node.expressions) : node;
+              else if (node.children && node.children.length)
+                return [...gatherBlockOrOther(node.children), node];
+              else
+                return [];
+            });
           }
           let currentScope = /* @__PURE__ */ new Set();
           scopes.push(currentScope);
           const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
           const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
-          const nodes = gatherNodes(statements, (s) => s.type === "BlockStatement" || s.type === "AssignmentExpression" || s.type === "Declaration");
-          let declaredIdentifiers = findVarDecs(statements);
-          for (const node of nodes) {
-            if (node.type == "AssignmentExpression") {
-              let undeclaredIdentifiers = node.names.filter((name) => !(hasDec(name) || declaredIdentifiers.has(name)));
-              if (node.children.length)
-                createLetDecs(node.children, scopes);
-              undeclaredIdentifiers.forEach((name) => currentScope.add(name));
-              if (node.names.length === undeclaredIdentifiers.length) {
-                insertBeforeAssignment(node, ["let "]);
-              } else if (undeclaredIdentifiers.length > 0) {
-                insertBeforeAssignment(node, ["let ", undeclaredIdentifiers.join(", "), "\n"]);
+          let targetStatements = [];
+          for (const statement of statements) {
+            const nodes = gatherBlockOrOther(statement);
+            let undeclaredIdentifiers = [];
+            for (const node of nodes) {
+              if (node.type == "BlockStatement") {
+                let block = node;
+                let fnNode = fnNodes.find((fnNode2) => fnNode2.block === block);
+                let forNode = forNodes.find((forNode2) => forNode2.block === block);
+                if (fnNode != null) {
+                  scopes.push(new Set(fnNode.parameters.names));
+                  createLetDecs(block.expressions, scopes);
+                  scopes.pop();
+                } else if (forNode != null) {
+                  scopes.push(new Set(forNode.declaration.names));
+                  createLetDecs(block.expressions, scopes);
+                  scopes.pop();
+                } else
+                  createLetDecs(block.expressions, scopes);
+                continue;
+              }
+              if (node.names == null)
+                continue;
+              let names = node.names.filter((name) => !hasDec(name));
+              if (node.type == "AssignmentExpression")
+                undeclaredIdentifiers.push(...names);
+              names.forEach((name) => currentScope.add(name));
+            }
+            if (undeclaredIdentifiers.length > 0) {
+              let indent = statement[0];
+              let firstIdentifier = gatherNodes(statement[1], (node) => node.type == "Identifier")[0];
+              if (undeclaredIdentifiers.length == 1 && statement[1].type == "AssignmentExpression" && statement[1].names.length == 1 && statement[1].names[0] == undeclaredIdentifiers[0] && firstIdentifier && firstIdentifier.names == undeclaredIdentifiers[0] && gatherNodes(statement[1], (node) => node.type === "ObjectBindingPattern").length == 0)
+                statement[1].children.unshift(["let "]);
+              else {
+                let tail = "\n";
+                if (gatherNodes(indent, (node) => node.token && node.token.endsWith("\n")).length > 0)
+                  tail = void 0;
+                targetStatements.push([indent, "let ", undeclaredIdentifiers.join(", "), tail]);
               }
-            } else if (node.type == "Declaration") {
-              if (node.children && node.children.length)
-                createLetDecs(node.children, scopes);
-              node.names.forEach((name) => currentScope.add(name));
-            } else {
-              let block = node;
-              let fnNode = fnNodes.find((fnNode2) => fnNode2.block === block);
-              let forNode = forNodes.find((forNode2) => forNode2.block === block);
-              if (fnNode != null) {
-                scopes.push(new Set(fnNode.parameters.names));
-                createLetDecs(block.expressions, scopes);
-                scopes.pop();
-              } else if (forNode != null) {
-                scopes.push(new Set(forNode.declaration.names));
-                createLetDecs(block.expressions, scopes);
-                scopes.pop();
-              } else
-                createLetDecs(block.expressions, scopes);
             }
+            targetStatements.push(statement);
           }
           scopes.pop();
+          statements.splice(0, statements.length, targetStatements);
         }
         function gatherBindingCode(statements, opts) {
           const thisAssignments = [];
@@ -18876,7 +18931,7 @@ ${input.slice(result.pos)}
   ({ parse } = import_parser.default);
   ({ SourceMap: SourceMap2, base64Encode: base64Encode2 } = util_exports);
   defaultOptions = {};
-  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", "Samedent", "ShortCircuitExpression", "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", "NonSuppressedTrailingMemberExpressions", "ObjectLiteral", "PopIndent", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuppressIndentedApplication", "SuppressTrailingMemberProperty", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
   var compile = function(src, options = defaultOptions) {
     var ast, code, events, filename, sm, srcMapJSON;
     filename = options.filename || "unknown";

package/dist/civet

@@ -38,6 +38,7 @@ Options:
   --js             Strip out all type annotations; default to .jsx extension
   --ast            Print the AST instead of the compiled code
   --inline-map     Generate a sourcemap
+  --no-cache       Disable compiler caching (slow, for debugging)
 
 You can use - to read from stdin or (prefixed by -o) write to stdout.
 

package/dist/main.js

@@ -428,6 +428,7 @@ ${input.slice(result.pos)}
       Program,
       TopLevelStatement,
       ExtendedExpression,
+      SingleLineExtendedExpression,
       NonPipelineExtendedExpression,
       NonAssignmentExtendedExpression,
       ExpressionizedStatement,
@@ -740,6 +741,7 @@ ${input.slice(result.pos)}
       __,
       Whitespace,
       ExpressionDelimiter,
+      SimpleStatementDelimiter,
       StatementDelimiter,
       SemicolonDelimiter,
       NonIdContinue,
@@ -1269,6 +1271,30 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var SingleLineExtendedExpression$0 = NonAssignmentExtendedExpression;
+    var SingleLineExtendedExpression$1 = SingleLineAssignmentExpression;
+    function SingleLineExtendedExpression(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("SingleLineExtendedExpression", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("SingleLineExtendedExpression", state, SingleLineExtendedExpression$0(state) || SingleLineExtendedExpression$1(state));
+        if (state.events)
+          state.events.exit?.("SingleLineExtendedExpression", state, result, eventData);
+        return result;
+      } else {
+        const result = SingleLineExtendedExpression$0(state) || SingleLineExtendedExpression$1(state);
+        if (state.events)
+          state.events.exit?.("SingleLineExtendedExpression", state, result, eventData);
+        return result;
+      }
+    }
     var NonPipelineExtendedExpression$0 = NonAssignmentExtendedExpression;
     var NonPipelineExtendedExpression$1 = NonPipelineAssignmentExpression;
     function NonPipelineExtendedExpression(state) {
@@ -1966,20 +1992,7 @@ ${input.slice(result.pos)}
       }
     }
     var AssignmentExpression$0 = PipelineExpression;
-    var AssignmentExpression$1 = $TS($S($Q(TrailingComment), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
-      var ws = $1;
-      var tail = $2;
-      if (ws.length) {
-        if (tail.children && tail.type !== "IterationExpression") {
-          return {
-            ...tail,
-            children: [...ws, ...tail.children]
-          };
-        }
-        return $0;
-      }
-      return tail;
-    });
+    var AssignmentExpression$1 = SingleLineAssignmentExpression;
     var AssignmentExpression$2 = $S(__, AssignmentExpressionTail);
     function AssignmentExpression(state) {
       let eventData;
@@ -4907,7 +4920,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var SingleLineStatements$0 = $TS($S($Q($S($Q(_), Statement, SemicolonDelimiter)), $E($S($Q(_), Statement, $E(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
+    var SingleLineStatements$0 = $TS($S($Q($S($S($E(_), $N(EOS)), Statement, SemicolonDelimiter)), $E($S($S($E(_), $N(EOS)), Statement, $E(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
       var stmts = $1;
       var last = $2;
       const children = [...stmts];
@@ -9383,7 +9396,12 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ExportVarDec$0 = $S(InsertVar, VariableDeclarationList);
+    var ExportVarDec$0 = $TS($S(InsertVar, VariableDeclarationList), function($skip, $loc, $0, $1, $2) {
+      return {
+        ...$2,
+        children: [$1, ...$2.children]
+      };
+    });
     function ExportVarDec(state) {
       let eventData;
       if (state.events) {
@@ -11206,6 +11224,30 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var SimpleStatementDelimiter$0 = SemicolonDelimiter;
+    var SimpleStatementDelimiter$1 = $Y(EOS);
+    function SimpleStatementDelimiter(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("SimpleStatementDelimiter", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("SimpleStatementDelimiter", state, SimpleStatementDelimiter$0(state) || SimpleStatementDelimiter$1(state));
+        if (state.events)
+          state.events.exit?.("SimpleStatementDelimiter", state, result, eventData);
+        return result;
+      } else {
+        const result = SimpleStatementDelimiter$0(state) || SimpleStatementDelimiter$1(state);
+        if (state.events)
+          state.events.exit?.("SimpleStatementDelimiter", state, result, eventData);
+        return result;
+      }
+    }
     var StatementDelimiter$0 = SemicolonDelimiter;
     var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L92, fail, 'StatementDelimiter "("'), $EXPECT($L93, fail, 'StatementDelimiter "["'), $EXPECT($L94, fail, 'StatementDelimiter "`"'), $EXPECT($L54, fail, 'StatementDelimiter "+"'), $EXPECT($L55, fail, 'StatementDelimiter "-"'), $EXPECT($L50, fail, 'StatementDelimiter "*"'), $EXPECT($L51, fail, 'StatementDelimiter "/"'), ObjectLiteral))), InsertSemicolon);
     var StatementDelimiter$2 = $Y(EOS);
@@ -15945,11 +15987,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var CivetPrologue$0 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
+    var CivetPrologue$0 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
       var content = value[2];
       return content;
     });
-    var CivetPrologue$1 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
+    var CivetPrologue$1 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
       var content = value[2];
       return content;
     });
@@ -16041,7 +16083,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var UnknownPrologue$0 = $S($R$0($EXPECT($R54, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
+    var UnknownPrologue$0 = $S($R$0($EXPECT($R54, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
     function UnknownPrologue(state) {
       let eventData;
       if (state.events) {
@@ -18103,9 +18145,6 @@ ${input.slice(result.pos)}
         scopes.pop();
       }
       function createLetDecs(statements, scopes) {
-        function hasDec(name) {
-          return scopes.some((s) => s.has(name));
-        }
         function findVarDecs(statements2, decs) {
           const declarationNames = gatherRecursive(
             statements2,
@@ -18113,52 +18152,68 @@ ${input.slice(result.pos)}
           ).filter((node) => node.type === "Declaration").flatMap((node) => node.names);
           return new Set(declarationNames);
         }
-        function insertBeforeAssignment(assignment, content) {
-          if (assignment.children && assignment.children.length) {
-            let indent = assignment.children[0][0][0];
-            if (Array.isArray(indent))
-              indent = indent[indent.length - 1];
-            assignment.children.unshift([indent, ...content]);
-          }
+        let declaredIdentifiers = findVarDecs(statements);
+        function hasDec(name) {
+          return declaredIdentifiers.has(name) || scopes.some((s) => s.has(name));
+        }
+        function gatherBlockOrOther(statement) {
+          return gatherNodes(statement, (s) => s.type === "BlockStatement" || s.type === "AssignmentExpression" || s.type === "Declaration").flatMap((node) => {
+            if (node.type == "BlockStatement")
+              return node.bare ? gatherBlockOrOther(node.expressions) : node;
+            else if (node.children && node.children.length)
+              return [...gatherBlockOrOther(node.children), node];
+            else
+              return [];
+          });
         }
         let currentScope = /* @__PURE__ */ new Set();
         scopes.push(currentScope);
         const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
         const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
-        const nodes = gatherNodes(statements, (s) => s.type === "BlockStatement" || s.type === "AssignmentExpression" || s.type === "Declaration");
-        let declaredIdentifiers = findVarDecs(statements);
-        for (const node of nodes) {
-          if (node.type == "AssignmentExpression") {
-            let undeclaredIdentifiers = node.names.filter((name) => !(hasDec(name) || declaredIdentifiers.has(name)));
-            if (node.children.length)
-              createLetDecs(node.children, scopes);
-            undeclaredIdentifiers.forEach((name) => currentScope.add(name));
-            if (node.names.length === undeclaredIdentifiers.length) {
-              insertBeforeAssignment(node, ["let "]);
-            } else if (undeclaredIdentifiers.length > 0) {
-              insertBeforeAssignment(node, ["let ", undeclaredIdentifiers.join(", "), "\n"]);
+        let targetStatements = [];
+        for (const statement of statements) {
+          const nodes = gatherBlockOrOther(statement);
+          let undeclaredIdentifiers = [];
+          for (const node of nodes) {
+            if (node.type == "BlockStatement") {
+              let block = node;
+              let fnNode = fnNodes.find((fnNode2) => fnNode2.block === block);
+              let forNode = forNodes.find((forNode2) => forNode2.block === block);
+              if (fnNode != null) {
+                scopes.push(new Set(fnNode.parameters.names));
+                createLetDecs(block.expressions, scopes);
+                scopes.pop();
+              } else if (forNode != null) {
+                scopes.push(new Set(forNode.declaration.names));
+                createLetDecs(block.expressions, scopes);
+                scopes.pop();
+              } else
+                createLetDecs(block.expressions, scopes);
+              continue;
+            }
+            if (node.names == null)
+              continue;
+            let names = node.names.filter((name) => !hasDec(name));
+            if (node.type == "AssignmentExpression")
+              undeclaredIdentifiers.push(...names);
+            names.forEach((name) => currentScope.add(name));
+          }
+          if (undeclaredIdentifiers.length > 0) {
+            let indent = statement[0];
+            let firstIdentifier = gatherNodes(statement[1], (node) => node.type == "Identifier")[0];
+            if (undeclaredIdentifiers.length == 1 && statement[1].type == "AssignmentExpression" && statement[1].names.length == 1 && statement[1].names[0] == undeclaredIdentifiers[0] && firstIdentifier && firstIdentifier.names == undeclaredIdentifiers[0] && gatherNodes(statement[1], (node) => node.type === "ObjectBindingPattern").length == 0)
+              statement[1].children.unshift(["let "]);
+            else {
+              let tail = "\n";
+              if (gatherNodes(indent, (node) => node.token && node.token.endsWith("\n")).length > 0)
+                tail = void 0;
+              targetStatements.push([indent, "let ", undeclaredIdentifiers.join(", "), tail]);
             }
-          } else if (node.type == "Declaration") {
-            if (node.children && node.children.length)
-              createLetDecs(node.children, scopes);
-            node.names.forEach((name) => currentScope.add(name));
-          } else {
-            let block = node;
-            let fnNode = fnNodes.find((fnNode2) => fnNode2.block === block);
-            let forNode = forNodes.find((forNode2) => forNode2.block === block);
-            if (fnNode != null) {
-              scopes.push(new Set(fnNode.parameters.names));
-              createLetDecs(block.expressions, scopes);
-              scopes.pop();
-            } else if (forNode != null) {
-              scopes.push(new Set(forNode.declaration.names));
-              createLetDecs(block.expressions, scopes);
-              scopes.pop();
-            } else
-              createLetDecs(block.expressions, scopes);
           }
+          targetStatements.push(statement);
         }
         scopes.pop();
+        statements.splice(0, statements.length, targetStatements);
       }
       function gatherBindingCode(statements, opts) {
         const thisAssignments = [];
@@ -18876,7 +18931,7 @@ var uncacheable;
 ({ parse } = import_parser.default);
 ({ SourceMap: SourceMap2, base64Encode: base64Encode2 } = util_exports);
 defaultOptions = {};
-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", "Samedent", "ShortCircuitExpression", "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", "NonSuppressedTrailingMemberExpressions", "ObjectLiteral", "PopIndent", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuppressIndentedApplication", "SuppressTrailingMemberProperty", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
 var compile = function(src, options = defaultOptions) {
   var ast, code, events, filename, sm, srcMapJSON;
   filename = options.filename || "unknown";

package/dist/main.mjs

@@ -426,6 +426,7 @@ ${input.slice(result.pos)}
       Program,
       TopLevelStatement,
       ExtendedExpression,
+      SingleLineExtendedExpression,
       NonPipelineExtendedExpression,
       NonAssignmentExtendedExpression,
       ExpressionizedStatement,
@@ -738,6 +739,7 @@ ${input.slice(result.pos)}
       __,
       Whitespace,
       ExpressionDelimiter,
+      SimpleStatementDelimiter,
       StatementDelimiter,
       SemicolonDelimiter,
       NonIdContinue,
@@ -1267,6 +1269,30 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var SingleLineExtendedExpression$0 = NonAssignmentExtendedExpression;
+    var SingleLineExtendedExpression$1 = SingleLineAssignmentExpression;
+    function SingleLineExtendedExpression(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("SingleLineExtendedExpression", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("SingleLineExtendedExpression", state, SingleLineExtendedExpression$0(state) || SingleLineExtendedExpression$1(state));
+        if (state.events)
+          state.events.exit?.("SingleLineExtendedExpression", state, result, eventData);
+        return result;
+      } else {
+        const result = SingleLineExtendedExpression$0(state) || SingleLineExtendedExpression$1(state);
+        if (state.events)
+          state.events.exit?.("SingleLineExtendedExpression", state, result, eventData);
+        return result;
+      }
+    }
     var NonPipelineExtendedExpression$0 = NonAssignmentExtendedExpression;
     var NonPipelineExtendedExpression$1 = NonPipelineAssignmentExpression;
     function NonPipelineExtendedExpression(state) {
@@ -1964,20 +1990,7 @@ ${input.slice(result.pos)}
       }
     }
     var AssignmentExpression$0 = PipelineExpression;
-    var AssignmentExpression$1 = $TS($S($Q(TrailingComment), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
-      var ws = $1;
-      var tail = $2;
-      if (ws.length) {
-        if (tail.children && tail.type !== "IterationExpression") {
-          return {
-            ...tail,
-            children: [...ws, ...tail.children]
-          };
-        }
-        return $0;
-      }
-      return tail;
-    });
+    var AssignmentExpression$1 = SingleLineAssignmentExpression;
     var AssignmentExpression$2 = $S(__, AssignmentExpressionTail);
     function AssignmentExpression(state) {
       let eventData;
@@ -4905,7 +4918,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var SingleLineStatements$0 = $TS($S($Q($S($Q(_), Statement, SemicolonDelimiter)), $E($S($Q(_), Statement, $E(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
+    var SingleLineStatements$0 = $TS($S($Q($S($S($E(_), $N(EOS)), Statement, SemicolonDelimiter)), $E($S($S($E(_), $N(EOS)), Statement, $E(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
       var stmts = $1;
       var last = $2;
       const children = [...stmts];
@@ -9381,7 +9394,12 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ExportVarDec$0 = $S(InsertVar, VariableDeclarationList);
+    var ExportVarDec$0 = $TS($S(InsertVar, VariableDeclarationList), function($skip, $loc, $0, $1, $2) {
+      return {
+        ...$2,
+        children: [$1, ...$2.children]
+      };
+    });
     function ExportVarDec(state) {
       let eventData;
       if (state.events) {
@@ -11204,6 +11222,30 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var SimpleStatementDelimiter$0 = SemicolonDelimiter;
+    var SimpleStatementDelimiter$1 = $Y(EOS);
+    function SimpleStatementDelimiter(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("SimpleStatementDelimiter", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("SimpleStatementDelimiter", state, SimpleStatementDelimiter$0(state) || SimpleStatementDelimiter$1(state));
+        if (state.events)
+          state.events.exit?.("SimpleStatementDelimiter", state, result, eventData);
+        return result;
+      } else {
+        const result = SimpleStatementDelimiter$0(state) || SimpleStatementDelimiter$1(state);
+        if (state.events)
+          state.events.exit?.("SimpleStatementDelimiter", state, result, eventData);
+        return result;
+      }
+    }
     var StatementDelimiter$0 = SemicolonDelimiter;
     var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L92, fail, 'StatementDelimiter "("'), $EXPECT($L93, fail, 'StatementDelimiter "["'), $EXPECT($L94, fail, 'StatementDelimiter "`"'), $EXPECT($L54, fail, 'StatementDelimiter "+"'), $EXPECT($L55, fail, 'StatementDelimiter "-"'), $EXPECT($L50, fail, 'StatementDelimiter "*"'), $EXPECT($L51, fail, 'StatementDelimiter "/"'), ObjectLiteral))), InsertSemicolon);
     var StatementDelimiter$2 = $Y(EOS);
@@ -15943,11 +15985,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var CivetPrologue$0 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
+    var CivetPrologue$0 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
       var content = value[2];
       return content;
     });
-    var CivetPrologue$1 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
+    var CivetPrologue$1 = $T($S($EXPECT($R54, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
       var content = value[2];
       return content;
     });
@@ -16039,7 +16081,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var UnknownPrologue$0 = $S($R$0($EXPECT($R54, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
+    var UnknownPrologue$0 = $S($R$0($EXPECT($R54, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
     function UnknownPrologue(state) {
       let eventData;
       if (state.events) {
@@ -18101,9 +18143,6 @@ ${input.slice(result.pos)}
         scopes.pop();
       }
       function createLetDecs(statements, scopes) {
-        function hasDec(name) {
-          return scopes.some((s) => s.has(name));
-        }
         function findVarDecs(statements2, decs) {
           const declarationNames = gatherRecursive(
             statements2,
@@ -18111,52 +18150,68 @@ ${input.slice(result.pos)}
           ).filter((node) => node.type === "Declaration").flatMap((node) => node.names);
           return new Set(declarationNames);
         }
-        function insertBeforeAssignment(assignment, content) {
-          if (assignment.children && assignment.children.length) {
-            let indent = assignment.children[0][0][0];
-            if (Array.isArray(indent))
-              indent = indent[indent.length - 1];
-            assignment.children.unshift([indent, ...content]);
-          }
+        let declaredIdentifiers = findVarDecs(statements);
+        function hasDec(name) {
+          return declaredIdentifiers.has(name) || scopes.some((s) => s.has(name));
+        }
+        function gatherBlockOrOther(statement) {
+          return gatherNodes(statement, (s) => s.type === "BlockStatement" || s.type === "AssignmentExpression" || s.type === "Declaration").flatMap((node) => {
+            if (node.type == "BlockStatement")
+              return node.bare ? gatherBlockOrOther(node.expressions) : node;
+            else if (node.children && node.children.length)
+              return [...gatherBlockOrOther(node.children), node];
+            else
+              return [];
+          });
         }
         let currentScope = /* @__PURE__ */ new Set();
         scopes.push(currentScope);
         const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
         const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
-        const nodes = gatherNodes(statements, (s) => s.type === "BlockStatement" || s.type === "AssignmentExpression" || s.type === "Declaration");
-        let declaredIdentifiers = findVarDecs(statements);
-        for (const node of nodes) {
-          if (node.type == "AssignmentExpression") {
-            let undeclaredIdentifiers = node.names.filter((name) => !(hasDec(name) || declaredIdentifiers.has(name)));
-            if (node.children.length)
-              createLetDecs(node.children, scopes);
-            undeclaredIdentifiers.forEach((name) => currentScope.add(name));
-            if (node.names.length === undeclaredIdentifiers.length) {
-              insertBeforeAssignment(node, ["let "]);
-            } else if (undeclaredIdentifiers.length > 0) {
-              insertBeforeAssignment(node, ["let ", undeclaredIdentifiers.join(", "), "\n"]);
+        let targetStatements = [];
+        for (const statement of statements) {
+          const nodes = gatherBlockOrOther(statement);
+          let undeclaredIdentifiers = [];
+          for (const node of nodes) {
+            if (node.type == "BlockStatement") {
+              let block = node;
+              let fnNode = fnNodes.find((fnNode2) => fnNode2.block === block);
+              let forNode = forNodes.find((forNode2) => forNode2.block === block);
+              if (fnNode != null) {
+                scopes.push(new Set(fnNode.parameters.names));
+                createLetDecs(block.expressions, scopes);
+                scopes.pop();
+              } else if (forNode != null) {
+                scopes.push(new Set(forNode.declaration.names));
+                createLetDecs(block.expressions, scopes);
+                scopes.pop();
+              } else
+                createLetDecs(block.expressions, scopes);
+              continue;
+            }
+            if (node.names == null)
+              continue;
+            let names = node.names.filter((name) => !hasDec(name));
+            if (node.type == "AssignmentExpression")
+              undeclaredIdentifiers.push(...names);
+            names.forEach((name) => currentScope.add(name));
+          }
+          if (undeclaredIdentifiers.length > 0) {
+            let indent = statement[0];
+            let firstIdentifier = gatherNodes(statement[1], (node) => node.type == "Identifier")[0];
+            if (undeclaredIdentifiers.length == 1 && statement[1].type == "AssignmentExpression" && statement[1].names.length == 1 && statement[1].names[0] == undeclaredIdentifiers[0] && firstIdentifier && firstIdentifier.names == undeclaredIdentifiers[0] && gatherNodes(statement[1], (node) => node.type === "ObjectBindingPattern").length == 0)
+              statement[1].children.unshift(["let "]);
+            else {
+              let tail = "\n";
+              if (gatherNodes(indent, (node) => node.token && node.token.endsWith("\n")).length > 0)
+                tail = void 0;
+              targetStatements.push([indent, "let ", undeclaredIdentifiers.join(", "), tail]);
             }
-          } else if (node.type == "Declaration") {
-            if (node.children && node.children.length)
-              createLetDecs(node.children, scopes);
-            node.names.forEach((name) => currentScope.add(name));
-          } else {
-            let block = node;
-            let fnNode = fnNodes.find((fnNode2) => fnNode2.block === block);
-            let forNode = forNodes.find((forNode2) => forNode2.block === block);
-            if (fnNode != null) {
-              scopes.push(new Set(fnNode.parameters.names));
-              createLetDecs(block.expressions, scopes);
-              scopes.pop();
-            } else if (forNode != null) {
-              scopes.push(new Set(forNode.declaration.names));
-              createLetDecs(block.expressions, scopes);
-              scopes.pop();
-            } else
-              createLetDecs(block.expressions, scopes);
           }
+          targetStatements.push(statement);
         }
         scopes.pop();
+        statements.splice(0, statements.length, targetStatements);
       }
       function gatherBindingCode(statements, opts) {
         const thisAssignments = [];
@@ -18864,7 +18919,7 @@ var uncacheable;
 ({ parse } = import_parser.default);
 ({ SourceMap: SourceMap2, base64Encode: base64Encode2 } = util_exports);
 defaultOptions = {};
-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", "Samedent", "ShortCircuitExpression", "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", "NonSuppressedTrailingMemberExpressions", "ObjectLiteral", "PopIndent", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuppressIndentedApplication", "SuppressTrailingMemberProperty", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
 var compile = function(src, options = defaultOptions) {
   var ast, code, events, filename, sm, srcMapJSON;
   filename = options.filename || "unknown";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.5.52",
+  "version": "0.5.54",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",