@danielx/civet 0.4.7 → 0.4.9

package/dist/browser.js

@@ -456,6 +456,7 @@ var Civet = (() => {
         SuperProperty,
         MetaProperty,
         Parameters,
+        NonEmptyParameters,
         ParameterElement,
         ParameterElementDelimiter,
         BindingIdentifier,
@@ -476,6 +477,7 @@ var Civet = (() => {
         Arrow,
         Block,
         BracedOrEmptyBlock,
+        EmptyBlock,
         BracedBlock,
         SingleNestedExpression,
         NestedBlockExpressions,
@@ -587,9 +589,8 @@ var Civet = (() => {
         TripleDoubleStringCharacters,
         TripleSingleStringCharacters,
         CoffeeStringSubstitution,
-        CoffeeCompat,
-        CoffeeCompatDoubleQuotedString,
-        CoffeeCompatDoubleQuotedStringCharacters,
+        CoffeeInterpolatedDoubleQuotedString,
+        CoffeeDoubleQuotedStringCharacters,
         RegularExpressionLiteral,
         RegularExpressionBody,
         RegExpCharacter,
@@ -717,6 +718,10 @@ var Civet = (() => {
         TypeConstraint,
         TypeParameterDelimiter,
         Shebang,
+        CivetPrologue,
+        CivetPrologueContent,
+        CivetOption,
+        UnknownPrologue,
         DirectivePrologue,
         EOS,
         EOL,
@@ -733,6 +738,8 @@ var Civet = (() => {
         InsertSpace,
         InsertDot,
         InsertBreak,
+        CoffeeCommentEnabled,
+        CoffeeInterpolationEnabled,
         Reset,
         Init,
         Indent,
@@ -884,8 +891,9 @@ var Civet = (() => {
       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"));
@@ -922,8 +930,10 @@ var Civet = (() => {
       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)
@@ -1179,7 +1189,19 @@ var Civet = (() => {
         }
       }
       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 (module.config.implicitReturns && !isVoid && isBlock) {
+          module.addImplicitReturns(expOrBlock);
+        }
+        return {
+          type: "FunctionExpression",
+          children: $0
+        };
+      });
       function ArrowFunction(state) {
         if (state.tokenize) {
           return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
@@ -1202,11 +1224,17 @@ var Civet = (() => {
           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));
@@ -1522,7 +1550,7 @@ var Civet = (() => {
           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: "()" };
       });
@@ -1533,6 +1561,16 @@ var Civet = (() => {
           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)
@@ -1701,8 +1739,17 @@ var Civet = (() => {
         }
       }
       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 (module.config.implicitReturns && !isVoid) {
+          module.addImplicitReturns(block);
+        }
+        return {
+          type: "FunctionExpression",
+          children: $0
+        };
       });
       function FunctionExpression(state) {
         if (state.tokenize) {
@@ -1716,7 +1763,8 @@ var Civet = (() => {
         var suffix = $2;
         var arrow = $4;
         var block = $5;
-        if (module.implicitReturns && suffix?.children[3] !== "void") {
+        const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
+        if (module.config.implicitReturns && !isVoid) {
           block = module.addImplicitReturns(block);
         }
         return {
@@ -1768,9 +1816,7 @@ var Civet = (() => {
         }
       }
       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));
@@ -1778,6 +1824,18 @@ var Civet = (() => {
           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 };
@@ -2101,7 +2159,17 @@ var Civet = (() => {
           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 (module.config.implicitReturns && !isConstructor && !isSet && !isVoid) {
+          block = module.addImplicitReturns(block);
+        }
+        return $0;
+      });
       function MethodDefinition(state) {
         if (state.verbose)
           console.log("ENTER:", "MethodDefinition");
@@ -2122,8 +2190,26 @@ var Civet = (() => {
           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));
@@ -2140,7 +2226,12 @@ var Civet = (() => {
           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");
@@ -2215,7 +2306,7 @@ var Civet = (() => {
       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 (module.coffeeCompat)
+        if (module.config.coffeeEq)
           return "!==";
         return $1;
       });
@@ -2224,7 +2315,7 @@ var Civet = (() => {
       });
       var BinaryOpSymbol$16 = $EXPECT($L57, fail, 'BinaryOpSymbol "==="');
       var BinaryOpSymbol$17 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
-        if (module.coffeeCompat)
+        if (module.config.coffeeEq)
           return "===";
         return $1;
       });
@@ -2345,7 +2436,10 @@ var Civet = (() => {
           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");
@@ -3135,7 +3229,7 @@ var Civet = (() => {
         var e = $3;
         return [s, module.dedentBlockString(str), e];
       });
-      var StringLiteral$2 = CoffeeCompatDoubleQuotedString;
+      var StringLiteral$2 = CoffeeInterpolatedDoubleQuotedString;
       var StringLiteral$3 = BasicStringLiteral;
       function StringLiteral(state) {
         if (state.tokenize) {
@@ -3223,21 +3317,7 @@ var Civet = (() => {
           return CoffeeStringSubstitution$0(state);
         }
       }
-      var CoffeeCompat$0 = $TV($EXPECT($L1, fail, 'CoffeeCompat ""'), function($skip, $loc, $0, $1) {
-        if (module.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;
@@ -3257,25 +3337,25 @@ var Civet = (() => {
         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) {
@@ -3387,7 +3467,7 @@ var Civet = (() => {
       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));
@@ -4413,7 +4493,7 @@ var Civet = (() => {
         }
       }
       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));
@@ -4491,7 +4571,7 @@ var Civet = (() => {
         }
       }
       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)
@@ -4502,8 +4582,16 @@ var Civet = (() => {
           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)
@@ -4514,7 +4602,11 @@ var Civet = (() => {
           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");
@@ -4534,7 +4626,11 @@ var Civet = (() => {
           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");
@@ -4544,7 +4640,13 @@ var Civet = (() => {
           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");
@@ -4587,8 +4689,8 @@ var Civet = (() => {
       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));
@@ -4596,7 +4698,11 @@ var Civet = (() => {
           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");
@@ -4607,8 +4713,12 @@ var Civet = (() => {
         }
       }
       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));
@@ -4616,8 +4726,12 @@ var Civet = (() => {
           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));
@@ -4702,14 +4816,73 @@ var Civet = (() => {
           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);
@@ -4722,7 +4895,7 @@ var Civet = (() => {
           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");
@@ -4732,7 +4905,7 @@ var Civet = (() => {
           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");
@@ -4886,12 +5059,65 @@ var Civet = (() => {
           return InsertBreak$0(state);
         }
       }
+      var CoffeeCommentEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
+        if (module.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 (module.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) {
         module.currentIndent = 0;
         module.indentLevels = [0];
         module.verbose = false;
-        module.coffeeCompat = false;
-        module.implicitReturns = true;
+        module.config = {
+          autoVar: false,
+          coffeeComment: false,
+          coffeeEq: false,
+          coffeeInterpolation: false,
+          implicitReturns: true
+        };
+        Object.defineProperty(module.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;
+            }
+          }
+        });
+        module.modifyString = function(str) {
+          return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
+        };
       });
       function Reset(state) {
         if (state.verbose)
@@ -4902,12 +5128,13 @@ var Civet = (() => {
           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/;
-          module.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
-        }
+        directives.forEach((directive) => {
+          if (directive.type === "CivetPrologue") {
+            Object.assign(module.config, directive.config);
+          }
+        });
         function hasReturnStatement(node) {
           if (!node)
             return false;
@@ -4949,7 +5176,6 @@ var Civet = (() => {
           if (!Array.isArray(node))
             return;
           const [, exp] = node;
-          debugger;
           if (!exp)
             return;
           switch (exp.type) {
@@ -4961,8 +5187,10 @@ var Civet = (() => {
             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]);
@@ -5019,9 +5247,6 @@ var Civet = (() => {
           }
           return spacing;
         };
-        module.modifyString = function(str) {
-          return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
-        };
         module.dedentBlockSubstitutions = function($02) {
           const [s, strWithSubstitutions, e] = $02;
           if (strWithSubstitutions.length === 0) {
@@ -5082,7 +5307,7 @@ var Civet = (() => {
           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,