@danielx/civet 0.5.76 → 0.5.78

package/dist/browser.js

@@ -850,6 +850,7 @@ ${input.slice(result.pos)}
         Import,
         In,
         LetOrConst,
+        Const,
         LetOrConstOrVar,
         Loop,
         New,
@@ -943,6 +944,7 @@ ${input.slice(result.pos)}
         InterfaceExtendsClause,
         InterfaceExtendsTarget,
         TypeKeyword,
+        Enum,
         Interface,
         Global,
         Module,
@@ -960,6 +962,11 @@ ${input.slice(result.pos)}
         NestedDeclareElements,
         NestedDeclareElement,
         DeclareElement,
+        EnumDeclaration,
+        EnumBlock,
+        NestedEnumProperties,
+        NestedEnumProperty,
+        EnumProperty,
         TypeIndexSignature,
         TypeIndex,
         TypeSuffix,
@@ -1218,16 +1225,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"));
@@ -1280,18 +1288,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);
@@ -1539,6 +1548,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) {
@@ -1610,7 +1622,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);
@@ -5827,10 +5839,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,
@@ -6285,6 +6297,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
         };
@@ -8994,12 +9007,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) {
@@ -10684,7 +10700,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) {
@@ -10696,12 +10713,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;
@@ -11562,7 +11579,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) {
@@ -11574,12 +11592,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;
@@ -14472,6 +14490,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) {
@@ -16243,11 +16286,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) {
@@ -16297,7 +16340,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];
@@ -16352,7 +16395,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) {
@@ -16797,7 +16840,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) {
@@ -16822,7 +16865,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,
@@ -16979,10 +17022,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) {
@@ -16994,12 +17038,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;
@@ -17099,7 +17143,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) {
@@ -17124,7 +17193,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) {
@@ -17149,7 +17218,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) {
@@ -17174,7 +17243,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) {
@@ -17323,7 +17392,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) {
@@ -17527,7 +17596,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) {
@@ -17605,7 +17888,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) {
@@ -17779,9 +18062,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;
@@ -18027,7 +18310,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) {
@@ -18434,7 +18717,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) {
@@ -18457,11 +18740,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;
       });
@@ -18487,7 +18770,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",
@@ -18517,7 +18800,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();
@@ -18553,7 +18836,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) {
@@ -18623,7 +18906,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) {
@@ -19777,6 +20060,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("'")) {
@@ -19928,6 +20214,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) {
@@ -20007,7 +20307,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 = {
@@ -20016,16 +20316,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 {
@@ -20233,6 +20545,7 @@ ${input.slice(result.pos)}
         }
         module.makeLeftHandSideExpression = function(expression) {
           switch (expression.type) {
+            case "Ref":
             case "Identifier":
             case "Literal":
             case "CallExpression":
@@ -20269,6 +20582,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;
@@ -20617,14 +20936,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)
@@ -20638,8 +20957,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);
@@ -20662,6 +20982,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)) {
@@ -20670,6 +21012,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) {
@@ -21162,6 +21521,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) => {
@@ -21203,19 +21578,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) => {
@@ -21286,29 +21649,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) {
@@ -21331,8 +21761,10 @@ ${input.slice(result.pos)}
                 arg = result;
               }
             }
+            if (usingRef) {
+              refDec.unshift("let ", usingRef, ";");
+            }
             children.push(arg);
-            s.children = children;
             addParentPointers(s, s.parent);
           });
         }
@@ -21621,7 +22053,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);