@danielx/civet 0.2.12 → 0.2.15

package/dist/main.js

@@ -444,6 +444,8 @@ var require_parser = __commonJS({
       ApplicationStart,
       AdditionalReservedWords,
       MemberExpression,
+      MemberExpressionRest,
+      PropertyAccess,
       SuperProperty,
       MetaProperty,
       Parameters,
@@ -462,7 +464,8 @@ var require_parser = __commonJS({
       ThinArrowFunction,
       Block,
       BracedBlock,
-      SingleNestedBlockExpression,
+      SingleNestedExpression,
+      SingleNestedBlockStatement,
       NestedBlockExpressions,
       BlockExpression,
       Literal,
@@ -528,6 +531,8 @@ var require_parser = __commonJS({
       Condition,
       ExpressionStatement,
       KeywordStatement,
+      MaybeNestedExpression,
+      Return,
       ImportDeclaration,
       ImportClause,
       NameSpaceImport,
@@ -546,6 +551,7 @@ var require_parser = __commonJS({
       Declaration,
       HoistableDeclaration,
       LexicalDeclaration,
+      ConstAssignment,
       LexicalBinding,
       Initializer,
       VariableStatement,
@@ -631,6 +637,7 @@ var require_parser = __commonJS({
       EOS,
       EOL,
       EOF,
+      Debugger,
       InsertOpenParen,
       InsertCloseParen,
       InsertOpenBrace,
@@ -644,7 +651,8 @@ var require_parser = __commonJS({
       Indent,
       PushIndent,
       PopIndent,
-      Nested
+      Nested,
+      NestedFurther
     });
     var $L0 = $L(",");
     var $L1 = $L("(");
@@ -670,9 +678,9 @@ var require_parser = __commonJS({
     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");
@@ -756,8 +764,8 @@ var require_parser = __commonJS({
     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");
@@ -930,7 +938,9 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -1001,7 +1011,7 @@ var require_parser = __commonJS({
         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) {
@@ -1070,7 +1080,7 @@ var require_parser = __commonJS({
         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");
@@ -1149,8 +1159,8 @@ var require_parser = __commonJS({
       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) {
@@ -1168,7 +1178,7 @@ var require_parser = __commonJS({
         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");
@@ -1180,7 +1190,7 @@ var require_parser = __commonJS({
     }
     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));
@@ -1189,23 +1199,17 @@ var require_parser = __commonJS({
       }
     }
     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");
@@ -1215,7 +1219,7 @@ var require_parser = __commonJS({
         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");
@@ -1249,7 +1253,7 @@ var require_parser = __commonJS({
         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) {
@@ -1259,7 +1263,32 @@ var require_parser = __commonJS({
         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");
@@ -1343,7 +1372,7 @@ var require_parser = __commonJS({
         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");
@@ -1447,19 +1476,34 @@ var require_parser = __commonJS({
         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) {
@@ -1520,7 +1564,12 @@ var require_parser = __commonJS({
         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");
@@ -1540,8 +1589,8 @@ var require_parser = __commonJS({
         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));
@@ -1575,8 +1624,8 @@ var require_parser = __commonJS({
       }
     }
     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) {
@@ -1704,7 +1753,7 @@ var require_parser = __commonJS({
     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));
@@ -2241,14 +2290,32 @@ var require_parser = __commonJS({
     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) {
@@ -2422,12 +2489,21 @@ var require_parser = __commonJS({
       }
     }
     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) {
@@ -2436,6 +2512,18 @@ var require_parser = __commonJS({
         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) {
@@ -2863,7 +2951,7 @@ var require_parser = __commonJS({
         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");
@@ -3048,7 +3136,7 @@ var require_parser = __commonJS({
         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");
@@ -3151,7 +3239,7 @@ var require_parser = __commonJS({
         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");
@@ -3164,7 +3252,7 @@ var require_parser = __commonJS({
     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) {
@@ -3319,6 +3407,18 @@ var require_parser = __commonJS({
         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 "(";
     });
@@ -3518,6 +3618,31 @@ var require_parser = __commonJS({
         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);
+      }
+    }
     module2.exports = {
       parse: parse2
     };
@@ -3528,11 +3653,18 @@ var require_parser = __commonJS({
 var require_generate = __commonJS({
   "source/generate.coffee"(exports2, module2) {
     var gen2;
+    var prune;
     gen2 = 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)) {
@@ -3541,19 +3673,55 @@ var require_generate = __commonJS({
         }).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 gen2(child, options);
-        }).join("");
+        return gen2(node.children, options);
       }
       throw new Error("Unknown node", JSON.stringify(node));
     };
     module2.exports = gen2;
+    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;
+    };
+    gen2.prune = prune;
   }
 });
 
@@ -3565,7 +3733,9 @@ gen = require_generate();
 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
 };

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 declare module "@danielx/civet" {
   export type CivetAST = unknown;
   export type CompileOptions = {
+    filename?: string
     js?: boolean
   }
 

package/esbuild-plugin.js

@@ -0,0 +1,27 @@
+const { readFile } = require('fs/promises');
+const path = require('path');
+const { compile } = require("./");
+
+module.exports = {
+  name: 'civet',
+  setup(build) {
+    build.onLoad({
+      filter: /\.civet/,
+    }, function(args) {
+      return readFile(args.path, 'utf8')
+      .then(function(source) {
+        const filename = path.relative(process.cwd(), args.path);
+        return {
+          contents: compile(source, { filename, js: true }),
+        };
+      })
+      .catch(function(e) {
+        return {
+          errors: [{
+            text: e.message,
+          }],
+        };
+      });
+    });
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.2.12",
+  "version": "0.2.15",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "types": "dist/types.d.ts",
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist/",
+    "esbuild-plugin.js",
     "register.js",
     "register.mjs"
   ],

package/register.mjs

@@ -7,23 +7,24 @@ const baseURL = pathToFileURL(process.cwd() + '/').href;
 
 const extensionsRegex = /\.civet$/;
 
-export async function resolve(specifier, context, defaultResolve) {
+export async function resolve(specifier, context, next) {
   const { parentURL = baseURL } = context;
 
   if (extensionsRegex.test(specifier)) {
     return {
-      format: "civet",
+      shortCircuit: true,
+      format: "module",
       url: new URL(specifier, parentURL).href,
     };
   }
 
   // Let Node.js handle all other specifiers.
-  return defaultResolve(specifier, context, defaultResolve);
+  return next(specifier, context);
 }
 
-export async function load(url, context, defaultLoad) {
+export async function load(url, context, next) {
   if (extensionsRegex.test(url)) {
-    const { source: rawSource } = await defaultLoad(url, { format: "civet" });
+    const { source: rawSource } = await next(url, { format: "module" });
 
     return {
       format: "module",
@@ -32,7 +33,7 @@ export async function load(url, context, defaultLoad) {
   }
 
   // Let Node.js handle all other URLs.
-  return defaultLoad(url, context, defaultLoad);
+  return next(url, context);
 }
 
 // Also transform CommonJS files.