@danielx/civet 0.5.76 → 0.5.78

package/dist/main.mjs

@@ -847,6 +847,7 @@ ${input.slice(result.pos)}
       Import,
       In,
       LetOrConst,
+      Const,
       LetOrConstOrVar,
       Loop,
       New,
@@ -940,6 +941,7 @@ ${input.slice(result.pos)}
       InterfaceExtendsClause,
       InterfaceExtendsTarget,
       TypeKeyword,
+      Enum,
       Interface,
       Global,
       Module,
@@ -957,6 +959,11 @@ ${input.slice(result.pos)}
       NestedDeclareElements,
       NestedDeclareElement,
       DeclareElement,
+      EnumDeclaration,
+      EnumBlock,
+      NestedEnumProperties,
+      NestedEnumProperty,
+      EnumProperty,
       TypeIndexSignature,
       TypeIndex,
       TypeSuffix,
@@ -1215,16 +1222,17 @@ ${input.slice(result.pos)}
     var $L169 = $L("<!--");
     var $L170 = $L("-->");
     var $L171 = $L("type");
-    var $L172 = $L("interface");
-    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 $L172 = $L("enum");
+    var $L173 = $L("interface");
+    var $L174 = $L("global");
+    var $L175 = $L("module");
+    var $L176 = $L("namespace");
+    var $L177 = $L("asserts");
+    var $L178 = $L("keyof");
+    var $L179 = $L("infer");
+    var $L180 = $L("[]");
+    var $L181 = $L("civet");
+    var $R0 = $R(new RegExp("(as|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"));
     var $R3 = $R(new RegExp("[&]", "suy"));
@@ -1277,18 +1285,19 @@ ${input.slice(result.pos)}
     var $R50 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
     var $R51 = $R(new RegExp("[\\s>]", "suy"));
     var $R52 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
-    var $R53 = $R(new RegExp("[<>]", "suy"));
-    var $R54 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
-    var $R55 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
-    var $R56 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
-    var $R57 = $R(new RegExp("[+-]?", "suy"));
-    var $R58 = $R(new RegExp("[+-]", "suy"));
-    var $R59 = $R(new RegExp("#![^\\r\\n]*", "suy"));
-    var $R60 = $R(new RegExp("[\\t ]*", "suy"));
-    var $R61 = $R(new RegExp("[\\s]*", "suy"));
-    var $R62 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
-    var $R63 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
-    var $R64 = $R(new RegExp("[ \\t]*", "suy"));
+    var $R53 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
+    var $R54 = $R(new RegExp("[<>]", "suy"));
+    var $R55 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
+    var $R56 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
+    var $R57 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
+    var $R58 = $R(new RegExp("[+-]?", "suy"));
+    var $R59 = $R(new RegExp("[+-]", "suy"));
+    var $R60 = $R(new RegExp("#![^\\r\\n]*", "suy"));
+    var $R61 = $R(new RegExp("[\\t ]*", "suy"));
+    var $R62 = $R(new RegExp("[\\s]*", "suy"));
+    var $R63 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
+    var $R64 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
+    var $R65 = $R(new RegExp("[ \\t]*", "suy"));
     var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var statements = $4;
       module.processProgram(statements);
@@ -1536,6 +1545,9 @@ ${input.slice(result.pos)}
       var ws = $4;
       var args = $5;
       var close = $6;
+      if (args.length === 1 && args[0].type === "IterationExpression" && args[0].subtype !== "DoStatement" && !args[0].async && module.isEmptyBareBlock(args[0].block)) {
+        return $skip;
+      }
       return [ta?.[0], open, module.insertTrimmingSpace(ws, ""), args, close];
     });
     function ImplicitArguments(state) {
@@ -1607,7 +1619,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
+    var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
     var ForbiddenImplicitCalls$1 = $EXPECT($L0, fail, 'ForbiddenImplicitCalls "/ "');
     var ForbiddenImplicitCalls$2 = AtAt;
     var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L1, fail, 'ForbiddenImplicitCalls "="'), Whitespace);
@@ -5824,10 +5836,10 @@ ${input.slice(result.pos)}
     var Block$0 = ExplicitBlock;
     var Block$1 = ImplicitNestedBlock;
     var Block$2 = ThenClause;
-    var Block$3 = $TS($S($Q(TrailingComment), Statement), function($skip, $loc, $0, $1, $2) {
+    var Block$3 = $TS($S($Q(TrailingComment), $N(EOS), Statement), function($skip, $loc, $0, $1, $2, $3) {
       var ws = $1;
-      var s = $2;
-      const expressions = [$0];
+      var s = $3;
+      const expressions = [[ws, s]];
       return {
         type: "BlockStatement",
         expressions,
@@ -6282,6 +6294,7 @@ ${input.slice(result.pos)}
     var Literal$0 = $TS($S(LiteralContent), function($skip, $loc, $0, $1) {
       return {
         type: "Literal",
+        subtype: $1.type,
         children: $0,
         raw: $1.token
       };
@@ -8991,12 +9004,15 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var IterationExpression$0 = $TS($S(IterationStatement), function($skip, $loc, $0, $1) {
+    var IterationExpression$0 = $TS($S($E($S(Async, __)), IterationStatement), function($skip, $loc, $0, $1, $2) {
+      var async = $1;
+      var statement = $2;
       return {
         type: "IterationExpression",
-        subtype: $1.type,
-        children: [$1],
-        block: $1.block
+        subtype: statement.type,
+        children: [statement],
+        block: statement.block,
+        async
       };
     });
     function IterationExpression(state) {
@@ -10681,7 +10697,8 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ExpressionStatement$0 = Expression;
+    var ExpressionStatement$0 = IterationExpression;
+    var ExpressionStatement$1 = Expression;
     function ExpressionStatement(state) {
       let eventData;
       if (state.events) {
@@ -10693,12 +10710,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ExpressionStatement", state, ExpressionStatement$0(state));
+        const result = $TOKEN("ExpressionStatement", state, ExpressionStatement$0(state) || ExpressionStatement$1(state));
         if (state.events)
           state.events.exit?.("ExpressionStatement", state, result, eventData);
         return result;
       } else {
-        const result = ExpressionStatement$0(state);
+        const result = ExpressionStatement$0(state) || ExpressionStatement$1(state);
         if (state.events)
           state.events.exit?.("ExpressionStatement", state, result, eventData);
         return result;
@@ -11559,7 +11576,8 @@ ${input.slice(result.pos)}
     var Declaration$1 = ClassDeclaration;
     var Declaration$2 = LexicalDeclaration;
     var Declaration$3 = TypeDeclaration;
-    var Declaration$4 = OperatorDeclaration;
+    var Declaration$4 = EnumDeclaration;
+    var Declaration$5 = OperatorDeclaration;
     function Declaration(state) {
       let eventData;
       if (state.events) {
@@ -11571,12 +11589,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("Declaration", state, Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state) || Declaration$4(state));
+        const result = $TOKEN("Declaration", state, Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state) || Declaration$4(state) || Declaration$5(state));
         if (state.events)
           state.events.exit?.("Declaration", state, result, eventData);
         return result;
       } else {
-        const result = Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state) || Declaration$4(state);
+        const result = Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state) || Declaration$4(state) || Declaration$5(state);
         if (state.events)
           state.events.exit?.("Declaration", state, result, eventData);
         return result;
@@ -14469,6 +14487,31 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var Const$0 = $TS($S($EXPECT($L129, fail, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      return { $loc, token: $1 };
+    });
+    function Const(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("Const", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("Const", state, Const$0(state));
+        if (state.events)
+          state.events.exit?.("Const", state, result, eventData);
+        return result;
+      } else {
+        const result = Const$0(state);
+        if (state.events)
+          state.events.exit?.("Const", state, result, eventData);
+        return result;
+      }
+    }
     var LetOrConstOrVar$0 = LetOrConst;
     var LetOrConstOrVar$1 = Var;
     function LetOrConstOrVar(state) {
@@ -16240,11 +16283,11 @@ ${input.slice(result.pos)}
     var JSXAttributeValue$2 = JSXFragment;
     var JSXAttributeValue$3 = $TS($S(InsertInlineOpenBrace, InlineJSXAttributeValue, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3) {
       if ($2.children?.length === 1 && $2.children[0].type === "StringLiteral") {
-        return $2.children[0];
+        return $skip;
       }
       return $0;
     });
-    var JSXAttributeValue$4 = StringLiteral;
+    var JSXAttributeValue$4 = $R$0($EXPECT($R53, fail, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
     function JSXAttributeValue(state) {
       let eventData;
       if (state.events) {
@@ -16294,7 +16337,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R53, fail, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
+    var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R54, fail, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
       var op = $2;
       var rhs = $3;
       return [[], op, [], rhs];
@@ -16349,7 +16392,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var InlineJSXUnaryOp$0 = $TR($EXPECT($R54, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var InlineJSXUnaryOp$0 = $TR($EXPECT($R55, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       return { $loc, token: $0 };
     });
     function InlineJSXUnaryOp(state) {
@@ -16794,7 +16837,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var JSXCommentContent$0 = $TR($EXPECT($R55, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var JSXCommentContent$0 = $TR($EXPECT($R56, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       return { $loc, token: $0.replace(/\*\//g, "* /") };
     });
     function JSXCommentContent(state) {
@@ -16819,7 +16862,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var JSXText$0 = $TR($EXPECT($R56, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var JSXText$0 = $TR($EXPECT($R57, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       return {
         type: "JSXText",
         token: $0,
@@ -16976,10 +17019,11 @@ ${input.slice(result.pos)}
       }
     }
     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));
+    var TypeLexicalDeclaration$1 = $S(__, EnumDeclaration);
+    var TypeLexicalDeclaration$2 = ClassSignature;
+    var TypeLexicalDeclaration$3 = $S(Namespace, $Q(TrailingComment), IdentifierName, DeclareBlock);
+    var TypeLexicalDeclaration$4 = $S(Module, _, StringLiteral, $E(DeclareBlock));
+    var TypeLexicalDeclaration$5 = $S(Global, $E(DeclareBlock));
     function TypeLexicalDeclaration(state) {
       let eventData;
       if (state.events) {
@@ -16991,12 +17035,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("TypeLexicalDeclaration", state, TypeLexicalDeclaration$0(state) || TypeLexicalDeclaration$1(state) || TypeLexicalDeclaration$2(state) || TypeLexicalDeclaration$3(state) || TypeLexicalDeclaration$4(state));
+        const result = $TOKEN("TypeLexicalDeclaration", state, TypeLexicalDeclaration$0(state) || TypeLexicalDeclaration$1(state) || TypeLexicalDeclaration$2(state) || TypeLexicalDeclaration$3(state) || TypeLexicalDeclaration$4(state) || TypeLexicalDeclaration$5(state));
         if (state.events)
           state.events.exit?.("TypeLexicalDeclaration", state, result, eventData);
         return result;
       } else {
-        const result = TypeLexicalDeclaration$0(state) || TypeLexicalDeclaration$1(state) || TypeLexicalDeclaration$2(state) || TypeLexicalDeclaration$3(state) || TypeLexicalDeclaration$4(state);
+        const result = TypeLexicalDeclaration$0(state) || TypeLexicalDeclaration$1(state) || TypeLexicalDeclaration$2(state) || TypeLexicalDeclaration$3(state) || TypeLexicalDeclaration$4(state) || TypeLexicalDeclaration$5(state);
         if (state.events)
           state.events.exit?.("TypeLexicalDeclaration", state, result, eventData);
         return result;
@@ -17096,7 +17140,32 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Interface$0 = $TS($S($EXPECT($L172, fail, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Enum$0 = $TS($S($EXPECT($L172, fail, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      return { $loc, token: $1 };
+    });
+    function Enum(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("Enum", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("Enum", state, Enum$0(state));
+        if (state.events)
+          state.events.exit?.("Enum", state, result, eventData);
+        return result;
+      } else {
+        const result = Enum$0(state);
+        if (state.events)
+          state.events.exit?.("Enum", state, result, eventData);
+        return result;
+      }
+    }
+    var Interface$0 = $TS($S($EXPECT($L173, fail, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function Interface(state) {
@@ -17121,7 +17190,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Global$0 = $TS($S($EXPECT($L173, fail, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Global$0 = $TS($S($EXPECT($L174, fail, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function Global(state) {
@@ -17146,7 +17215,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Module$0 = $TS($S($EXPECT($L174, fail, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Module$0 = $TS($S($EXPECT($L175, fail, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function Module(state) {
@@ -17171,7 +17240,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Namespace$0 = $TS($S($EXPECT($L175, fail, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Namespace$0 = $TS($S($EXPECT($L176, fail, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function Namespace(state) {
@@ -17320,7 +17389,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var InterfacePropertyDelimiter$0 = $S($Q(_), $C(Semicolon, Comma));
+    var InterfacePropertyDelimiter$0 = $S($E(_), $C(Semicolon, Comma));
     var InterfacePropertyDelimiter$1 = $Y($S(__, CloseBrace));
     var InterfacePropertyDelimiter$2 = $Y(EOS);
     function InterfacePropertyDelimiter(state) {
@@ -17524,7 +17593,221 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L141, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R58, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
+    var EnumDeclaration$0 = $TS($S($E($S(Const, _)), Enum, $Q(TrailingComment), IdentifierName, EnumBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var isConst = $1;
+      var id = $4;
+      var block = $5;
+      const ts = {
+        ts: true,
+        children: $0
+      };
+      if (isConst)
+        return ts;
+      const names = new Set(block.properties.map((p) => p.name.name));
+      return [
+        ts,
+        {
+          js: true,
+          children: [
+            ["let ", id, " = {};\n"],
+            ...block.properties.map((property, i) => {
+              let init, isString;
+              if (property.init) {
+                init = module.replaceNodes(
+                  structuredClone(property.init),
+                  (n) => n.type === "Identifier" && names.has(n.name),
+                  (n) => [id, '["', n.name, '"]']
+                );
+                const value = init[init.length - 1];
+                isString = value.type === "TemplateLiteral" || value.type === "Literal" && value.subtype === "StringLiteral";
+              } else {
+                init = i === 0 ? " = 0" : [" = ", id, '["', block.properties[i - 1].name, '"] + 1'];
+              }
+              if (isString) {
+                return [
+                  id,
+                  '["',
+                  property.name,
+                  '"]',
+                  init,
+                  ";\n"
+                ];
+              } else {
+                return [
+                  id,
+                  "[",
+                  id,
+                  '["',
+                  property.name,
+                  '"]',
+                  init,
+                  '] = "',
+                  property.name,
+                  '";\n'
+                ];
+              }
+            })
+          ]
+        }
+      ];
+    });
+    function EnumDeclaration(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("EnumDeclaration", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("EnumDeclaration", state, EnumDeclaration$0(state));
+        if (state.events)
+          state.events.exit?.("EnumDeclaration", state, result, eventData);
+        return result;
+      } else {
+        const result = EnumDeclaration$0(state);
+        if (state.events)
+          state.events.exit?.("EnumDeclaration", state, result, eventData);
+        return result;
+      }
+    }
+    var EnumBlock$0 = $TS($S(__, OpenBrace, NestedEnumProperties, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var props2 = $3;
+      return {
+        properties: props2.properties,
+        children: $0
+      };
+    });
+    var EnumBlock$1 = $TS($S(__, OpenBrace, $Q($S(__, EnumProperty)), __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var props2 = $3;
+      return {
+        properties: props2.map((p) => p[1]),
+        children: $0
+      };
+    });
+    var EnumBlock$2 = $TS($S(InsertOpenBrace, NestedEnumProperties, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var props2 = $2;
+      return {
+        properties: props2.properties,
+        children: $0
+      };
+    });
+    function EnumBlock(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("EnumBlock", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("EnumBlock", state, EnumBlock$0(state) || EnumBlock$1(state) || EnumBlock$2(state));
+        if (state.events)
+          state.events.exit?.("EnumBlock", state, result, eventData);
+        return result;
+      } else {
+        const result = EnumBlock$0(state) || EnumBlock$1(state) || EnumBlock$2(state);
+        if (state.events)
+          state.events.exit?.("EnumBlock", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedEnumProperties$0 = $TS($S(PushIndent, $Q(NestedEnumProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var props2 = $2;
+      if (!props2.length)
+        return $skip;
+      return {
+        properties: props2.map((p) => p.property),
+        children: $0
+      };
+    });
+    function NestedEnumProperties(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedEnumProperties", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedEnumProperties", state, NestedEnumProperties$0(state));
+        if (state.events)
+          state.events.exit?.("NestedEnumProperties", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedEnumProperties$0(state);
+        if (state.events)
+          state.events.exit?.("NestedEnumProperties", state, result, eventData);
+        return result;
+      }
+    }
+    var NestedEnumProperty$0 = $TS($S(Nested, EnumProperty), function($skip, $loc, $0, $1, $2) {
+      return {
+        property: $2,
+        children: $0
+      };
+    });
+    function NestedEnumProperty(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NestedEnumProperty", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NestedEnumProperty", state, NestedEnumProperty$0(state));
+        if (state.events)
+          state.events.exit?.("NestedEnumProperty", state, result, eventData);
+        return result;
+      } else {
+        const result = NestedEnumProperty$0(state);
+        if (state.events)
+          state.events.exit?.("NestedEnumProperty", state, result, eventData);
+        return result;
+      }
+    }
+    var EnumProperty$0 = $TS($S(Identifier, $E($S(__, Equals, ExtendedExpression)), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
+      var name = $1;
+      var init = $2;
+      return {
+        type: "EnumProperty",
+        name,
+        init,
+        children: $0
+      };
+    });
+    function EnumProperty(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("EnumProperty", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("EnumProperty", state, EnumProperty$0(state));
+        if (state.events)
+          state.events.exit?.("EnumProperty", state, result, eventData);
+        return result;
+      } else {
+        const result = EnumProperty$0(state);
+        if (state.events)
+          state.events.exit?.("EnumProperty", state, result, eventData);
+        return result;
+      }
+    }
+    var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R58, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L141, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R59, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
     function TypeIndexSignature(state) {
       let eventData;
       if (state.events) {
@@ -17602,7 +17885,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    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 ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L177, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
       var asserts = $3;
       var t = $4;
       if (asserts) {
@@ -17776,9 +18059,9 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var TypeUnaryOp$0 = $S($EXPECT($L177, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
+    var TypeUnaryOp$0 = $S($EXPECT($L178, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
     var TypeUnaryOp$1 = $S($EXPECT($L157, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
-    var TypeUnaryOp$2 = $S($EXPECT($L178, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
+    var TypeUnaryOp$2 = $S($EXPECT($L179, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
     var TypeUnaryOp$3 = $S($EXPECT($L141, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
     function TypeUnaryOp(state) {
       let eventData;
@@ -18024,7 +18307,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($L179, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
+    var TypeLiteral$3 = $TV($EXPECT($L180, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
       return { $loc, token: "[]" };
     });
     function TypeLiteral(state) {
@@ -18431,7 +18714,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Shebang$0 = $S($R$0($EXPECT($R59, fail, "Shebang /#![^\\r\\n]*/")), EOL);
+    var Shebang$0 = $S($R$0($EXPECT($R60, fail, "Shebang /#![^\\r\\n]*/")), EOL);
     function Shebang(state) {
       let eventData;
       if (state.events) {
@@ -18454,11 +18737,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var CivetPrologue$0 = $T($S($EXPECT($R60, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
+    var CivetPrologue$0 = $T($S($EXPECT($R61, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
       var content = value[2];
       return content;
     });
-    var CivetPrologue$1 = $T($S($EXPECT($R60, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
+    var CivetPrologue$1 = $T($S($EXPECT($R61, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
       var content = value[2];
       return content;
     });
@@ -18484,7 +18767,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    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 CivetPrologueContent$0 = $TS($S($EXPECT($L181, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R62, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
       var options = $3;
       return {
         type: "CivetPrologue",
@@ -18514,7 +18797,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var CivetOption$0 = $TR($EXPECT($R62, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var CivetOption$0 = $TR($EXPECT($R63, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
         if (l)
           return l.toUpperCase();
@@ -18550,7 +18833,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var UnknownPrologue$0 = $S($R$0($EXPECT($R60, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
+    var UnknownPrologue$0 = $S($R$0($EXPECT($R61, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
     function UnknownPrologue(state) {
       let eventData;
       if (state.events) {
@@ -18620,7 +18903,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var EOL$0 = $TR($EXPECT($R63, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var EOL$0 = $TR($EXPECT($R64, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       return { $loc, token: $0 };
     });
     function EOL(state) {
@@ -19774,6 +20057,9 @@ ${input.slice(result.pos)}
       module.modifyString = function(str) {
         return str.replace(/(^.?|[^\\]{2})(\\\\)*\n/g, "$1$2\\n");
       };
+      module.unmodifyString = function(str) {
+        return str.replace(/\\n/g, "\n");
+      };
       module.quoteString = function(str) {
         str = str.replace(/\\/g, "\\\\");
         if (str.includes('"') && !str.includes("'")) {
@@ -19925,6 +20211,20 @@ ${input.slice(result.pos)}
           return { children };
         }
       };
+      module.needsRef = function(expression, base = "ref") {
+        switch (expression.type) {
+          case "Ref":
+          case "Identifier":
+          case "Literal":
+            return;
+          default:
+            return {
+              type: "Ref",
+              base,
+              id: base
+            };
+        }
+      };
       module.literalValue = function(literal) {
         let { raw } = literal;
         switch (raw) {
@@ -20004,7 +20304,7 @@ ${input.slice(result.pos)}
         const i = exp.children.indexOf(exp.block);
         if (exp.subtype === "DoStatement") {
           insertReturn(exp.block);
-          exp.children.splice(i, 1, ...module.wrapIIFE(exp.children));
+          exp.children.splice(i, 1, ...module.wrapIIFE(exp.children, exp.async));
           return;
         }
         const resultsRef = {
@@ -20013,16 +20313,28 @@ ${input.slice(result.pos)}
           id: "results"
         };
         insertPush(exp.block, resultsRef);
-        exp.children.splice(i, 1, module.wrapIIFE(
-          ["const ", resultsRef, "=[];", ...exp.children, "; return ", resultsRef]
-        ));
+        exp.children.splice(
+          i,
+          1,
+          module.wrapIIFE([
+            "const ",
+            resultsRef,
+            "=[];",
+            ...exp.children,
+            "; return ",
+            resultsRef
+          ], exp.async)
+        );
       }
       module.hasAwait = (exp) => {
         return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
       };
-      module.wrapIIFE = (exp) => {
+      module.wrapIIFE = (exp, async) => {
         let prefix, suffix;
-        if (module.hasAwait(exp)) {
+        if (async) {
+          prefix = "(async ()=>{";
+          suffix = "})()";
+        } else if (module.hasAwait(exp)) {
           prefix = "(await (async ()=>{";
           suffix = "})())";
         } else {
@@ -20230,6 +20542,7 @@ ${input.slice(result.pos)}
       }
       module.makeLeftHandSideExpression = function(expression) {
         switch (expression.type) {
+          case "Ref":
           case "Identifier":
           case "Literal":
           case "CallExpression":
@@ -20266,6 +20579,12 @@ ${input.slice(result.pos)}
           s = s[0];
         return s.token?.startsWith?.("`");
       };
+      module.isEmptyBareBlock = function(node) {
+        if (node?.type !== "BlockStatement")
+          return false;
+        const { bare, expressions } = node;
+        return bare && (expressions.length === 0 || expressions.length === 1 && expressions[0][1]?.type === "EmptyStatement");
+      };
       module.processBinaryOpExpression = function($02) {
         const expandedOps = module.expandChainedComparisons($02);
         let i = 2;
@@ -20614,14 +20933,14 @@ ${input.slice(result.pos)}
         if (node == null)
           return [];
         if (Array.isArray(node)) {
-          return node.flatMap((n) => gatherRecursive(n, predicate));
+          return node.flatMap((n) => gatherRecursive(n, predicate, skipPredicate));
         }
         if (skipPredicate?.(node))
           return [];
         if (predicate(node)) {
           return [node];
         }
-        return gatherRecursive(node.children, predicate);
+        return gatherRecursive(node.children, predicate, skipPredicate);
       }
       function gatherRecursiveAll(node, predicate) {
         if (node == null)
@@ -20635,8 +20954,9 @@ ${input.slice(result.pos)}
         }
         return nodes;
       }
-      function isFunction({ type }) {
-        return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition";
+      function isFunction(node) {
+        const { type } = node;
+        return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || node.async;
       }
       function gatherRecursiveWithinFunction(node, predicate) {
         return gatherRecursive(node, predicate, isFunction);
@@ -20659,6 +20979,28 @@ ${input.slice(result.pos)}
           }
         }
       }
+      function removeParentPointers(node) {
+        if (node == null)
+          return;
+        if (typeof node !== "object")
+          return;
+        if (Array.isArray(node)) {
+          for (const child of node) {
+            removeParentPointers(child);
+          }
+          return;
+        }
+        node.parent = null;
+        if (node.children) {
+          for (const child of node.children) {
+            removeParentPointers(child);
+          }
+        }
+      }
+      function clone(node) {
+        removeParentPointers(node);
+        return structuredClone(node);
+      }
       function findAncestor(node, predicate, stopPredicate) {
         node = node.parent;
         while (node && !stopPredicate?.(node)) {
@@ -20667,6 +21009,23 @@ ${input.slice(result.pos)}
           node = node.parent;
         }
       }
+      module.replaceNodes = (root, predicate, replacer) => {
+        if (root == null)
+          return root;
+        const array = Array.isArray(root) ? root : root.children;
+        if (!array)
+          return root;
+        array.forEach((node, i) => {
+          if (node == null)
+            return;
+          if (predicate(node)) {
+            array[i] = replacer(node, root);
+          } else {
+            module.replaceNodes(node, predicate, replacer);
+          }
+        });
+        return root;
+      };
       function processParams(f) {
         const { type, parameters, block } = f;
         if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
@@ -21159,6 +21518,22 @@ ${input.slice(result.pos)}
           }
         }
         propsGroupedByName.forEach((shared, key) => {
+          if (!key)
+            return;
+          if (ReservedWord({
+            pos: 0,
+            input: key
+          })) {
+            shared.forEach((p) => {
+              const ref = {
+                type: "Ref",
+                base: `_${key}`,
+                id: key
+              };
+              p.children.push(": ", ref);
+            });
+            return;
+          }
           if (shared.length === 1)
             return;
           const refs = shared.map((p) => {
@@ -21200,19 +21575,7 @@ ${input.slice(result.pos)}
           if (expression.type === "ParenthesizedExpression") {
             expression = expression.expression;
           }
-          let ref;
-          switch (expression.type) {
-            case "Identifier":
-            case "Literal":
-              ref = expression;
-              break;
-            default:
-              ref = {
-                type: "Ref",
-                base: "m",
-                id: "m"
-              };
-          }
+          let ref = module.needsRef(expression, "m") || expression;
           let prev = [], root = prev;
           const l = clauses.length;
           clauses.forEach((c, i) => {
@@ -21283,29 +21646,96 @@ ${input.slice(result.pos)}
           const [ws, , body] = s.children;
           let [, arg] = s.children;
           let i = 0, l = body.length;
-          const children = [ws];
+          const refDec = [];
+          const children = [ws, refDec];
+          let usingRef = null;
           for (i = 0; i < l; i++) {
             const step = body[i];
             const [leadingComment, pipe, trailingComment, expr] = step;
             const returns = pipe.token === "||>";
+            let ref, result, returning = returns ? arg : null;
             if (pipe.token === "|>=") {
+              let initRef;
               if (i === 0) {
-                children.push(arg, " = ");
+                outer:
+                  switch (arg.type) {
+                    case "MemberExpression":
+                      if (arg.children.length <= 2)
+                        break;
+                    case "CallExpression":
+                      const access = arg.children.pop();
+                      switch (access.type) {
+                        case "PropertyAccess":
+                        case "SliceExpression":
+                          break;
+                        default:
+                          children.unshift({
+                            type: "Error",
+                            $loc: pipe.token.$loc,
+                            message: `Can't assign to ${access.type}`
+                          });
+                          arg.children.push(access);
+                          break outer;
+                      }
+                      usingRef = module.needsRef({});
+                      initRef = {
+                        type: "AssignmentExpression",
+                        children: [usingRef, " = ", arg, ","]
+                      };
+                      arg = {
+                        type: "MemberExpression",
+                        children: [usingRef, access]
+                      };
+                      break;
+                  }
+                children.pop();
+                const lhs = [[
+                  [refDec, initRef],
+                  arg,
+                  [],
+                  { token: "=", children: [" = "] }
+                ]];
+                Object.assign(s, {
+                  type: "AssignmentExpression",
+                  children: [lhs, children],
+                  names: null,
+                  lhs,
+                  assigned: arg,
+                  exp: children
+                });
+                arg = clone(arg);
+                if (arg.children[0].type === "Ref") {
+                  arg.children[0] = usingRef;
+                }
               } else {
-                children.push({
+                children.unshift({
                   type: "Error",
+                  $loc: pipe.token.$loc,
                   message: "Can't use |>= in the middle of a pipeline"
                 });
               }
+            } else {
+              s.children = children;
             }
-            const [result, returning] = module.constructPipeStep(
+            if (returns && (ref = module.needsRef(arg))) {
+              usingRef = usingRef || ref;
+              arg = {
+                type: "ParenthesizedExpression",
+                children: ["(", {
+                  type: "AssignmentExpression",
+                  children: [usingRef, " = ", arg]
+                }, ")"]
+              };
+              returning = usingRef;
+            }
+            [result, returning] = module.constructPipeStep(
               {
                 leadingComment: module.skipIfOnlyWS(leadingComment),
                 trailingComment: module.skipIfOnlyWS(trailingComment),
                 expr
               },
               arg,
-              returns ? arg : null
+              returning
             );
             if (result.type === "ReturnStatement") {
               if (i < l - 1) {
@@ -21328,8 +21758,10 @@ ${input.slice(result.pos)}
               arg = result;
             }
           }
+          if (usingRef) {
+            refDec.unshift("let ", usingRef, ";");
+          }
           children.push(arg);
-          s.children = children;
           addParentPointers(s, s.parent);
         });
       }
@@ -21618,7 +22050,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var Indent$0 = $TR($EXPECT($R64, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var Indent$0 = $TR($EXPECT($R65, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       let level;
       if (module.config.tab) {
         const tabs = $0.match(/\t/g);