@danielx/civet 0.4.7 → 0.4.9

package/dist/main.js

@@ -455,6 +455,7 @@ var require_parser = __commonJS({
       SuperProperty,
       MetaProperty,
       Parameters,
+      NonEmptyParameters,
       ParameterElement,
       ParameterElementDelimiter,
       BindingIdentifier,
@@ -475,6 +476,7 @@ var require_parser = __commonJS({
       Arrow,
       Block,
       BracedOrEmptyBlock,
+      EmptyBlock,
       BracedBlock,
       SingleNestedExpression,
       NestedBlockExpressions,
@@ -586,9 +588,8 @@ var require_parser = __commonJS({
       TripleDoubleStringCharacters,
       TripleSingleStringCharacters,
       CoffeeStringSubstitution,
-      CoffeeCompat,
-      CoffeeCompatDoubleQuotedString,
-      CoffeeCompatDoubleQuotedStringCharacters,
+      CoffeeInterpolatedDoubleQuotedString,
+      CoffeeDoubleQuotedStringCharacters,
       RegularExpressionLiteral,
       RegularExpressionBody,
       RegExpCharacter,
@@ -716,6 +717,10 @@ var require_parser = __commonJS({
       TypeConstraint,
       TypeParameterDelimiter,
       Shebang,
+      CivetPrologue,
+      CivetPrologueContent,
+      CivetOption,
+      UnknownPrologue,
       DirectivePrologue,
       EOS,
       EOL,
@@ -732,6 +737,8 @@ var require_parser = __commonJS({
       InsertSpace,
       InsertDot,
       InsertBreak,
+      CoffeeCommentEnabled,
+      CoffeeInterpolationEnabled,
       Reset,
       Init,
       Indent,
@@ -883,8 +890,9 @@ var require_parser = __commonJS({
     var $L138 = $L("keyof");
     var $L139 = $L("infer");
     var $L140 = $L("[]");
-    var $L141 = $L("  ");
-    var $L142 = $L("	");
+    var $L141 = $L("civet");
+    var $L142 = $L("  ");
+    var $L143 = $L("	");
     var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
     var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
     var $R2 = $R(new RegExp("[!~+-]", "suy"));
@@ -921,8 +929,10 @@ var require_parser = __commonJS({
     var $R33 = $R(new RegExp("[+-]", "suy"));
     var $R34 = $R(new RegExp("#![^\\r\\n]*", "suy"));
     var $R35 = $R(new RegExp("[\\t ]*", "suy"));
-    var $R36 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
-    var $R37 = $R(new RegExp("$", "suy"));
+    var $R36 = $R(new RegExp("[\\s]*", "suy"));
+    var $R37 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
+    var $R38 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
+    var $R39 = $R(new RegExp("$", "suy"));
     var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
     function Program(state) {
       if (state.verbose)
@@ -1178,7 +1188,19 @@ var require_parser = __commonJS({
       }
     }
     var ArrowFunction$0 = ThinArrowFunction;
-    var ArrowFunction$1 = $S(Parameters, $E(ReturnTypeSuffix), FatArrow, FatArrowBody);
+    var ArrowFunction$1 = $TS($S(Parameters, $E(ReturnTypeSuffix), FatArrow, FatArrowBody), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var suffix = $2;
+      var expOrBlock = $4;
+      const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
+      const isBlock = expOrBlock.type === "BlockStatement";
+      if (module2.config.implicitReturns && !isVoid && isBlock) {
+        module2.addImplicitReturns(expOrBlock);
+      }
+      return {
+        type: "FunctionExpression",
+        children: $0
+      };
+    });
     function ArrowFunction(state) {
       if (state.tokenize) {
         return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
@@ -1201,11 +1223,17 @@ var require_parser = __commonJS({
         return FatArrow$0(state);
       }
     }
-    var FatArrowBody$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
-    var FatArrowBody$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
+    var FatArrowBody$0 = $T($S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace), function(value) {
+      var exps = value[3];
+      return { "type": "BlockStatement", "expressions": exps, "children": value };
+    });
+    var FatArrowBody$1 = $T($S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace), function(value) {
+      var exps = value[2];
+      return { "type": "BlockStatement", "expressions": exps, "children": value };
+    });
     var FatArrowBody$2 = AssignmentExpression;
     var FatArrowBody$3 = $S(__, AssignmentExpression);
-    var FatArrowBody$4 = $S(InsertOpenBrace, InsertCloseBrace);
+    var FatArrowBody$4 = EmptyBlock;
     function FatArrowBody(state) {
       if (state.tokenize) {
         return $TOKEN("FatArrowBody", state, FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state) || FatArrowBody$4(state));
@@ -1521,7 +1549,7 @@ var require_parser = __commonJS({
         return MetaProperty$0(state) || MetaProperty$1(state);
       }
     }
-    var Parameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
+    var Parameters$0 = NonEmptyParameters;
     var Parameters$1 = $TV($EXPECT($L1, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: "()" };
     });
@@ -1532,6 +1560,16 @@ var require_parser = __commonJS({
         return Parameters$0(state) || Parameters$1(state);
       }
     }
+    var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
+    function NonEmptyParameters(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NonEmptyParameters");
+      if (state.tokenize) {
+        return $TOKEN("NonEmptyParameters", state, NonEmptyParameters$0(state));
+      } else {
+        return NonEmptyParameters$0(state);
+      }
+    }
     var ParameterElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter);
     function ParameterElement(state) {
       if (state.verbose)
@@ -1700,8 +1738,17 @@ var require_parser = __commonJS({
       }
     }
     var FunctionExpression$0 = ThinArrowFunction;
-    var FunctionExpression$1 = $T($S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock), function(value) {
-      return { "type": "FunctionExpression", "children": value };
+    var FunctionExpression$1 = $TS($S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+      var suffix = $7;
+      var block = $8;
+      const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
+      if (module2.config.implicitReturns && !isVoid) {
+        module2.addImplicitReturns(block);
+      }
+      return {
+        type: "FunctionExpression",
+        children: $0
+      };
     });
     function FunctionExpression(state) {
       if (state.tokenize) {
@@ -1715,7 +1762,8 @@ var require_parser = __commonJS({
       var suffix = $2;
       var arrow = $4;
       var block = $5;
-      if (module2.implicitReturns && suffix?.children[3] !== "void") {
+      const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
+      if (module2.config.implicitReturns && !isVoid) {
         block = module2.addImplicitReturns(block);
       }
       return {
@@ -1767,9 +1815,7 @@ var require_parser = __commonJS({
       }
     }
     var BracedOrEmptyBlock$0 = BracedBlock;
-    var BracedOrEmptyBlock$1 = $T($S(InsertOpenBrace, InsertCloseBrace), function(value) {
-      return { "type": "BlockStatement", "expressions": [], "children": value };
-    });
+    var BracedOrEmptyBlock$1 = EmptyBlock;
     function BracedOrEmptyBlock(state) {
       if (state.tokenize) {
         return $TOKEN("BracedOrEmptyBlock", state, BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state));
@@ -1777,6 +1823,18 @@ var require_parser = __commonJS({
         return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
       }
     }
+    var EmptyBlock$0 = $T($S(InsertOpenBrace, InsertCloseBrace), function(value) {
+      return { "type": "BlockStatement", "expressions": [], "children": value };
+    });
+    function EmptyBlock(state) {
+      if (state.verbose)
+        console.log("ENTER:", "EmptyBlock");
+      if (state.tokenize) {
+        return $TOKEN("EmptyBlock", state, EmptyBlock$0(state));
+      } else {
+        return EmptyBlock$0(state);
+      }
+    }
     var BracedBlock$0 = $T($S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace), function(value) {
       var exps = value[3];
       return { "type": "BlockStatement", "expressions": exps, "children": value };
@@ -2100,7 +2158,17 @@ var require_parser = __commonJS({
         return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
       }
     }
-    var MethodDefinition$0 = $S(MethodSignature, BracedBlock);
+    var MethodDefinition$0 = $TS($S(MethodSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
+      var sig = $1;
+      var block = $2;
+      const isConstructor = sig.name === "constructor";
+      const isVoid = sig.returnType === "void";
+      const isSet = sig.modifier === "set";
+      if (module2.config.implicitReturns && !isConstructor && !isSet && !isVoid) {
+        block = module2.addImplicitReturns(block);
+      }
+      return $0;
+    });
     function MethodDefinition(state) {
       if (state.verbose)
         console.log("ENTER:", "MethodDefinition");
@@ -2121,8 +2189,26 @@ var require_parser = __commonJS({
         return MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state);
       }
     }
-    var MethodSignature$0 = $S(ConstructorShorthand, Parameters);
-    var MethodSignature$1 = $S($E(MethodModifier), ClassElementName, $Q(_), Parameters);
+    var MethodSignature$0 = $TS($S(ConstructorShorthand, Parameters), function($skip, $loc, $0, $1, $2) {
+      return {
+        type: "MethodSignature",
+        children: $0,
+        name: $1.token,
+        returnType: void 0
+      };
+    });
+    var MethodSignature$1 = $TS($S($E(MethodModifier), ClassElementName, $Q(_), NonEmptyParameters, $E(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var name = $2;
+      var suffix = $5;
+      name = name.token.match(/^(?:"|')/) ? name.token.slice(1, -1) : name.token;
+      return {
+        type: "MethodSignature",
+        children: $0,
+        name,
+        modifier: $1?.[0]?.token,
+        returnType: void 0
+      };
+    });
     function MethodSignature(state) {
       if (state.tokenize) {
         return $TOKEN("MethodSignature", state, MethodSignature$0(state) || MethodSignature$1(state));
@@ -2139,7 +2225,12 @@ var require_parser = __commonJS({
         return ClassElementName$0(state) || ClassElementName$1(state);
       }
     }
-    var PrivateIdentifier$0 = $S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName);
+    var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
+      return {
+        $loc,
+        token: $1
+      };
+    });
     function PrivateIdentifier(state) {
       if (state.verbose)
         console.log("ENTER:", "PrivateIdentifier");
@@ -2214,7 +2305,7 @@ var require_parser = __commonJS({
     var BinaryOpSymbol$12 = $EXPECT($L53, fail, 'BinaryOpSymbol ">"');
     var BinaryOpSymbol$13 = $EXPECT($L54, fail, 'BinaryOpSymbol "!=="');
     var BinaryOpSymbol$14 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
-      if (module2.coffeeCompat)
+      if (module2.config.coffeeEq)
         return "!==";
       return $1;
     });
@@ -2223,7 +2314,7 @@ var require_parser = __commonJS({
     });
     var BinaryOpSymbol$16 = $EXPECT($L57, fail, 'BinaryOpSymbol "==="');
     var BinaryOpSymbol$17 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
-      if (module2.coffeeCompat)
+      if (module2.config.coffeeEq)
         return "===";
       return $1;
     });
@@ -2344,7 +2435,10 @@ var require_parser = __commonJS({
         return EmptyStatement$0(state);
       }
     }
-    var BlockStatement$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
+    var BlockStatement$0 = $T($S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace), function(value) {
+      var exps = value[3];
+      return { "type": "BlockStatement", "children": value, "expressions": exps };
+    });
     function BlockStatement(state) {
       if (state.verbose)
         console.log("ENTER:", "BlockStatement");
@@ -3134,7 +3228,7 @@ var require_parser = __commonJS({
       var e = $3;
       return [s, module2.dedentBlockString(str), e];
     });
-    var StringLiteral$2 = CoffeeCompatDoubleQuotedString;
+    var StringLiteral$2 = CoffeeInterpolatedDoubleQuotedString;
     var StringLiteral$3 = BasicStringLiteral;
     function StringLiteral(state) {
       if (state.tokenize) {
@@ -3222,21 +3316,7 @@ var require_parser = __commonJS({
         return CoffeeStringSubstitution$0(state);
       }
     }
-    var CoffeeCompat$0 = $TV($EXPECT($L1, fail, 'CoffeeCompat ""'), function($skip, $loc, $0, $1) {
-      if (module2.coffeeCompat)
-        return;
-      return $skip;
-    });
-    function CoffeeCompat(state) {
-      if (state.verbose)
-        console.log("ENTER:", "CoffeeCompat");
-      if (state.tokenize) {
-        return $TOKEN("CoffeeCompat", state, CoffeeCompat$0(state));
-      } else {
-        return CoffeeCompat$0(state);
-      }
-    }
-    var CoffeeCompatDoubleQuotedString$0 = $TS($S(CoffeeCompat, DoubleQuote, $Q($C(CoffeeCompatDoubleQuotedStringCharacters, CoffeeStringSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var CoffeeInterpolatedDoubleQuotedString$0 = $TS($S(CoffeeInterpolationEnabled, DoubleQuote, $Q($C(CoffeeDoubleQuotedStringCharacters, CoffeeStringSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
       var s = $2;
       var parts = $3;
       var e = $4;
@@ -3256,25 +3336,25 @@ var require_parser = __commonJS({
       s.token = e.token = "`";
       return [s, parts, e];
     });
-    function CoffeeCompatDoubleQuotedString(state) {
+    function CoffeeInterpolatedDoubleQuotedString(state) {
       if (state.verbose)
-        console.log("ENTER:", "CoffeeCompatDoubleQuotedString");
+        console.log("ENTER:", "CoffeeInterpolatedDoubleQuotedString");
       if (state.tokenize) {
-        return $TOKEN("CoffeeCompatDoubleQuotedString", state, CoffeeCompatDoubleQuotedString$0(state));
+        return $TOKEN("CoffeeInterpolatedDoubleQuotedString", state, CoffeeInterpolatedDoubleQuotedString$0(state));
       } else {
-        return CoffeeCompatDoubleQuotedString$0(state);
+        return CoffeeInterpolatedDoubleQuotedString$0(state);
       }
     }
-    var CoffeeCompatDoubleQuotedStringCharacters$0 = $TR($EXPECT($R13, fail, 'CoffeeCompatDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R13, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       return { $loc, token: $0 };
     });
-    function CoffeeCompatDoubleQuotedStringCharacters(state) {
+    function CoffeeDoubleQuotedStringCharacters(state) {
       if (state.verbose)
-        console.log("ENTER:", "CoffeeCompatDoubleQuotedStringCharacters");
+        console.log("ENTER:", "CoffeeDoubleQuotedStringCharacters");
       if (state.tokenize) {
-        return $TOKEN("CoffeeCompatDoubleQuotedStringCharacters", state, CoffeeCompatDoubleQuotedStringCharacters$0(state));
+        return $TOKEN("CoffeeDoubleQuotedStringCharacters", state, CoffeeDoubleQuotedStringCharacters$0(state));
       } else {
-        return CoffeeCompatDoubleQuotedStringCharacters$0(state);
+        return CoffeeDoubleQuotedStringCharacters$0(state);
       }
     }
     var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
@@ -3386,7 +3466,7 @@ var require_parser = __commonJS({
     var SingleLineComment$0 = $TR($EXPECT($R20, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       return { $loc, token: $0 };
     });
-    var SingleLineComment$1 = $S(CoffeeCompat, CoffeeSingleLineComment);
+    var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
     function SingleLineComment(state) {
       if (state.tokenize) {
         return $TOKEN("SingleLineComment", state, SingleLineComment$0(state) || SingleLineComment$1(state));
@@ -4412,7 +4492,7 @@ var require_parser = __commonJS({
       }
     }
     var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
-    var InterfaceProperty$1 = $S(MethodSignature, $E(TypeSuffix));
+    var InterfaceProperty$1 = MethodSignature;
     function InterfaceProperty(state) {
       if (state.tokenize) {
         return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state));
@@ -4490,7 +4570,7 @@ var require_parser = __commonJS({
       }
     }
     var TypeSuffix$0 = $T($S($E(QuestionMark), __, Colon, Type), function(value) {
-      return { "ts": true, "children": value };
+      return { "type": "TypeSuffix", "ts": true, "children": value };
     });
     function TypeSuffix(state) {
       if (state.verbose)
@@ -4501,8 +4581,16 @@ var require_parser = __commonJS({
         return TypeSuffix$0(state);
       }
     }
-    var ReturnTypeSuffix$0 = $T($S(__, Colon, $E($S(__, $EXPECT($L137, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
-      return { "ts": true, "children": value };
+    var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L137, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
+      if (!$3)
+        $0.splice(2, 1);
+      if ($1.length === 0)
+        $0.shift();
+      return {
+        type: "ReturnTypeAnnotation",
+        children: $0,
+        ts: true
+      };
     });
     function ReturnTypeSuffix(state) {
       if (state.verbose)
@@ -4513,7 +4601,11 @@ var require_parser = __commonJS({
         return ReturnTypeSuffix$0(state);
       }
     }
-    var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
+    var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
+      if (!$2)
+        return $1;
+      return $0;
+    });
     function TypePredicate(state) {
       if (state.verbose)
         console.log("ENTER:", "TypePredicate");
@@ -4533,7 +4625,11 @@ var require_parser = __commonJS({
         return Type$0(state);
       }
     }
-    var TypeBinary$0 = $S(TypeUnary, $Q($S(__, TypeBinaryOp, __, TypeUnary)));
+    var TypeBinary$0 = $TS($S(TypeUnary, $Q($S(__, TypeBinaryOp, __, TypeUnary))), function($skip, $loc, $0, $1, $2) {
+      if ($2.length)
+        return $0;
+      return $1;
+    });
     function TypeBinary(state) {
       if (state.verbose)
         console.log("ENTER:", "TypeBinary");
@@ -4543,7 +4639,13 @@ var require_parser = __commonJS({
         return TypeBinary$0(state);
       }
     }
-    var TypeUnary$0 = $S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix));
+    var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
+      if (!$3.length)
+        $0.pop();
+      if (!$1.length)
+        $0.shift();
+      return $0;
+    });
     function TypeUnary(state) {
       if (state.verbose)
         console.log("ENTER:", "TypeUnary");
@@ -4586,8 +4688,8 @@ var require_parser = __commonJS({
     var TypePrimary$0 = InterfaceBlock;
     var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
     var TypePrimary$2 = $S($Q(_), FunctionType);
-    var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
-    var TypePrimary$4 = $S($Q(_), TypeLiteral);
+    var TypePrimary$3 = $S($Q(_), TypeLiteral);
+    var TypePrimary$4 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
     function TypePrimary(state) {
       if (state.tokenize) {
         return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
@@ -4595,7 +4697,11 @@ var require_parser = __commonJS({
         return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
       }
     }
-    var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
+    var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
+      if ($2)
+        return $0;
+      return $1;
+    });
     function TypeConditional(state) {
       if (state.verbose)
         console.log("ENTER:", "TypeConditional");
@@ -4606,8 +4712,12 @@ var require_parser = __commonJS({
       }
     }
     var TypeLiteral$0 = Literal;
-    var TypeLiteral$1 = $EXPECT($L70, fail, 'TypeLiteral "void"');
-    var TypeLiteral$2 = $EXPECT($L140, fail, 'TypeLiteral "[]"');
+    var TypeLiteral$1 = $TV($EXPECT($L70, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
+      return { $loc, token: "void" };
+    });
+    var TypeLiteral$2 = $TV($EXPECT($L140, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
+      return { $loc, token: "[]" };
+    });
     function TypeLiteral(state) {
       if (state.tokenize) {
         return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -4615,8 +4725,12 @@ var require_parser = __commonJS({
         return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
       }
     }
-    var TypeBinaryOp$0 = $EXPECT($L68, fail, 'TypeBinaryOp "|"');
-    var TypeBinaryOp$1 = $EXPECT($L66, fail, 'TypeBinaryOp "&"');
+    var TypeBinaryOp$0 = $TV($EXPECT($L68, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
+      return { $loc, token: "|" };
+    });
+    var TypeBinaryOp$1 = $TV($EXPECT($L66, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
+      return { $loc, token: "&" };
+    });
     function TypeBinaryOp(state) {
       if (state.tokenize) {
         return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -4701,14 +4815,73 @@ var require_parser = __commonJS({
         return Shebang$0(state);
       }
     }
-    var DirectivePrologue$0 = $Q($S($R$0($EXPECT($R35, fail, "DirectivePrologue /[\\t ]*/")), StringLiteral, $TEXT(StatementDelimiter), EOS));
-    function DirectivePrologue(state) {
+    var CivetPrologue$0 = $T($S($EXPECT($R35, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
+      var content = value[2];
+      return content;
+    });
+    var CivetPrologue$1 = $T($S($EXPECT($R35, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
+      var content = value[2];
+      return content;
+    });
+    function CivetPrologue(state) {
+      if (state.tokenize) {
+        return $TOKEN("CivetPrologue", state, CivetPrologue$0(state) || CivetPrologue$1(state));
+      } else {
+        return CivetPrologue$0(state) || CivetPrologue$1(state);
+      }
+    }
+    var CivetPrologueContent$0 = $TS($S($EXPECT($L141, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R36, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
+      var options = $2;
+      return {
+        type: "CivetPrologue",
+        children: [],
+        config: Object.fromEntries(options)
+      };
+    });
+    function CivetPrologueContent(state) {
+      if (state.verbose)
+        console.log("ENTER:", "CivetPrologueContent");
+      if (state.tokenize) {
+        return $TOKEN("CivetPrologueContent", state, CivetPrologueContent$0(state));
+      } else {
+        return CivetPrologueContent$0(state);
+      }
+    }
+    var CivetOption$0 = $TR($EXPECT($R37, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      const optionName = $2.toLowerCase().replace(/-+([a-z]?)/g, (_2, l) => {
+        if (l)
+          return l.toUpperCase();
+        return "";
+      });
+      const value = $1 === "-" ? false : true;
+      return [optionName, value];
+    });
+    function CivetOption(state) {
       if (state.verbose)
-        console.log("ENTER:", "DirectivePrologue");
+        console.log("ENTER:", "CivetOption");
       if (state.tokenize) {
-        return $TOKEN("DirectivePrologue", state, DirectivePrologue$0(state));
+        return $TOKEN("CivetOption", state, CivetOption$0(state));
       } else {
-        return DirectivePrologue$0(state);
+        return CivetOption$0(state);
+      }
+    }
+    var UnknownPrologue$0 = $S($R$0($EXPECT($R35, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
+    function UnknownPrologue(state) {
+      if (state.verbose)
+        console.log("ENTER:", "UnknownPrologue");
+      if (state.tokenize) {
+        return $TOKEN("UnknownPrologue", state, UnknownPrologue$0(state));
+      } else {
+        return UnknownPrologue$0(state);
+      }
+    }
+    var DirectivePrologue$0 = CivetPrologue;
+    var DirectivePrologue$1 = UnknownPrologue;
+    function DirectivePrologue(state) {
+      if (state.tokenize) {
+        return $TOKEN("DirectivePrologue", state, DirectivePrologue$0(state) || DirectivePrologue$1(state));
+      } else {
+        return DirectivePrologue$0(state) || DirectivePrologue$1(state);
       }
     }
     var EOS$0 = $P(RestOfLine);
@@ -4721,7 +4894,7 @@ var require_parser = __commonJS({
         return EOS$0(state);
       }
     }
-    var EOL$0 = $R$0($EXPECT($R36, fail, "EOL /\\r\\n|\\n|\\r|$/"));
+    var EOL$0 = $R$0($EXPECT($R38, fail, "EOL /\\r\\n|\\n|\\r|$/"));
     function EOL(state) {
       if (state.verbose)
         console.log("ENTER:", "EOL");
@@ -4731,7 +4904,7 @@ var require_parser = __commonJS({
         return EOL$0(state);
       }
     }
-    var EOF$0 = $R$0($EXPECT($R37, fail, "EOF /$/"));
+    var EOF$0 = $R$0($EXPECT($R39, fail, "EOF /$/"));
     function EOF(state) {
       if (state.verbose)
         console.log("ENTER:", "EOF");
@@ -4885,12 +5058,65 @@ var require_parser = __commonJS({
         return InsertBreak$0(state);
       }
     }
+    var CoffeeCommentEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
+      if (module2.config.coffeeComment)
+        return;
+      return $skip;
+    });
+    function CoffeeCommentEnabled(state) {
+      if (state.verbose)
+        console.log("ENTER:", "CoffeeCommentEnabled");
+      if (state.tokenize) {
+        return $TOKEN("CoffeeCommentEnabled", state, CoffeeCommentEnabled$0(state));
+      } else {
+        return CoffeeCommentEnabled$0(state);
+      }
+    }
+    var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
+      if (module2.config.coffeeInterpolation)
+        return;
+      return $skip;
+    });
+    function CoffeeInterpolationEnabled(state) {
+      if (state.verbose)
+        console.log("ENTER:", "CoffeeInterpolationEnabled");
+      if (state.tokenize) {
+        return $TOKEN("CoffeeInterpolationEnabled", state, CoffeeInterpolationEnabled$0(state));
+      } else {
+        return CoffeeInterpolationEnabled$0(state);
+      }
+    }
     var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
       module2.currentIndent = 0;
       module2.indentLevels = [0];
       module2.verbose = false;
-      module2.coffeeCompat = false;
-      module2.implicitReturns = true;
+      module2.config = {
+        autoVar: false,
+        coffeeComment: false,
+        coffeeEq: false,
+        coffeeInterpolation: false,
+        implicitReturns: true
+      };
+      Object.defineProperty(module2.config, "coffeeCompat", {
+        set(b) {
+          if (b) {
+            this.autoVar = true;
+            this.coffeeComment = true;
+            this.coffeeEq = true;
+            this.coffeeInterpolation = true;
+            this.implicitReturns = true;
+          } else {
+            this.autoVar = false;
+            this.coffeeComment = false;
+            this.coffeeEq = false;
+            this.coffeeInterpolation = false;
+            this.implicitReturns = false;
+          }
+        }
+      });
+      module2.modifyString = function(str) {
+        return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
+      };
     });
     function Reset(state) {
       if (state.verbose)
@@ -4901,12 +5127,13 @@ var require_parser = __commonJS({
         return Reset$0(state);
       }
     }
-    var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
+    var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
       var directives = $2;
-      if (directives) {
-        const compatRe = /use coffee-compat/;
-        module2.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
-      }
+      directives.forEach((directive) => {
+        if (directive.type === "CivetPrologue") {
+          Object.assign(module2.config, directive.config);
+        }
+      });
       function hasReturnStatement(node) {
         if (!node)
           return false;
@@ -4948,7 +5175,6 @@ var require_parser = __commonJS({
         if (!Array.isArray(node))
           return;
         const [, exp] = node;
-        debugger;
         if (!exp)
           return;
         switch (exp.type) {
@@ -4960,8 +5186,10 @@ var require_parser = __commonJS({
           case "ThrowStatement":
           case "VariableDeclaration":
             return;
+          case "BlockStatement":
+            insertReturn(exp.expressions[exp.expressions.length - 1]);
+            return;
           case "IfStatement":
-            debugger;
             insertReturn(exp.children[2]);
             if (exp.children[3])
               insertReturn(exp.children[3][2]);
@@ -5018,9 +5246,6 @@ var require_parser = __commonJS({
         }
         return spacing;
       };
-      module2.modifyString = function(str) {
-        return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
-      };
       module2.dedentBlockSubstitutions = function($02) {
         const [s, strWithSubstitutions, e] = $02;
         if (strWithSubstitutions.length === 0) {
@@ -5081,7 +5306,7 @@ var require_parser = __commonJS({
         return Init$0(state);
       }
     }
-    var Indent$0 = $TV($Q($C($EXPECT($L141, fail, 'Indent "  "'), $EXPECT($L142, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
+    var Indent$0 = $TV($Q($C($EXPECT($L142, fail, 'Indent "  "'), $EXPECT($L143, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
       const level = $1.length;
       return {
         $loc,