@danielx/civet 0.5.71 → 0.5.73

package/dist/browser.js

@@ -494,6 +494,11 @@ ${input.slice(result.pos)}
         NestedClassElement,
         ClassElement,
         ClassElementDefinition,
+        ClassSignature,
+        ClassSignatureBody,
+        NestedClassSignatureElements,
+        NestedClassSignatureElement,
+        ClassSignatureElement,
         AccessModifier,
         FieldDefinition,
         ThisLiteral,
@@ -842,6 +847,7 @@ ${input.slice(result.pos)}
         Import,
         In,
         LetOrConst,
+        LetOrConstOrVar,
         Loop,
         New,
         Not,
@@ -935,6 +941,8 @@ ${input.slice(result.pos)}
         InterfaceExtendsTarget,
         TypeKeyword,
         Interface,
+        Global,
+        Module,
         Namespace,
         InterfaceBlock,
         NestedInterfaceProperties,
@@ -942,9 +950,13 @@ ${input.slice(result.pos)}
         InterfaceProperty,
         BasicInterfaceProperty,
         InterfacePropertyDelimiter,
-        NamespaceBlock,
-        NestedTypeDeclarations,
-        NestedTypeDeclaration,
+        ModuleBlock,
+        NestedModuleItems,
+        NestedModuleItem,
+        DeclareBlock,
+        NestedDeclareElements,
+        NestedDeclareElement,
+        DeclareElement,
         TypeIndexSignature,
         TypeIndex,
         TypeSuffix,
@@ -1203,12 +1215,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"));
@@ -2738,9 +2752,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) {
@@ -3136,6 +3148,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;
@@ -3700,6 +3834,20 @@ ${input.slice(result.pos)}
           children: [start, [...ws, { ...sep, token: ", " }], [end, ...inc]]
         };
       });
+      var SliceParameters$2 = $TS($S(Loc, __, $C(DotDot, DotDotDot), $Y($S(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var l = $1;
+        var ws = $2;
+        const start = {
+          $loc: l.$loc,
+          token: "0"
+        };
+        return {
+          type: "SliceParameters",
+          start,
+          end: void 0,
+          children: [start, ws]
+        };
+      });
       function SliceParameters(state) {
         let eventData;
         if (state.events) {
@@ -3711,12 +3859,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state));
+          const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state));
           if (state.events)
             state.events.exit?.("SliceParameters", state, result, eventData);
           return result;
         } else {
-          const result = SliceParameters$0(state) || SliceParameters$1(state);
+          const result = SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state);
           if (state.events)
             state.events.exit?.("SliceParameters", state, result, eventData);
           return result;
@@ -5327,19 +5475,15 @@ ${input.slice(result.pos)}
           };
           return {
             type: "ArrowFunction",
-            children: [ref2, " => ", prefix, ref2]
+            children: [ref2, " => ", prefix, ref2],
+            ampersandBlock: true
           };
         }
         const { ref } = rhs;
-        if (!prefix) {
-          return {
-            type: "ArrowFunction",
-            children: [ref, " => ", rhs]
-          };
-        }
         return {
           type: "ArrowFunction",
-          children: [ref, " => ", prefix, rhs]
+          children: [ref, " => ", prefix, rhs],
+          ampersandBlock: true
         };
       });
       function FunctionExpression(state) {
@@ -9579,7 +9723,8 @@ ${input.slice(result.pos)}
         return {
           type: "SwitchExpression",
           children: ["(()=>{", e.children, "})()"],
-          caseBlock: e.children[2]
+          expression: e.expression,
+          caseBlock: e.caseBlock
         };
       });
       function SwitchExpression(state) {
@@ -11103,7 +11248,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 };
@@ -13776,7 +13921,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var DotDot$0 = $TV($EXPECT($L114, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
+      var DotDot$0 = $TS($S($EXPECT($L114, fail, 'DotDot ".."'), $N($EXPECT($L4, fail, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function DotDot(state) {
@@ -14201,6 +14346,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)" };
       });
@@ -16659,7 +16828,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;
@@ -16683,7 +16852,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) {
@@ -16695,12 +16868,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;
@@ -16775,7 +16948,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) {
@@ -16798,7 +16973,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) {
@@ -16821,7 +16998,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) {
@@ -16993,13 +17222,63 @@ ${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?.("NamespaceBlock", state);
+          const result = state.events.enter?.("NestedModuleItem", state);
           if (result) {
             if (result.cache)
               return result.cache;
@@ -17007,27 +17286,52 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("NamespaceBlock", state, NamespaceBlock$0(state) || NamespaceBlock$1(state) || NamespaceBlock$2(state));
+          const result = $TOKEN("NestedModuleItem", state, NestedModuleItem$0(state));
           if (state.events)
-            state.events.exit?.("NamespaceBlock", state, result, eventData);
+            state.events.exit?.("NestedModuleItem", state, result, eventData);
           return result;
         } else {
-          const result = NamespaceBlock$0(state) || NamespaceBlock$1(state) || NamespaceBlock$2(state);
+          const result = NestedModuleItem$0(state);
           if (state.events)
-            state.events.exit?.("NamespaceBlock", state, result, eventData);
+            state.events.exit?.("NestedModuleItem", state, result, eventData);
           return result;
         }
       }
-      var NestedTypeDeclarations$0 = $TS($S(PushIndent, $Q(NestedTypeDeclaration), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      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?.("DeclareBlock", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("DeclareBlock", state, DeclareBlock$0(state) || DeclareBlock$1(state) || DeclareBlock$2(state));
+          if (state.events)
+            state.events.exit?.("DeclareBlock", state, result, eventData);
+          return result;
+        } else {
+          const result = DeclareBlock$0(state) || DeclareBlock$1(state) || DeclareBlock$2(state);
+          if (state.events)
+            state.events.exit?.("DeclareBlock", state, result, eventData);
+          return result;
+        }
+      }
+      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?.("NestedTypeDeclarations", state);
+          const result = state.events.enter?.("NestedDeclareElements", state);
           if (result) {
             if (result.cache)
               return result.cache;
@@ -17035,22 +17339,22 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("NestedTypeDeclarations", state, NestedTypeDeclarations$0(state));
+          const result = $TOKEN("NestedDeclareElements", state, NestedDeclareElements$0(state));
           if (state.events)
-            state.events.exit?.("NestedTypeDeclarations", state, result, eventData);
+            state.events.exit?.("NestedDeclareElements", state, result, eventData);
           return result;
         } else {
-          const result = NestedTypeDeclarations$0(state);
+          const result = NestedDeclareElements$0(state);
           if (state.events)
-            state.events.exit?.("NestedTypeDeclarations", state, result, eventData);
+            state.events.exit?.("NestedDeclareElements", state, result, eventData);
           return result;
         }
       }
-      var NestedTypeDeclaration$0 = $S(Nested, TypeDeclaration, InterfacePropertyDelimiter);
-      function NestedTypeDeclaration(state) {
+      var NestedDeclareElement$0 = $S(Nested, DeclareElement, InterfacePropertyDelimiter);
+      function NestedDeclareElement(state) {
         let eventData;
         if (state.events) {
-          const result = state.events.enter?.("NestedTypeDeclaration", state);
+          const result = state.events.enter?.("NestedDeclareElement", state);
           if (result) {
             if (result.cache)
               return result.cache;
@@ -17058,14 +17362,42 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("NestedTypeDeclaration", state, NestedTypeDeclaration$0(state));
+          const result = $TOKEN("NestedDeclareElement", state, NestedDeclareElement$0(state));
           if (state.events)
-            state.events.exit?.("NestedTypeDeclaration", state, result, eventData);
+            state.events.exit?.("NestedDeclareElement", state, result, eventData);
           return result;
         } else {
-          const result = NestedTypeDeclaration$0(state);
+          const result = NestedDeclareElement$0(state);
           if (state.events)
-            state.events.exit?.("NestedTypeDeclaration", state, result, eventData);
+            state.events.exit?.("NestedDeclareElement", state, result, eventData);
+          return result;
+        }
+      }
+      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?.("DeclareElement", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("DeclareElement", state, DeclareElement$0(state) || DeclareElement$1(state));
+          if (state.events)
+            state.events.exit?.("DeclareElement", state, result, eventData);
+          return result;
+        } else {
+          const result = DeclareElement$0(state) || DeclareElement$1(state);
+          if (state.events)
+            state.events.exit?.("DeclareElement", state, result, eventData);
           return result;
         }
       }
@@ -17119,6 +17451,9 @@ ${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 };
+      });
       function TypeSuffix(state) {
         let eventData;
         if (state.events) {
@@ -17130,18 +17465,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));
           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);
           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) {
@@ -17315,9 +17650,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;
@@ -17563,7 +17898,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) {
@@ -18023,7 +18358,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",
@@ -19616,6 +19951,9 @@ ${input.slice(result.pos)}
               else
                 exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
               return;
+            case "PatternMatchingStatement":
+              insertPush(exp.children[0][0], ref);
+              return;
             case "SwitchStatement":
               insertPush(exp.children[2], ref);
               return;
@@ -19703,6 +20041,9 @@ ${input.slice(result.pos)}
               else
                 exp.children.push(["\n", indent, wrapWithReturn()]);
               return;
+            case "PatternMatchingStatement":
+              insertReturn(exp.children[0][0]);
+              return;
             case "SwitchStatement":
               insertSwitchReturns(exp);
               return;
@@ -20630,7 +20971,7 @@ ${input.slice(result.pos)}
           }
         }
         function processPatternMatching(statements) {
-          gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement").forEach((s) => {
+          gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
             const { caseBlock } = s;
             const { clauses } = caseBlock;
             let errors = false;
@@ -20709,15 +21050,21 @@ ${input.slice(result.pos)}
                 block.children.push("}");
                 block.bare = false;
               }
-              const e = i < l - 1 ? ["\nelse "] : [];
-              prev.push({
+              if (i < l - 1)
+                next.push("\n", "else ");
+              prev.push(["", {
                 type: "IfStatement",
-                children: ["if", condition, block, ...e, next],
+                children: ["if", condition, block, next],
                 then: block,
-                else: e
-              });
+                else: next
+              }]);
               prev = next;
             });
+            if (module.config.implicitReturns && s.type === "SwitchExpression") {
+              insertReturn(root[0]);
+              root.unshift("(()=>{");
+              root.push("})()");
+            }
             s.type = "PatternMatchingStatement";
             s.children = [root];
           });
@@ -20770,10 +21117,10 @@ ${input.slice(result.pos)}
           addParentPointers(statements);
           processPipelineExpressions(statements);
           processAssignments(statements);
+          processPatternMatching(statements);
           processFunctions(statements);
           processSwitchExpressions(statements);
           processTryExpressions(statements);
-          processPatternMatching(statements);
           gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
           checkSpliceRef(statements);
           statements.unshift(...module.prelude);
@@ -20972,6 +21319,15 @@ ${input.slice(result.pos)}
         module.gatherBindingCode = gatherBindingCode;
         module.constructInvocation = function(fn, arg) {
           const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
+          if (fn.expr.ampersandBlock) {
+            const [ref, , prefix, rhs] = fn.expr.children;
+            ref.type = "PipedExpression";
+            ref.children = [module.makeLeftHandSideExpression(arg)];
+            return {
+              type: "UnwrappedExpression",
+              children: [module.skipIfOnlyWS(fn.leadingComment), prefix, rhs, module.skipIfOnlyWS(fn.trailingComment)]
+            };
+          }
           const lhs = module.makeLeftHandSideExpression(fn.expr);
           let comment = module.skipIfOnlyWS(fn.trailingComment);
           if (comment)
@@ -20981,10 +21337,7 @@ ${input.slice(result.pos)}
             lhs.children.splice(1, 0, comment);
           switch (arg.type) {
             case "CommaExpression":
-              arg = {
-                type: "ParenthesizedExpression",
-                children: ["(", arg, ")"]
-              };
+              arg = module.makeLeftHandSideExpression(arg);
               break;
           }
           return {
@@ -21704,7 +22057,7 @@ ${input.slice(result.pos)}
   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", "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) {