@danielx/civet 0.5.72 → 0.5.74

package/dist/main.js

@@ -493,6 +493,11 @@ ${input.slice(result.pos)}
       NestedClassElement,
       ClassElement,
       ClassElementDefinition,
+      ClassSignature,
+      ClassSignatureBody,
+      NestedClassSignatureElements,
+      NestedClassSignatureElement,
+      ClassSignatureElement,
       AccessModifier,
       FieldDefinition,
       ThisLiteral,
@@ -636,6 +641,7 @@ ${input.slice(result.pos)}
       StatementListItem,
       PostfixedStatement,
       PostfixedExpression,
+      NonPipelinePostfixedExpression,
       PostfixStatement,
       Statement,
       EmptyStatement,
@@ -659,6 +665,7 @@ ${input.slice(result.pos)}
       LoopStatement,
       LoopClause,
       DoWhileStatement,
+      DoStatement,
       WhileStatement,
       WhileClause,
       ForStatement,
@@ -841,6 +848,7 @@ ${input.slice(result.pos)}
       Import,
       In,
       LetOrConst,
+      LetOrConstOrVar,
       Loop,
       New,
       Not,
@@ -934,6 +942,8 @@ ${input.slice(result.pos)}
       InterfaceExtendsTarget,
       TypeKeyword,
       Interface,
+      Global,
+      Module,
       Namespace,
       InterfaceBlock,
       NestedInterfaceProperties,
@@ -941,9 +951,13 @@ ${input.slice(result.pos)}
       InterfaceProperty,
       BasicInterfaceProperty,
       InterfacePropertyDelimiter,
-      NamespaceBlock,
-      NestedTypeDeclarations,
-      NestedTypeDeclaration,
+      ModuleBlock,
+      NestedModuleItems,
+      NestedModuleItem,
+      DeclareBlock,
+      NestedDeclareElements,
+      NestedDeclareElement,
+      DeclareElement,
       TypeIndexSignature,
       TypeIndex,
       TypeSuffix,
@@ -1025,6 +1039,7 @@ ${input.slice(result.pos)}
       TrackIndented,
       Samedent,
       IndentedFurther,
+      NotDedented,
       PushIndent,
       PopIndent,
       Nested
@@ -1202,12 +1217,14 @@ ${input.slice(result.pos)}
     var $L170 = $L("-->");
     var $L171 = $L("type");
     var $L172 = $L("interface");
-    var $L173 = $L("namespace");
-    var $L174 = $L("asserts");
-    var $L175 = $L("keyof");
-    var $L176 = $L("infer");
-    var $L177 = $L("[]");
-    var $L178 = $L("civet");
+    var $L173 = $L("global");
+    var $L174 = $L("module");
+    var $L175 = $L("namespace");
+    var $L176 = $L("asserts");
+    var $L177 = $L("keyof");
+    var $L178 = $L("infer");
+    var $L179 = $L("[]");
+    var $L180 = $L("civet");
     var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
     var $R1 = $R(new RegExp("[0-9]", "suy"));
     var $R2 = $R(new RegExp("[)}]", "suy"));
@@ -1951,7 +1968,7 @@ ${input.slice(result.pos)}
       var rhs = $2;
       return [[], op, [], rhs];
     });
-    var BinaryOpRHS$1 = $S(__, BinaryOp, $C(_, $S(EOS, __)), RHS);
+    var BinaryOpRHS$1 = $S(NotDedented, BinaryOp, $C(_, $S(EOS, __)), RHS);
     function BinaryOpRHS(state) {
       let eventData;
       if (state.events) {
@@ -2433,7 +2450,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var FatArrowBody$0 = $T($S($N(EOS), PostfixedExpression, $N(SemicolonDelimiter)), function(value) {
+    var FatArrowBody$0 = $T($S($N(EOS), NonPipelinePostfixedExpression, $N(SemicolonDelimiter)), function(value) {
       var exp = value[1];
       return exp;
     });
@@ -2564,12 +2581,13 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var PipelineExpression$0 = $TS($S(PipelineHeadItem, $P($S(__, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2) {
-      var head = $1;
-      var body = $2;
+    var PipelineExpression$0 = $TS($S($E(_), PipelineHeadItem, $P($S(NotDedented, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2, $3) {
+      var ws = $1;
+      var head = $2;
+      var body = $3;
       return {
         type: "PipelineExpression",
-        children: [head, body]
+        children: [ws, head, body]
       };
     });
     function PipelineExpression(state) {
@@ -2737,9 +2755,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ClassExpression$0 = $TS($S($E(Decorators), $E($S(Abstract, __)), Class, $E(ClassBinding), $E(ClassHeritage), ClassBody), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-      return $0;
-    });
+    var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $E(ClassBinding), $E(ClassHeritage), ClassBody);
     function ClassExpression(state) {
       let eventData;
       if (state.events) {
@@ -3135,6 +3151,128 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var ClassSignature$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $E(ClassBinding), $E(ClassHeritage), ClassSignatureBody);
+    function ClassSignature(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ClassSignature", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ClassSignature", state, ClassSignature$0(state));
+        if (state.events)
+          state.events.exit?.("ClassSignature", state, result, eventData);
+        return result;
+      } else {
+        const result = ClassSignature$0(state);
+        if (state.events)
+          state.events.exit?.("ClassSignature", state, result, eventData);
+        return result;
+      }
+    }
+    var ClassSignatureBody$0 = $S(__, OpenBrace, $E(NestedClassSignatureElements), __, CloseBrace);
+    var ClassSignatureBody$1 = $S(InsertOpenBrace, $E(NestedClassSignatureElements), InsertNewline, InsertIndent, InsertCloseBrace);
+    function ClassSignatureBody(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ClassSignatureBody", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ClassSignatureBody", state, ClassSignatureBody$0(state) || ClassSignatureBody$1(state));
+        if (state.events)
+          state.events.exit?.("ClassSignatureBody", state, result, eventData);
+        return result;
+      } else {
+        const result = ClassSignatureBody$0(state) || ClassSignatureBody$1(state);
+        if (state.events)
+          state.events.exit?.("ClassSignatureBody", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedClassSignatureElements$0 = $TS($S(PushIndent, $Q(NestedClassSignatureElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var elements = $2;
+      if (!elements.length)
+        return $skip;
+      return elements;
+    });
+    function NestedClassSignatureElements(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedClassSignatureElements", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedClassSignatureElements", state, NestedClassSignatureElements$0(state));
+        if (state.events)
+          state.events.exit?.("NestedClassSignatureElements", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedClassSignatureElements$0(state);
+        if (state.events)
+          state.events.exit?.("NestedClassSignatureElements", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedClassSignatureElement$0 = $S(Nested, ClassSignatureElement, StatementDelimiter);
+    function NestedClassSignatureElement(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedClassSignatureElement", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedClassSignatureElement", state, NestedClassSignatureElement$0(state));
+        if (state.events)
+          state.events.exit?.("NestedClassSignatureElement", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedClassSignatureElement$0(state);
+        if (state.events)
+          state.events.exit?.("NestedClassSignatureElement", state, result, eventData);
+        return result;
+      }
+    }
+    var ClassSignatureElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $Q(TrailingComment))), $C(MethodSignature, FieldDefinition));
+    var ClassSignatureElement$1 = $S(Static, ClassSignatureBody);
+    function ClassSignatureElement(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ClassSignatureElement", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ClassSignatureElement", state, ClassSignatureElement$0(state) || ClassSignatureElement$1(state));
+        if (state.events)
+          state.events.exit?.("ClassSignatureElement", state, result, eventData);
+        return result;
+      } else {
+        const result = ClassSignatureElement$0(state) || ClassSignatureElement$1(state);
+        if (state.events)
+          state.events.exit?.("ClassSignatureElement", state, result, eventData);
+        return result;
+      }
+    }
     var AccessModifier$0 = $TS($S($E($S($C(Public, Private, Protected), __)), $E($S(Readonly, __))), function($skip, $loc, $0, $1, $2) {
       if (!($1 || $2))
         return $skip;
@@ -8230,6 +8368,35 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var NonPipelinePostfixedExpression$0 = $TS($S(NonPipelineExtendedExpression, $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 NonPipelinePostfixedExpression(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NonPipelinePostfixedExpression", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NonPipelinePostfixedExpression", state, NonPipelinePostfixedExpression$0(state));
+        if (state.events)
+          state.events.exit?.("NonPipelinePostfixedExpression", state, result, eventData);
+        return result;
+      } else {
+        const result = NonPipelinePostfixedExpression$0(state);
+        if (state.events)
+          state.events.exit?.("NonPipelinePostfixedExpression", state, result, eventData);
+        return result;
+      }
+    }
     var PostfixStatement$0 = ForClause;
     var PostfixStatement$1 = IfClause;
     var PostfixStatement$2 = LoopClause;
@@ -8766,8 +8933,11 @@ ${input.slice(result.pos)}
     var IterationStatement$1 = $T($S($N(CoffeeDoEnabled), DoWhileStatement), function(value) {
       return value[1];
     });
-    var IterationStatement$2 = WhileStatement;
-    var IterationStatement$3 = ForStatement;
+    var IterationStatement$2 = $T($S($N(CoffeeDoEnabled), DoStatement), function(value) {
+      return value[1];
+    });
+    var IterationStatement$3 = WhileStatement;
+    var IterationStatement$4 = ForStatement;
     function IterationStatement(state) {
       let eventData;
       if (state.events) {
@@ -8779,12 +8949,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state));
+        const result = $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state));
         if (state.events)
           state.events.exit?.("IterationStatement", state, result, eventData);
         return result;
       } else {
-        const result = IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state);
+        const result = IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
         if (state.events)
           state.events.exit?.("IterationStatement", state, result, eventData);
         return result;
@@ -8793,6 +8963,7 @@ ${input.slice(result.pos)}
     var IterationExpression$0 = $TS($S(IterationStatement), function($skip, $loc, $0, $1) {
       return {
         type: "IterationExpression",
+        subtype: $1.type,
         children: [$1],
         block: $1.block
       };
@@ -8901,6 +9072,37 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var DoStatement$0 = $TS($S(Do, NoPostfixBracedBlock), function($skip, $loc, $0, $1, $2) {
+      var block = $2;
+      block = module2.insertTrimmingSpace(block, "");
+      return {
+        type: "DoStatement",
+        children: [block],
+        block
+      };
+    });
+    function DoStatement(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("DoStatement", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("DoStatement", state, DoStatement$0(state));
+        if (state.events)
+          state.events.exit?.("DoStatement", state, result, eventData);
+        return result;
+      } else {
+        const result = DoStatement$0(state);
+        if (state.events)
+          state.events.exit?.("DoStatement", state, result, eventData);
+        return result;
+      }
+    }
     var WhileStatement$0 = $TS($S(WhileClause, Block), function($skip, $loc, $0, $1, $2) {
       var clause = $1;
       var block = $2;
@@ -9842,13 +10044,31 @@ ${input.slice(result.pos)}
       var c = $3;
       var f = $4;
       if (!c && !f) {
+        const e = [];
+        const emptyCatchBlock = {
+          type: "BlockStatement",
+          expressions: e,
+          children: ["{", e, "}"],
+          bare: false,
+          empty: true
+        };
+        c = {
+          type: "CatchClause",
+          children: [" catch(e) ", emptyCatchBlock],
+          block: emptyCatchBlock
+        };
         return {
           type: "TryStatement",
-          children: [t, b, " catch(e) {}"]
+          blocks: [b, emptyCatchBlock],
+          children: [t, b, c]
         };
       }
+      const blocks = [b];
+      if (c)
+        blocks.push(c.block);
       return {
         type: "TryStatement",
+        blocks,
         children: [t, b, c, f]
       };
     });
@@ -9878,7 +10098,7 @@ ${input.slice(result.pos)}
       var t = $0;
       return {
         type: "TryExpression",
-        blocks: [t.children[1], t.children[2]?.[3]],
+        blocks: t.blocks,
         children: ["(()=>{", t, "})()"]
       };
     });
@@ -9904,7 +10124,14 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var CatchClause$0 = $S($C(Samedent, _), Catch, $E(CatchBind), $C(ThenClause, BracedOrEmptyBlock));
+    var CatchClause$0 = $TS($S($C(Samedent, _), Catch, $E(CatchBind), $C(ThenClause, BracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var block = $4;
+      return {
+        type: "CatchClause",
+        children: $0,
+        block
+      };
+    });
     function CatchClause(state) {
       let eventData;
       if (state.events) {
@@ -11113,7 +11340,7 @@ ${input.slice(result.pos)}
         return $0;
       return { ts: true, children: $0 };
     });
-    var ExportDeclaration$2 = $TS($S(Export, __, $C(Declaration, TypeAndNamedExports, VariableStatement, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3) {
+    var ExportDeclaration$2 = $TS($S(Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3) {
       if (!$3.ts)
         return $0;
       return { ts: true, children: $0 };
@@ -13086,7 +13313,7 @@ ${input.slice(result.pos)}
       }
     }
     var StatementDelimiter$0 = SemicolonDelimiter;
-    var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L97, fail, 'StatementDelimiter "["'), $EXPECT($L98, fail, 'StatementDelimiter "`"'), $EXPECT($L58, fail, 'StatementDelimiter "+"'), $EXPECT($L17, fail, 'StatementDelimiter "-"'), $EXPECT($L54, fail, 'StatementDelimiter "*"'), $EXPECT($L55, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
+    var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L97, fail, 'StatementDelimiter "["'), $EXPECT($L98, fail, 'StatementDelimiter "`"'), $EXPECT($L58, fail, 'StatementDelimiter "+"'), $EXPECT($L17, fail, 'StatementDelimiter "-"'), $EXPECT($L54, fail, 'StatementDelimiter "*"'), $EXPECT($L55, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, FatArrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
     var StatementDelimiter$2 = $Y(EOS);
     function StatementDelimiter(state) {
       let eventData;
@@ -14211,6 +14438,30 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var LetOrConstOrVar$0 = LetOrConst;
+    var LetOrConstOrVar$1 = Var;
+    function LetOrConstOrVar(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("LetOrConstOrVar", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("LetOrConstOrVar", state, LetOrConstOrVar$0(state) || LetOrConstOrVar$1(state));
+        if (state.events)
+          state.events.exit?.("LetOrConstOrVar", state, result, eventData);
+        return result;
+      } else {
+        const result = LetOrConstOrVar$0(state) || LetOrConstOrVar$1(state);
+        if (state.events)
+          state.events.exit?.("LetOrConstOrVar", state, result, eventData);
+        return result;
+      }
+    }
     var Loop$0 = $TS($S($EXPECT($L130, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: "while(true)" };
     });
@@ -16669,7 +16920,7 @@ ${input.slice(result.pos)}
     }
     var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, $C($S($E(_), Type), $S(__, Type)));
     var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock);
-    var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
+    var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, ModuleBlock);
     var TypeDeclarationRest$3 = FunctionSignature;
     function TypeDeclarationRest(state) {
       let eventData;
@@ -16693,7 +16944,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TypeLexicalDeclaration$0 = $S(__, $N(Namespace), LetOrConst, TypeDeclarationBinding, $Q($S(CommaDelimiter, __, TypeDeclarationBinding)));
+    var TypeLexicalDeclaration$0 = $S(__, LetOrConstOrVar, TypeDeclarationBinding, $Q($S(CommaDelimiter, __, TypeDeclarationBinding)));
+    var TypeLexicalDeclaration$1 = ClassSignature;
+    var TypeLexicalDeclaration$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, DeclareBlock);
+    var TypeLexicalDeclaration$3 = $S(Module, _, StringLiteral, $E(DeclareBlock));
+    var TypeLexicalDeclaration$4 = $S(Global, $E(DeclareBlock));
     function TypeLexicalDeclaration(state) {
       let eventData;
       if (state.events) {
@@ -16705,12 +16960,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("TypeLexicalDeclaration", state, TypeLexicalDeclaration$0(state));
+        const result = $TOKEN("TypeLexicalDeclaration", state, TypeLexicalDeclaration$0(state) || TypeLexicalDeclaration$1(state) || TypeLexicalDeclaration$2(state) || TypeLexicalDeclaration$3(state) || TypeLexicalDeclaration$4(state));
         if (state.events)
           state.events.exit?.("TypeLexicalDeclaration", state, result, eventData);
         return result;
       } else {
-        const result = TypeLexicalDeclaration$0(state);
+        const result = TypeLexicalDeclaration$0(state) || TypeLexicalDeclaration$1(state) || TypeLexicalDeclaration$2(state) || TypeLexicalDeclaration$3(state) || TypeLexicalDeclaration$4(state);
         if (state.events)
           state.events.exit?.("TypeLexicalDeclaration", state, result, eventData);
         return result;
@@ -16785,7 +17040,9 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TypeKeyword$0 = $S($EXPECT($L171, fail, 'TypeKeyword "type"'), NonIdContinue);
+    var TypeKeyword$0 = $TS($S($EXPECT($L171, fail, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      return { $loc, token: $1 };
+    });
     function TypeKeyword(state) {
       let eventData;
       if (state.events) {
@@ -16808,7 +17065,9 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Interface$0 = $S($EXPECT($L172, fail, 'Interface "interface"'), NonIdContinue);
+    var Interface$0 = $TS($S($EXPECT($L172, fail, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      return { $loc, token: $1 };
+    });
     function Interface(state) {
       let eventData;
       if (state.events) {
@@ -16831,7 +17090,59 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Namespace$0 = $S($EXPECT($L173, fail, 'Namespace "namespace"'), NonIdContinue);
+    var Global$0 = $TS($S($EXPECT($L173, fail, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      return { $loc, token: $1 };
+    });
+    function Global(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("Global", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("Global", state, Global$0(state));
+        if (state.events)
+          state.events.exit?.("Global", state, result, eventData);
+        return result;
+      } else {
+        const result = Global$0(state);
+        if (state.events)
+          state.events.exit?.("Global", state, result, eventData);
+        return result;
+      }
+    }
+    var Module$0 = $TS($S($EXPECT($L174, fail, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      return { $loc, token: $1 };
+    });
+    function Module(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("Module", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("Module", state, Module$0(state));
+        if (state.events)
+          state.events.exit?.("Module", state, result, eventData);
+        return result;
+      } else {
+        const result = Module$0(state);
+        if (state.events)
+          state.events.exit?.("Module", state, result, eventData);
+        return result;
+      }
+    }
+    var Namespace$0 = $TS($S($EXPECT($L175, fail, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      return { $loc, token: $1 };
+    });
     function Namespace(state) {
       let eventData;
       if (state.events) {
@@ -17003,13 +17314,88 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var NamespaceBlock$0 = $S(__, OpenBrace, NestedTypeDeclarations, __, CloseBrace);
-    var NamespaceBlock$1 = $S(__, OpenBrace, $Q($S(__, TypeDeclaration, InterfacePropertyDelimiter)), __, CloseBrace);
-    var NamespaceBlock$2 = $S(InsertOpenBrace, NestedTypeDeclarations, InsertNewline, InsertIndent, InsertCloseBrace);
-    function NamespaceBlock(state) {
+    var ModuleBlock$0 = $S(__, OpenBrace, NestedModuleItems, __, CloseBrace);
+    var ModuleBlock$1 = $S(InsertOpenBrace, NestedModuleItems, InsertNewline, InsertIndent, InsertCloseBrace);
+    function ModuleBlock(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ModuleBlock", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ModuleBlock", state, ModuleBlock$0(state) || ModuleBlock$1(state));
+        if (state.events)
+          state.events.exit?.("ModuleBlock", state, result, eventData);
+        return result;
+      } else {
+        const result = ModuleBlock$0(state) || ModuleBlock$1(state);
+        if (state.events)
+          state.events.exit?.("ModuleBlock", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedModuleItems$0 = $TS($S(PushIndent, $Q(NestedModuleItem), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var items = $2;
+      if (items.length)
+        return items;
+      return $skip;
+    });
+    function NestedModuleItems(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedModuleItems", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedModuleItems", state, NestedModuleItems$0(state));
+        if (state.events)
+          state.events.exit?.("NestedModuleItems", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedModuleItems$0(state);
+        if (state.events)
+          state.events.exit?.("NestedModuleItems", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedModuleItem$0 = $S(Nested, ModuleItem, StatementDelimiter);
+    function NestedModuleItem(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedModuleItem", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedModuleItem", state, NestedModuleItem$0(state));
+        if (state.events)
+          state.events.exit?.("NestedModuleItem", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedModuleItem$0(state);
+        if (state.events)
+          state.events.exit?.("NestedModuleItem", state, result, eventData);
+        return result;
+      }
+    }
+    var DeclareBlock$0 = $S(__, OpenBrace, NestedDeclareElements, __, CloseBrace);
+    var DeclareBlock$1 = $S(__, OpenBrace, $Q($S(__, DeclareElement, InterfacePropertyDelimiter)), __, CloseBrace);
+    var DeclareBlock$2 = $S(InsertOpenBrace, NestedDeclareElements, InsertNewline, InsertIndent, InsertCloseBrace);
+    function DeclareBlock(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("NamespaceBlock", state);
+        const result = state.events.enter?.("DeclareBlock", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -17017,27 +17403,50 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("NamespaceBlock", state, NamespaceBlock$0(state) || NamespaceBlock$1(state) || NamespaceBlock$2(state));
+        const result = $TOKEN("DeclareBlock", state, DeclareBlock$0(state) || DeclareBlock$1(state) || DeclareBlock$2(state));
         if (state.events)
-          state.events.exit?.("NamespaceBlock", state, result, eventData);
+          state.events.exit?.("DeclareBlock", state, result, eventData);
         return result;
       } else {
-        const result = NamespaceBlock$0(state) || NamespaceBlock$1(state) || NamespaceBlock$2(state);
+        const result = DeclareBlock$0(state) || DeclareBlock$1(state) || DeclareBlock$2(state);
         if (state.events)
-          state.events.exit?.("NamespaceBlock", state, result, eventData);
+          state.events.exit?.("DeclareBlock", state, result, eventData);
         return result;
       }
     }
-    var NestedTypeDeclarations$0 = $TS($S(PushIndent, $Q(NestedTypeDeclaration), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+    var NestedDeclareElements$0 = $TS($S(PushIndent, $Q(NestedDeclareElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
       var decs = $2;
       if (decs.length)
         return decs;
       return $skip;
     });
-    function NestedTypeDeclarations(state) {
+    function NestedDeclareElements(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedDeclareElements", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedDeclareElements", state, NestedDeclareElements$0(state));
+        if (state.events)
+          state.events.exit?.("NestedDeclareElements", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedDeclareElements$0(state);
+        if (state.events)
+          state.events.exit?.("NestedDeclareElements", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedDeclareElement$0 = $S(Nested, DeclareElement, InterfacePropertyDelimiter);
+    function NestedDeclareElement(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("NestedTypeDeclarations", state);
+        const result = state.events.enter?.("NestedDeclareElement", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -17045,22 +17454,27 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("NestedTypeDeclarations", state, NestedTypeDeclarations$0(state));
+        const result = $TOKEN("NestedDeclareElement", state, NestedDeclareElement$0(state));
         if (state.events)
-          state.events.exit?.("NestedTypeDeclarations", state, result, eventData);
+          state.events.exit?.("NestedDeclareElement", state, result, eventData);
         return result;
       } else {
-        const result = NestedTypeDeclarations$0(state);
+        const result = NestedDeclareElement$0(state);
         if (state.events)
-          state.events.exit?.("NestedTypeDeclarations", state, result, eventData);
+          state.events.exit?.("NestedDeclareElement", state, result, eventData);
         return result;
       }
     }
-    var NestedTypeDeclaration$0 = $S(Nested, TypeDeclaration, InterfacePropertyDelimiter);
-    function NestedTypeDeclaration(state) {
+    var DeclareElement$0 = $T($S($E($S(Export, $E(_))), TypeLexicalDeclaration), function(value) {
+      return { "ts": true, "children": value };
+    });
+    var DeclareElement$1 = $T($S($E($S(Export, $E(_))), TypeDeclarationRest), function(value) {
+      return { "ts": true, "children": value };
+    });
+    function DeclareElement(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("NestedTypeDeclaration", state);
+        const result = state.events.enter?.("DeclareElement", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -17068,14 +17482,14 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("NestedTypeDeclaration", state, NestedTypeDeclaration$0(state));
+        const result = $TOKEN("DeclareElement", state, DeclareElement$0(state) || DeclareElement$1(state));
         if (state.events)
-          state.events.exit?.("NestedTypeDeclaration", state, result, eventData);
+          state.events.exit?.("DeclareElement", state, result, eventData);
         return result;
       } else {
-        const result = NestedTypeDeclaration$0(state);
+        const result = DeclareElement$0(state) || DeclareElement$1(state);
         if (state.events)
-          state.events.exit?.("NestedTypeDeclaration", state, result, eventData);
+          state.events.exit?.("DeclareElement", state, result, eventData);
         return result;
       }
     }
@@ -17129,6 +17543,12 @@ ${input.slice(result.pos)}
     var TypeSuffix$0 = $T($S($E(QuestionMark), $E(_), Colon, Type), function(value) {
       return { "type": "TypeSuffix", "ts": true, "children": value };
     });
+    var TypeSuffix$1 = $T($S(QuestionMark, $E(_)), function(value) {
+      return { "type": "TypeSuffix", "ts": true, "children": value };
+    });
+    var TypeSuffix$2 = $T($S(NonNullAssertion, $E(_), $E($S(Colon, Type))), function(value) {
+      return { "type": "TypeSuffix", "ts": true, "children": value };
+    });
     function TypeSuffix(state) {
       let eventData;
       if (state.events) {
@@ -17140,18 +17560,18 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("TypeSuffix", state, TypeSuffix$0(state));
+        const result = $TOKEN("TypeSuffix", state, TypeSuffix$0(state) || TypeSuffix$1(state) || TypeSuffix$2(state));
         if (state.events)
           state.events.exit?.("TypeSuffix", state, result, eventData);
         return result;
       } else {
-        const result = TypeSuffix$0(state);
+        const result = TypeSuffix$0(state) || TypeSuffix$1(state) || TypeSuffix$2(state);
         if (state.events)
           state.events.exit?.("TypeSuffix", state, result, eventData);
         return result;
       }
     }
-    var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L174, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L176, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
       var asserts = $3;
       var t = $4;
       if (asserts) {
@@ -17325,9 +17745,9 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TypeUnaryOp$0 = $S($EXPECT($L175, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
+    var TypeUnaryOp$0 = $S($EXPECT($L177, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
     var TypeUnaryOp$1 = $S($EXPECT($L157, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
-    var TypeUnaryOp$2 = $S($EXPECT($L176, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
+    var TypeUnaryOp$2 = $S($EXPECT($L178, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
     var TypeUnaryOp$3 = $S($EXPECT($L141, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
     function TypeUnaryOp(state) {
       let eventData;
@@ -17573,7 +17993,7 @@ ${input.slice(result.pos)}
     var TypeLiteral$2 = $TS($S($EXPECT($L161, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { type: "VoidType", $loc, token: $1 };
     });
-    var TypeLiteral$3 = $TV($EXPECT($L177, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
+    var TypeLiteral$3 = $TV($EXPECT($L179, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
       return { $loc, token: "[]" };
     });
     function TypeLiteral(state) {
@@ -18033,7 +18453,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var CivetPrologueContent$0 = $TS($S($EXPECT($L178, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R61, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var CivetPrologueContent$0 = $TS($S($EXPECT($L180, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R61, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
       var options = $3;
       return {
         type: "CivetPrologue",
@@ -19550,15 +19970,29 @@ ${input.slice(result.pos)}
         return post;
       };
       function expressionizeIteration(exp) {
+        const i = exp.children.indexOf(exp.block);
+        if (exp.subtype === "DoStatement") {
+          insertReturn(exp.block);
+          exp.children.splice(i, 1, "(()=>", ...exp.children, ")()");
+          return;
+        }
         const resultsRef = {
           type: "Ref",
           base: "results",
           id: "results"
         };
         insertPush(exp.block, resultsRef);
-        exp.children = ["(()=>{const ", resultsRef, "=[];", ...exp.children, "; return ", resultsRef, "})()"];
+        exp.children.splice(i, 1, "(()=>{const ", resultsRef, "=[];", ...exp.children, "; return ", resultsRef, "})()");
       }
       function wrapIterationReturningResults(statement, outerRef) {
+        if (statement.type === "DoStatement") {
+          if (outerRef) {
+            insertPush(statement.block, outerRef);
+          } else {
+            insertReturn(statement.block);
+          }
+          return;
+        }
         const resultsRef = {
           type: "Ref",
           base: "results",
@@ -19581,7 +20015,12 @@ ${input.slice(result.pos)}
           return;
         switch (node.type) {
           case "BlockStatement":
-            insertPush(node.expressions[node.expressions.length - 1], ref);
+            if (node.expressions.length) {
+              const last = node.expressions[node.expressions.length - 1];
+              insertPush(last, ref);
+            } else {
+              node.expressions.push([ref, ".push(void 0);"]);
+            }
             return;
           case "CaseBlock":
             node.clauses.forEach((clause) => {
@@ -19614,6 +20053,7 @@ ${input.slice(result.pos)}
             return;
           case "ForStatement":
           case "IterationStatement":
+          case "DoStatement":
             wrapIterationReturningResults(exp, ref);
             return;
           case "BlockStatement":
@@ -19633,9 +20073,7 @@ ${input.slice(result.pos)}
             insertPush(exp.children[2], ref);
             return;
           case "TryStatement":
-            insertPush(exp.children[1], ref);
-            if (exp.children[2])
-              insertPush(exp.children[2][2], ref);
+            exp.blocks.forEach((block) => insertPush(block, ref));
             return;
         }
         node.splice(1, 0, ref, ".push(");
@@ -19671,7 +20109,14 @@ ${input.slice(result.pos)}
           return;
         switch (node.type) {
           case "BlockStatement":
-            insertReturn(node.expressions[node.expressions.length - 1]);
+            if (node.expressions.length) {
+              const last = node.expressions[node.expressions.length - 1];
+              insertReturn(last);
+            } else {
+              if (node.parent.type === "CatchClause") {
+                node.expressions.push(["return"]);
+              }
+            }
             return;
           case "WhenClause":
             node.children.splice(node.children.indexOf(node.break), 1);
@@ -19704,6 +20149,7 @@ ${input.slice(result.pos)}
             return;
           case "ForStatement":
           case "IterationStatement":
+          case "DoStatement":
             wrapIterationReturningResults(exp);
             return;
           case "BlockStatement":
@@ -19723,9 +20169,7 @@ ${input.slice(result.pos)}
             insertSwitchReturns(exp);
             return;
           case "TryStatement":
-            insertReturn(exp.children[1]);
-            if (exp.children[2])
-              insertReturn(exp.children[2][3]);
+            exp.blocks.forEach((block) => insertReturn(block));
             return;
         }
         if (node[node.length - 1]?.type === "SemicolonDelimiter")
@@ -19901,10 +20345,12 @@ ${input.slice(result.pos)}
         if (Array.isArray(target)) {
           if (target.length === 1) {
             return module2.skipIfOnlyWS(target[0]);
+          } else if (target.every((e) => module2.skipIfOnlyWS(e) === void 0)) {
+            return void 0;
           }
           return target;
         }
-        if (target.token && target.token.trim() === "") {
+        if (target.token != null && target.token.trim() === "") {
           return void 0;
         }
         return target;
@@ -20439,8 +20885,9 @@ ${input.slice(result.pos)}
       module2.attachPostfixStatementAsExpression = function(exp, post) {
         let clause;
         switch (post[1].type) {
-          case "IterationStatement":
           case "ForStatement":
+          case "IterationStatement":
+          case "DoStatement":
             clause = module2.addPostfixStatement(exp, ...post);
             return {
               type: "IterationExpression",
@@ -20645,6 +21092,37 @@ ${input.slice(result.pos)}
             return pattern;
         }
       }
+      function aggregateDuplicateBindings(bindings) {
+        const props2 = gatherRecursiveAll(bindings, (n) => n.type === "BindingMatchProperty");
+        const declarations = [];
+        const propsGroupedByName = /* @__PURE__ */ new Map();
+        for (const p of props2) {
+          const { name } = p;
+          const key = name.name;
+          if (propsGroupedByName.has(key)) {
+            propsGroupedByName.get(key).push(p);
+          } else {
+            propsGroupedByName.set(key, [p]);
+          }
+        }
+        propsGroupedByName.forEach((shared, key) => {
+          if (shared.length === 1)
+            return;
+          const refs = shared.map((p) => {
+            const ref = {
+              type: "Ref",
+              base: key,
+              id: key
+            };
+            p.children.push(": ", ref);
+            return ref;
+          });
+          declarations.push(["const ", key, " = [", ...refs.map((r, i) => {
+            return i === 0 ? r : [", ", r];
+          }), "]"]);
+        });
+        return declarations;
+      }
       function processPatternMatching(statements) {
         gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
           const { caseBlock } = s;
@@ -20711,10 +21189,13 @@ ${input.slice(result.pos)}
                 if (pattern.properties?.length === 0)
                   break;
                 let [splices, thisAssignments] = gatherBindingCode(pattern);
+                const patternBindings = nonMatcherBindings(pattern);
                 splices = splices.map((s2) => [", ", nonMatcherBindings(s2)]);
                 thisAssignments = thisAssignments.map((a) => [indent, a, ";\n"]);
-                prefix.push([indent, "const ", nonMatcherBindings(pattern), " = ", ref, splices, ";\n"]);
+                const duplicateDeclarations = aggregateDuplicateBindings([patternBindings, splices]);
+                prefix.push([indent, "const ", patternBindings, " = ", ref, splices, ";\n"]);
                 prefix.push(...thisAssignments);
+                prefix.push(...duplicateDeclarations.map((d) => [indent, d, ";\n"]));
                 break;
               }
             }
@@ -20746,10 +21227,10 @@ ${input.slice(result.pos)}
       }
       function processPipelineExpressions(statements) {
         gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
-          const [, body] = s.children;
-          let [arg] = s.children;
+          const [ws, , body] = s.children;
+          let [, arg] = s.children;
           let i = 0, l = body.length;
-          const children = [];
+          const children = [ws];
           for (i = 0; i < l; i++) {
             const step = body[i];
             const [leadingComment, pipe, trailingComment, expr] = step;
@@ -20774,7 +21255,17 @@ ${input.slice(result.pos)}
               returns ? arg : null
             );
             if (result.type === "ReturnStatement") {
+              if (i < l - 1) {
+                result.children.push({
+                  type: "Error",
+                  message: "Can't continue a pipeline after returning"
+                });
+              }
               arg = result;
+              if (children[children.length - 1] === ",") {
+                children.pop();
+                children.push(";");
+              }
               break;
             }
             if (returning) {
@@ -21205,6 +21696,36 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var NotDedented$0 = $TS($S($E($C(Samedent, IndentedFurther)), $E(_)), function($skip, $loc, $0, $1, $2) {
+      const ws = [];
+      if ($1)
+        ws.push(...$1);
+      if ($2)
+        ws.push(...$2);
+      return ws.flat(Infinity).filter(Boolean);
+    });
+    function NotDedented(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NotDedented", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NotDedented", state, NotDedented$0(state));
+        if (state.events)
+          state.events.exit?.("NotDedented", state, result, eventData);
+        return result;
+      } else {
+        const result = NotDedented$0(state);
+        if (state.events)
+          state.events.exit?.("NotDedented", state, result, eventData);
+        return result;
+      }
+    }
     var PushIndent$0 = $Y($S(EOS, TrackIndented));
     function PushIndent(state) {
       let eventData;
@@ -21733,7 +22254,7 @@ var parse;
 var uncacheable;
 ({ parse } = import_parser.default);
 ({ SourceMap: SourceMap2, base64Encode: base64Encode2 } = util_exports);
-uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "AllowAll", "AllowIndentedApplication", "AllowTrailingMemberProperty", "AllowedTrailingMemberExpressions", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationForbidden", "ExtendedExpression", "FatArrowBody", "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", "NestedElement", "NestedElementList", "NestedImplicitObjectLiteral", "NestedImplicitPropertyDefinition", "NestedImplicitPropertyDefinitions", "NestedInterfaceProperty", "NestedJSXChildExpression", "NestedObject", "NestedPropertyDefinitions", "NonSingleBracedBlock", "ObjectLiteral", "PopIndent", "PopJSXStack", "PostfixedExpression", "PostfixedStatement", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "RestoreAll", "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", "AllowIndentedApplication", "AllowTrailingMemberProperty", "AllowedTrailingMemberExpressions", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationForbidden", "ExtendedExpression", "FatArrowBody", "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", "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) {