@danielx/civet 0.2.12 → 0.2.15

package/README.md

@@ -46,6 +46,25 @@ createCompilerHost := (options: CompilerOptions, moduleSearchLocations : string[
     return fileCache[fileName]
 ```
 
+ESBuild Plugin
+---
+
+```coffee
+esbuild = require "esbuild"
+civetPlugin = require "@danielx/civet/esbuild-plugin"
+
+esbuild.build
+  entryPoints: ['source/main.civet']
+  bundle: true
+  platform: 'node'
+  outfile: 'dist/main.js'
+  plugins: [
+    civetPlugin
+  ]
+.catch -> process.exit 1
+
+```
+
 Things Kept from CoffeeScript
 ---
 

package/dist/browser.js

@@ -445,6 +445,8 @@ var Civet = (() => {
         ApplicationStart,
         AdditionalReservedWords,
         MemberExpression,
+        MemberExpressionRest,
+        PropertyAccess,
         SuperProperty,
         MetaProperty,
         Parameters,
@@ -463,7 +465,8 @@ var Civet = (() => {
         ThinArrowFunction,
         Block,
         BracedBlock,
-        SingleNestedBlockExpression,
+        SingleNestedExpression,
+        SingleNestedBlockStatement,
         NestedBlockExpressions,
         BlockExpression,
         Literal,
@@ -529,6 +532,8 @@ var Civet = (() => {
         Condition,
         ExpressionStatement,
         KeywordStatement,
+        MaybeNestedExpression,
+        Return,
         ImportDeclaration,
         ImportClause,
         NameSpaceImport,
@@ -547,6 +552,7 @@ var Civet = (() => {
         Declaration,
         HoistableDeclaration,
         LexicalDeclaration,
+        ConstAssignment,
         LexicalBinding,
         Initializer,
         VariableStatement,
@@ -632,6 +638,7 @@ var Civet = (() => {
         EOS,
         EOL,
         EOF,
+        Debugger,
         InsertOpenParen,
         InsertCloseParen,
         InsertOpenBrace,
@@ -645,7 +652,8 @@ var Civet = (() => {
         Indent,
         PushIndent,
         PopIndent,
-        Nested
+        Nested,
+        NestedFurther
       });
       var $L0 = $L(",");
       var $L1 = $L("(");
@@ -671,9 +679,9 @@ var Civet = (() => {
       var $L21 = $L("new");
       var $L22 = $L("super");
       var $L23 = $L("import");
-      var $L24 = $L("[");
-      var $L25 = $L("]");
-      var $L26 = $L(".");
+      var $L24 = $L(".");
+      var $L25 = $L("[");
+      var $L26 = $L("]");
       var $L27 = $L("::");
       var $L28 = $L("super[");
       var $L29 = $L("new.target");
@@ -757,8 +765,8 @@ var Civet = (() => {
       var $L107 = $L("break");
       var $L108 = $L("continue");
       var $L109 = $L("debugger");
-      var $L110 = $L("return");
-      var $L111 = $L("throw");
+      var $L110 = $L("throw");
+      var $L111 = $L("return");
       var $L112 = $L("import type");
       var $L113 = $L("from");
       var $L114 = $L("export");
@@ -931,7 +939,9 @@ var Civet = (() => {
         }
       }
       var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
-      var UnaryPostfix$1 = $S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type);
+      var UnaryPostfix$1 = $T($S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type), function(value) {
+        return { "ts": true, "children": value };
+      });
       function UnaryPostfix(state) {
         if (state.tokenize) {
           return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
@@ -1002,7 +1012,7 @@ var Civet = (() => {
           return FatArrow$0(state);
         }
       }
-      var ConciseBody$0 = $S(EOS, SingleNestedBlockExpression);
+      var ConciseBody$0 = $S(EOS, SingleNestedBlockStatement);
       var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
       var ConciseBody$2 = BracedBlock;
       function ConciseBody(state) {
@@ -1071,7 +1081,7 @@ var Civet = (() => {
           return ClassExpression$0(state);
         }
       }
-      var ClassHeritage$0 = $S(ExtendsToken, __, $S(MemberExpression, $Q(CallExpressionRest)));
+      var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
       function ClassHeritage(state) {
         if (state.verbose)
           console.log("ENTER:", "ClassHeritage");
@@ -1150,8 +1160,8 @@ var Civet = (() => {
         var ref = value[1];
         return ["this.", ref];
       });
-      var This$2 = $T($EXPECT($L19, fail, 'This "@"'), function(value) {
-        return "this";
+      var This$2 = $TV($EXPECT($L19, fail, 'This "@"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "this" };
       });
       function This(state) {
         if (state.tokenize) {
@@ -1169,7 +1179,7 @@ var Civet = (() => {
           return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
         }
       }
-      var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), MemberExpression);
+      var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), CallExpression);
       function NewExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "NewExpression");
@@ -1181,7 +1191,7 @@ var Civet = (() => {
       }
       var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
       var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
-      var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest), $E(SpacedApplication));
+      var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
       function CallExpression(state) {
         if (state.tokenize) {
           return $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
@@ -1190,23 +1200,17 @@ var Civet = (() => {
         }
       }
       var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
-      var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
-      var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
-      var CallExpressionRest$3 = $TS($S($EXPECT($L27, fail, 'CallExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
-        var id = $2;
-        if (id)
-          return [".prototype.", id];
-        return ".prototype";
-      });
-      var CallExpressionRest$4 = TemplateLiteral;
+      var CallExpressionRest$1 = MemberExpressionRest;
+      var CallExpressionRest$2 = SpacedApplication;
+      var CallExpressionRest$3 = TemplateLiteral;
       function CallExpressionRest(state) {
         if (state.tokenize) {
-          return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state) || CallExpressionRest$4(state));
+          return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state));
         } else {
-          return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state) || CallExpressionRest$4(state);
+          return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
         }
       }
-      var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
+      var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L24, fail, 'OptionalShorthand "."'), InsertDot));
       function OptionalShorthand(state) {
         if (state.verbose)
           console.log("ENTER:", "OptionalShorthand");
@@ -1216,7 +1220,7 @@ var Civet = (() => {
           return OptionalShorthand$0(state);
         }
       }
-      var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
+      var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
       function SpacedApplication(state) {
         if (state.verbose)
           console.log("ENTER:", "SpacedApplication");
@@ -1250,7 +1254,7 @@ var Civet = (() => {
           return AdditionalReservedWords$0(state);
         }
       }
-      var MemberExpression$0 = $S(PrimaryExpression, $Q(CallExpressionRest));
+      var MemberExpression$0 = $S(PrimaryExpression, $Q(MemberExpressionRest));
       var MemberExpression$1 = $S($Q(TrailingComment), SuperProperty);
       var MemberExpression$2 = $S($Q(TrailingComment), MetaProperty);
       function MemberExpression(state) {
@@ -1260,7 +1264,32 @@ var Civet = (() => {
           return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
         }
       }
-      var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
+      var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L25, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L26, fail, 'MemberExpressionRest "]"'));
+      var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
+      var MemberExpressionRest$2 = $TS($S($EXPECT($L27, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
+        var id = $2;
+        if (id)
+          return [".prototype.", id];
+        return ".prototype";
+      });
+      function MemberExpressionRest(state) {
+        if (state.tokenize) {
+          return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state));
+        } else {
+          return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
+        }
+      }
+      var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L24, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
+      function PropertyAccess(state) {
+        if (state.verbose)
+          console.log("ENTER:", "PropertyAccess");
+        if (state.tokenize) {
+          return $TOKEN("PropertyAccess", state, PropertyAccess$0(state));
+        } else {
+          return PropertyAccess$0(state);
+        }
+      }
+      var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L26, fail, 'SuperProperty "]"'));
       function SuperProperty(state) {
         if (state.verbose)
           console.log("ENTER:", "SuperProperty");
@@ -1344,7 +1373,7 @@ var Civet = (() => {
           return ObjectBindingPattern$0(state);
         }
       }
-      var ArrayBindingPattern$0 = $S($EXPECT($L24, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L25, fail, 'ArrayBindingPattern "]"'));
+      var ArrayBindingPattern$0 = $S($EXPECT($L25, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L26, fail, 'ArrayBindingPattern "]"'));
       function ArrayBindingPattern(state) {
         if (state.verbose)
           console.log("ENTER:", "ArrayBindingPattern");
@@ -1448,19 +1477,34 @@ var Civet = (() => {
           return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
         }
       }
-      var SingleNestedBlockExpression$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), $S(PopIndent, $N($EXPECT($L31, fail, 'SingleNestedBlockExpression ""')))), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
+      var SingleNestedExpression$0 = $TS($S(PushIndent, $E($S(Nested, Expression, StatementDelimiter)), $C($S($N($S(Nested, Expression)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
         var exp = $2;
         if (exp)
           return exp;
         return $skip;
       });
-      function SingleNestedBlockExpression(state) {
+      function SingleNestedExpression(state) {
         if (state.verbose)
-          console.log("ENTER:", "SingleNestedBlockExpression");
+          console.log("ENTER:", "SingleNestedExpression");
         if (state.tokenize) {
-          return $TOKEN("SingleNestedBlockExpression", state, SingleNestedBlockExpression$0(state));
+          return $TOKEN("SingleNestedExpression", state, SingleNestedExpression$0(state));
         } else {
-          return SingleNestedBlockExpression$0(state);
+          return SingleNestedExpression$0(state);
+        }
+      }
+      var SingleNestedBlockStatement$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
+        var exp = $2;
+        if (exp)
+          return exp;
+        return $skip;
+      });
+      function SingleNestedBlockStatement(state) {
+        if (state.verbose)
+          console.log("ENTER:", "SingleNestedBlockStatement");
+        if (state.tokenize) {
+          return $TOKEN("SingleNestedBlockStatement", state, SingleNestedBlockStatement$0(state));
+        } else {
+          return SingleNestedBlockStatement$0(state);
         }
       }
       var NestedBlockExpressions$0 = $TS($S(PushIndent, $Q(BlockExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
@@ -1521,7 +1565,12 @@ var Civet = (() => {
           return Identifier$0(state);
         }
       }
-      var IdentifierName$0 = $R$0($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
+      var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+        return {
+          $loc,
+          token: $0
+        };
+      });
       function IdentifierName(state) {
         if (state.verbose)
           console.log("ENTER:", "IdentifierName");
@@ -1541,8 +1590,8 @@ var Civet = (() => {
           return IdentifierReference$0(state);
         }
       }
-      var ArrayLiteral$0 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
-      var ArrayLiteral$1 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
+      var ArrayLiteral$0 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
+      var ArrayLiteral$1 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
       function ArrayLiteral(state) {
         if (state.tokenize) {
           return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1576,8 +1625,8 @@ var Civet = (() => {
         }
       }
       var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
-      var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
-      var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"'))), function(value) {
+      var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
+      var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"'))), function(value) {
         return ",";
       });
       var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1705,7 +1754,7 @@ var Civet = (() => {
       var PropertyName$0 = NumericLiteral;
       var PropertyName$1 = StringLiteral;
       var PropertyName$2 = IdentifierName;
-      var PropertyName$3 = $S($EXPECT($L24, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
+      var PropertyName$3 = $S($EXPECT($L25, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
       function PropertyName(state) {
         if (state.tokenize) {
           return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -2242,14 +2291,32 @@ var Civet = (() => {
       var KeywordStatement$0 = $S($EXPECT($L107, fail, 'KeywordStatement "break"'), NonIdContinue);
       var KeywordStatement$1 = $S($EXPECT($L108, fail, 'KeywordStatement "continue"'), NonIdContinue);
       var KeywordStatement$2 = $S($EXPECT($L109, fail, 'KeywordStatement "debugger"'), NonIdContinue);
-      var KeywordStatement$3 = $S($EXPECT($L110, fail, 'KeywordStatement "return"'), NonIdContinue, Expression);
-      var KeywordStatement$4 = $S($EXPECT($L110, fail, 'KeywordStatement "return"'), NonIdContinue);
-      var KeywordStatement$5 = $S($EXPECT($L111, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
+      var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
+      var KeywordStatement$4 = $S($EXPECT($L110, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
       function KeywordStatement(state) {
         if (state.tokenize) {
-          return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
+          return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
         } else {
-          return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
+          return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state);
+        }
+      }
+      var MaybeNestedExpression$0 = $S($N(EOS), $Q(TrailingComment), Expression);
+      var MaybeNestedExpression$1 = $S($Y(EOS), ObjectLiteral);
+      function MaybeNestedExpression(state) {
+        if (state.tokenize) {
+          return $TOKEN("MaybeNestedExpression", state, MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state));
+        } else {
+          return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
+        }
+      }
+      var Return$0 = $S($EXPECT($L111, fail, 'Return "return"'), NonIdContinue);
+      function Return(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Return");
+        if (state.tokenize) {
+          return $TOKEN("Return", state, Return$0(state));
+        } else {
+          return Return$0(state);
         }
       }
       var ImportDeclaration$0 = $T($S($EXPECT($L112, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
@@ -2423,12 +2490,21 @@ var Civet = (() => {
         }
       }
       var LexicalDeclaration$0 = $S($C($EXPECT($L98, fail, 'LexicalDeclaration "let"'), $EXPECT($L99, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
-      var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L115, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
-        var bind = value[0];
-        var suffix = value[1];
-        var ws = value[2];
-        var exp = value[4];
-        return ["const ", bind, suffix, ws, "=", exp];
+      var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+        var bind = $1;
+        var suffix = $2;
+        var ws = $3;
+        var ca = $4;
+        var exp = $5;
+        return [
+          { token: "const", $loc: ca.$loc },
+          " ",
+          bind,
+          suffix,
+          ws,
+          { token: "=", $loc: ca.$loc },
+          exp
+        ];
       });
       function LexicalDeclaration(state) {
         if (state.tokenize) {
@@ -2437,6 +2513,18 @@ var Civet = (() => {
           return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
         }
       }
+      var ConstAssignment$0 = $TV($EXPECT($L115, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $0 };
+      });
+      function ConstAssignment(state) {
+        if (state.verbose)
+          console.log("ENTER:", "ConstAssignment");
+        if (state.tokenize) {
+          return $TOKEN("ConstAssignment", state, ConstAssignment$0(state));
+        } else {
+          return ConstAssignment$0(state);
+        }
+      }
       var LexicalBinding$0 = $S(BindingPattern, $E(TypeSuffix), Initializer);
       var LexicalBinding$1 = $S(BindingIdentifier, $E(TypeSuffix), $E(Initializer));
       function LexicalBinding(state) {
@@ -2864,7 +2952,7 @@ var Civet = (() => {
           return JSXFragment$0(state);
         }
       }
-      var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L26, fail, 'JSXElementName "."'), JSXIdentifierName))));
+      var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L24, fail, 'JSXElementName "."'), JSXIdentifierName))));
       function JSXElementName(state) {
         if (state.verbose)
           console.log("ENTER:", "JSXElementName");
@@ -3049,7 +3137,7 @@ var Civet = (() => {
           return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
         }
       }
-      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L129, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L24, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L25, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
+      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L129, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L25, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L26, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
       function TypeIndexSignature(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeIndexSignature");
@@ -3152,7 +3240,7 @@ var Civet = (() => {
           return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
         }
       }
-      var TypeIndexedAccess$0 = $S(__, $EXPECT($L24, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L25, fail, 'TypeIndexedAccess "]"'));
+      var TypeIndexedAccess$0 = $S(__, $EXPECT($L25, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L26, fail, 'TypeIndexedAccess "]"'));
       function TypeIndexedAccess(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeIndexedAccess");
@@ -3165,7 +3253,7 @@ var Civet = (() => {
       var TypePrimary$0 = InterfaceBlock;
       var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
       var TypePrimary$2 = $S($Q(_), FunctionType);
-      var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L26, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
+      var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L24, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
       var TypePrimary$4 = $S($Q(_), TypeLiteral);
       function TypePrimary(state) {
         if (state.tokenize) {
@@ -3320,6 +3408,18 @@ var Civet = (() => {
           return EOF$0(state);
         }
       }
+      var Debugger$0 = $TV($EXPECT($L31, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
+        debugger;
+      });
+      function Debugger(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Debugger");
+        if (state.tokenize) {
+          return $TOKEN("Debugger", state, Debugger$0(state));
+        } else {
+          return Debugger$0(state);
+        }
+      }
       var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
         return "(";
       });
@@ -3519,6 +3619,31 @@ var Civet = (() => {
           return Nested$0(state);
         }
       }
+      var NestedFurther$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
+        var eos = $1;
+        var indent = $2;
+        const currentIndent = global.indentLevels[global.indentLevels.length - 1];
+        if (global.verbose) {
+          console.log("global indent", global.currentIndent);
+          console.log("Indented", indent, currentIndent);
+        }
+        if (indent !== currentIndent + 1) {
+          if (global.verbose) {
+            console.log("skipped nested");
+          }
+          return $skip;
+        }
+        return [eos, "".padStart(indent * 2)];
+      });
+      function NestedFurther(state) {
+        if (state.verbose)
+          console.log("ENTER:", "NestedFurther");
+        if (state.tokenize) {
+          return $TOKEN("NestedFurther", state, NestedFurther$0(state));
+        } else {
+          return NestedFurther$0(state);
+        }
+      }
       module.exports = {
         parse
       };
@@ -3529,11 +3654,18 @@ var Civet = (() => {
   var require_generate = __commonJS({
     "source/generate.coffee"(exports, module) {
       var gen;
+      var prune;
       gen = function(node, options) {
+        var $loc, token;
         if (node === null || node === void 0) {
           return "";
         }
         if (typeof node === "string") {
+          if (options != null) {
+            if (typeof options.updateSourceMap === "function") {
+              options.updateSourceMap(node);
+            }
+          }
           return node;
         }
         if (Array.isArray(node)) {
@@ -3542,19 +3674,55 @@ var Civet = (() => {
           }).join("");
         }
         if (typeof node === "object") {
-          if ((options != null ? options.js : void 0) && node.ts) {
+          if (options.js && node.ts) {
             return "";
           }
+          if (node.$loc != null) {
+            ({ token, $loc } = node);
+            if (options != null) {
+              if (typeof options.updateSourceMap === "function") {
+                options.updateSourceMap(token, $loc.pos);
+              }
+            }
+            return token;
+          }
           if (!node.children) {
             throw new Error("Unknown node", JSON.stringify(node));
           }
-          return node.children.map(function(child) {
-            return gen(child, options);
-          }).join("");
+          return gen(node.children, options);
         }
         throw new Error("Unknown node", JSON.stringify(node));
       };
       module.exports = gen;
+      prune = function(node) {
+        var a;
+        if (node === null || node === void 0) {
+          return;
+        }
+        if (node.length === 0) {
+          return;
+        }
+        if (Array.isArray(node)) {
+          a = node.map(function(n) {
+            return prune(n);
+          }).filter(function(n) {
+            return !!n;
+          });
+          if (a.length > 1) {
+            return a;
+          }
+          if (a.length === 1) {
+            return a[0];
+          }
+          return;
+        }
+        if (node.children != null) {
+          node.children = prune(node.children);
+          return node;
+        }
+        return node;
+      };
+      gen.prune = prune;
     }
   });
 
@@ -3568,7 +3736,9 @@ var Civet = (() => {
       module.exports = {
         parse,
         compile: function(src, options) {
-          return gen(parse(src), options);
+          return gen(parse(src, {
+            filename: options != null ? options.filename : void 0
+          }), options);
         },
         generate: gen
       };