@danielx/civet 0.6.71 → 0.6.73

package/dist/browser.js

@@ -2262,9 +2262,17 @@ var Civet = (() => {
       const isMethod = f.type === "MethodDefinition";
       const isConstructor = isMethod && name === "constructor";
       const isVoid = isVoidType(returnType2?.t) || async && isPromiseVoidType(returnType2?.t) || !async && generator && isGeneratorVoidType(returnType2?.t);
-      const isBlock = block?.type === "BlockStatement";
-      if (!isVoid && !set && !isConstructor && isBlock) {
-        insertReturn(block);
+      if (block?.type === "BlockStatement") {
+        if (isVoid || set || isConstructor) {
+          if (block.bare && block.implicitlyReturned) {
+            block.children = [" {", ...block.children, " }"];
+            block.bare = block.implicitlyReturned = false;
+          }
+        } else {
+          if (!block.implicitlyReturned) {
+            insertReturn(block);
+          }
+        }
       }
     }
   }
@@ -2671,8 +2679,8 @@ var Civet = (() => {
     }
   }
   function aggregateDuplicateBindings(bindings, ReservedWord) {
-    const props = gatherRecursiveAll(bindings, (n) => n.type === "BindingProperty");
-    const arrayBindings = gatherRecursiveAll(bindings, (n) => n.type === "ArrayBindingPattern");
+    const props = gatherRecursiveAll(bindings, ($3) => $3.type === "BindingProperty");
+    const arrayBindings = gatherRecursiveAll(bindings, ($4) => $4.type === "ArrayBindingPattern");
     arrayBindings.forEach((a) => {
       const { elements } = a;
       return elements.forEach((element) => {
@@ -2702,20 +2710,22 @@ var Civet = (() => {
       }
     }
     propsGroupedByName.forEach((shared, key) => {
-      if (!key)
+      if (!key) {
         return;
+      }
       if (ReservedWord({ fail() {
       } }, {
         pos: 0,
         input: key
       })) {
-        shared.forEach((p) => ({
-          aliasBinding: aliasBinding(p, makeRef(`_${key}`, key))
-        }));
+        shared.forEach((p) => {
+          return aliasBinding(p, makeRef(`_${key}`, key));
+        });
         return;
       }
-      if (shared.length === 1)
+      if (shared.length === 1) {
         return;
+      }
       const refs = shared.map((p) => {
         const ref = makeRef(key);
         aliasBinding(p, ref);
@@ -2728,7 +2738,7 @@ var Civet = (() => {
     return declarations;
   }
   function processPatternMatching(statements, ReservedWord) {
-    gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement").forEach((s) => {
+    gatherRecursiveAll(statements, ($5) => $5.type === "SwitchStatement").forEach((s) => {
       const { caseBlock } = s;
       const { clauses } = caseBlock;
       for (const c of clauses) {
@@ -2742,7 +2752,7 @@ var Civet = (() => {
       }
       let errors = false;
       let isPattern = false;
-      if (clauses.some((c) => c.type === "PatternClause")) {
+      if (clauses.some(($6) => $6.type === "PatternClause")) {
         isPattern = true;
         clauses.forEach((c) => {
           if (!(c.type === "PatternClause" || c.type === "DefaultClause")) {
@@ -2756,8 +2766,9 @@ var Civet = (() => {
           return;
         });
       }
-      if (errors || !isPattern)
+      if (errors || !isPattern) {
         return;
+      }
       let { condition } = s;
       if (condition.type === "ParenthesizedExpression") {
         condition = condition.expression;
@@ -2969,7 +2980,7 @@ var Civet = (() => {
         };
       }
       children.push(arg);
-      if (!children.some(($3) => $3?.type === "ReturnStatement") && children.some(($4) => $4 === ",")) {
+      if (!children.some(($7) => $7?.type === "ReturnStatement") && children.some(($8) => $8 === ",")) {
         const { parent } = s;
         const parenthesizedExpression = makeLeftHandSideExpression({ ...s });
         Object.assign(s, parenthesizedExpression, {
@@ -3092,7 +3103,7 @@ var Civet = (() => {
     scopes.push(decs);
     const varIds = [];
     const assignmentStatements = findAssignments(statements, scopes);
-    const undeclaredIdentifiers = assignmentStatements.flatMap((a) => a.names);
+    const undeclaredIdentifiers = assignmentStatements.flatMap(($9) => $9?.names || []);
     undeclaredIdentifiers.filter((x, i, a) => {
       if (!hasDec(x))
         return a.indexOf(x) === i;
@@ -3397,8 +3408,9 @@ var Civet = (() => {
           }
         ];
       }
-      if (rest.delim?.at(-1)?.token === ",") {
-        rest.delim.pop();
+      if (Array.isArray(rest.delim) && rest.delim.at(-1)?.token === ",") {
+        rest.delim = rest.delim.slice(0, -1);
+        rest.children = [...rest.children.slice(0, -1), rest.delim];
       }
       const children = [...props, ...after, rest];
       return {
@@ -4143,6 +4155,7 @@ ${input.slice(result.pos)}
         ArrowFunction,
         FatArrow,
         TrailingDeclaration,
+        TrailingPipe,
         FatArrowBody,
         ConditionalExpression,
         TernaryRest,
@@ -4576,6 +4589,7 @@ ${input.slice(result.pos)}
         If,
         Import,
         In,
+        Infer,
         LetOrConst,
         Const,
         Is,
@@ -4674,6 +4688,9 @@ ${input.slice(result.pos)}
         UsingJSModeError,
         TypeDeclaration,
         TypeDeclarationRest,
+        TypeAliasDeclaration,
+        InterfaceDeclaration,
+        NamespaceDeclaration,
         OptionalEquals,
         TypeLexicalDeclaration,
         TypeDeclarationBinding,
@@ -4701,7 +4718,7 @@ ${input.slice(result.pos)}
         EnumDeclaration,
         EnumBlock,
         NestedEnumProperties,
-        NestedEnumProperty,
+        NestedEnumPropertyLine,
         EnumProperty,
         TypeProperty,
         TypeIndexSignature,
@@ -4960,66 +4977,66 @@ ${input.slice(result.pos)}
       var $L150 = $L("#");
       var $L151 = $L("if");
       var $L152 = $L("in");
-      var $L153 = $L("let");
-      var $L154 = $L("const");
-      var $L155 = $L("is");
-      var $L156 = $L("loop");
-      var $L157 = $L("new");
-      var $L158 = $L("not");
-      var $L159 = $L("of");
-      var $L160 = $L("[");
-      var $L161 = $L("operator");
-      var $L162 = $L("own");
-      var $L163 = $L("public");
-      var $L164 = $L("private");
-      var $L165 = $L("protected");
-      var $L166 = $L("||>");
-      var $L167 = $L("|\u25B7");
-      var $L168 = $L("|>=");
-      var $L169 = $L("\u25B7=");
-      var $L170 = $L("|>");
-      var $L171 = $L("\u25B7");
-      var $L172 = $L("readonly");
-      var $L173 = $L("return");
-      var $L174 = $L("satisfies");
-      var $L175 = $L("'");
-      var $L176 = $L("static");
-      var $L177 = $L("${");
-      var $L178 = $L("super");
-      var $L179 = $L("switch");
-      var $L180 = $L("target");
-      var $L181 = $L("then");
-      var $L182 = $L("this");
-      var $L183 = $L("throw");
-      var $L184 = $L('"""');
-      var $L185 = $L("'''");
-      var $L186 = $L("///");
-      var $L187 = $L("```");
-      var $L188 = $L("try");
-      var $L189 = $L("typeof");
-      var $L190 = $L("unless");
-      var $L191 = $L("until");
-      var $L192 = $L("using");
-      var $L193 = $L("var");
-      var $L194 = $L("void");
-      var $L195 = $L("when");
-      var $L196 = $L("while");
-      var $L197 = $L("yield");
-      var $L198 = $L("/>");
-      var $L199 = $L("</");
-      var $L200 = $L("<>");
-      var $L201 = $L("</>");
-      var $L202 = $L("<!--");
-      var $L203 = $L("-->");
-      var $L204 = $L("type");
-      var $L205 = $L("enum");
-      var $L206 = $L("interface");
-      var $L207 = $L("global");
-      var $L208 = $L("module");
-      var $L209 = $L("namespace");
-      var $L210 = $L("asserts");
-      var $L211 = $L("keyof");
-      var $L212 = $L("infer");
+      var $L153 = $L("infer");
+      var $L154 = $L("let");
+      var $L155 = $L("const");
+      var $L156 = $L("is");
+      var $L157 = $L("loop");
+      var $L158 = $L("new");
+      var $L159 = $L("not");
+      var $L160 = $L("of");
+      var $L161 = $L("[");
+      var $L162 = $L("operator");
+      var $L163 = $L("own");
+      var $L164 = $L("public");
+      var $L165 = $L("private");
+      var $L166 = $L("protected");
+      var $L167 = $L("||>");
+      var $L168 = $L("|\u25B7");
+      var $L169 = $L("|>=");
+      var $L170 = $L("\u25B7=");
+      var $L171 = $L("|>");
+      var $L172 = $L("\u25B7");
+      var $L173 = $L("readonly");
+      var $L174 = $L("return");
+      var $L175 = $L("satisfies");
+      var $L176 = $L("'");
+      var $L177 = $L("static");
+      var $L178 = $L("${");
+      var $L179 = $L("super");
+      var $L180 = $L("switch");
+      var $L181 = $L("target");
+      var $L182 = $L("then");
+      var $L183 = $L("this");
+      var $L184 = $L("throw");
+      var $L185 = $L('"""');
+      var $L186 = $L("'''");
+      var $L187 = $L("///");
+      var $L188 = $L("```");
+      var $L189 = $L("try");
+      var $L190 = $L("typeof");
+      var $L191 = $L("unless");
+      var $L192 = $L("until");
+      var $L193 = $L("using");
+      var $L194 = $L("var");
+      var $L195 = $L("void");
+      var $L196 = $L("when");
+      var $L197 = $L("while");
+      var $L198 = $L("yield");
+      var $L199 = $L("/>");
+      var $L200 = $L("</");
+      var $L201 = $L("<>");
+      var $L202 = $L("</>");
+      var $L203 = $L("<!--");
+      var $L204 = $L("-->");
+      var $L205 = $L("type");
+      var $L206 = $L("enum");
+      var $L207 = $L("interface");
+      var $L208 = $L("global");
+      var $L209 = $L("module");
+      var $L210 = $L("namespace");
+      var $L211 = $L("asserts");
+      var $L212 = $L("keyof");
       var $L213 = $L("???");
       var $L214 = $L("[]");
       var $L215 = $L("civet");
@@ -5756,12 +5773,23 @@ ${input.slice(result.pos)}
       function TrailingDeclaration(ctx, state) {
         return $EVENT(ctx, state, "TrailingDeclaration", TrailingDeclaration$0);
       }
-      var FatArrowBody$0 = $TS($S($N(EOS), NonPipelinePostfixedExpression, $N(TrailingDeclaration), $N(SemicolonDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var TrailingPipe$0 = $S($E(_), Pipe);
+      function TrailingPipe(ctx, state) {
+        return $EVENT(ctx, state, "TrailingPipe", TrailingPipe$0);
+      }
+      var FatArrowBody$0 = $TS($S($N(EOS), NonPipelinePostfixedExpression, $N(TrailingDeclaration), $N(TrailingPipe), $N(SemicolonDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var exp = $2;
         if (exp.type === "ObjectExpression") {
-          return makeLeftHandSideExpression(exp);
+          exp = makeLeftHandSideExpression(exp);
         }
-        return exp;
+        const expressions = [exp];
+        return {
+          type: "BlockStatement",
+          bare: true,
+          expressions,
+          children: [expressions],
+          implicitlyReturned: true
+        };
       });
       var FatArrowBody$1 = NoCommaBracedOrEmptyBlock;
       var FatArrowBody$$ = [FatArrowBody$0, FatArrowBody$1];
@@ -5891,7 +5919,7 @@ ${input.slice(result.pos)}
         return $EVENT(ctx, state, "ParenthesizedExpression", ParenthesizedExpression$0);
       }
       var ClassDeclaration$0 = $TS($S(ClassExpression), function($skip, $loc, $0, $1) {
-        if ($1.binding)
+        if ($1.id)
           return $1;
         return makeLeftHandSideExpression($1);
       });
@@ -5908,6 +5936,7 @@ ${input.slice(result.pos)}
           decorators,
           abstract,
           binding,
+          id: binding?.[0],
           heritage,
           body,
           children: $0
@@ -6225,7 +6254,8 @@ ${input.slice(result.pos)}
             name: id.name,
             children: [".", id]
           }],
-          privateShorthand: true
+          privateShorthand: true,
+          privateId: id
         };
       });
       var PrivateThis$$ = [PrivateThis$0, PrivateThis$1];
@@ -7411,7 +7441,10 @@ ${input.slice(result.pos)}
         var w = $2;
         var decl = $3;
         decl.names.forEach((name) => module.operators.add(name));
-        return [insertTrimmingSpace(w, ""), decl];
+        return {
+          ...decl,
+          children: [insertTrimmingSpace(w, ""), ...decl.children]
+        };
       });
       var OperatorDeclaration$1 = $TS($S(OperatorSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
         var signature = $1;
@@ -7433,7 +7466,10 @@ ${input.slice(result.pos)}
         var ids = $4;
         module.operators.add(id.name);
         ids.forEach(([, , id2]) => module.operators.add(id2.name));
-        return [];
+        return {
+          id,
+          children: []
+        };
       });
       var OperatorDeclaration$$ = [OperatorDeclaration$0, OperatorDeclaration$1, OperatorDeclaration$2];
       function OperatorDeclaration(ctx, state) {
@@ -8320,14 +8356,17 @@ ${input.slice(result.pos)}
       function NestedImplicitPropertyDefinitions(ctx, state) {
         return $EVENT(ctx, state, "NestedImplicitPropertyDefinitions", NestedImplicitPropertyDefinitions$0);
       }
-      var NestedImplicitPropertyDefinition$0 = $TS($S(Nested, NamedProperty, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
-        var ws = $1;
-        var prop = $2;
-        var delimiter = $3;
-        return {
+      var NestedImplicitPropertyDefinition$0 = $TS($S(Nested, $P($S($E(_), NamedProperty, ObjectPropertyDelimiter))), function($skip, $loc, $0, $1, $2) {
+        var indent = $1;
+        var props = $2;
+        return props.map(([ws, prop, delimiter], i) => ({
           ...prop,
-          children: [...ws, ...prop.children, delimiter]
-        };
+          children: [
+            ...i === 0 ? [indent, ws] : [ws],
+            ...prop.children,
+            delimiter
+          ]
+        }));
       });
       function NestedImplicitPropertyDefinition(ctx, state) {
         return $EVENT(ctx, state, "NestedImplicitPropertyDefinition", NestedImplicitPropertyDefinition$0);
@@ -8725,7 +8764,12 @@ ${input.slice(result.pos)}
                     v = insertTrimmingSpace(p, "");
                     break;
                   case "Property":
-                    v = insertTrimmingSpace(p.value, "");
+                    const { value: value2 } = p;
+                    if (value2.privateShorthand) {
+                      v = value2.privateId;
+                    } else {
+                      v = insertTrimmingSpace(value2, "");
+                    }
                     break;
                 }
                 const exp = processCallMemberExpression({
@@ -10804,18 +10848,45 @@ ${input.slice(result.pos)}
           children: [exp, $0.slice(1)]
         };
       });
-      var ExportDeclaration$1 = $TS($S($E(Decorators), Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var ExportDeclaration$1 = $TS($S($E(Decorators), Export, __, Default, __, $N(FunctionDeclaration), $C(LexicalDeclaration, VariableStatement, TypeAliasDeclaration, NamespaceDeclaration, EnumDeclaration, OperatorDeclaration)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+        var declaration = $7;
+        let id, error;
+        if (declaration.id) {
+          id = declaration.id;
+        } else if (declaration.names) {
+          if (declaration.names.length !== 1) {
+            error = {
+              type: "Error",
+              message: `export default with ${declaration.names.length} variable declaration (should be 1)`
+            };
+          }
+          id = declaration.names[0];
+        } else {
+          throw new Error("Could not find name of declaration in export default");
+        }
+        return [
+          declaration,
+          { children: [";"], ts: declaration.ts },
+          error ?? {
+            type: "ExportDeclaration",
+            declaration: id,
+            ts: declaration.ts,
+            children: [...$0.slice(0, -2), id]
+          }
+        ];
+      });
+      var ExportDeclaration$2 = $TS($S($E(Decorators), Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, InterfaceDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         var declaration = $6;
-        return { type: "ExportDeclaration", declaration, children: $0 };
+        return { type: "ExportDeclaration", declaration, ts: declaration.ts, children: $0 };
       });
-      var ExportDeclaration$2 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var ExportDeclaration$3 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         return { type: "ExportDeclaration", ts: $3.ts, children: $0 };
       });
-      var ExportDeclaration$3 = $TS($S($E(Decorators), Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ExportDeclaration$4 = $TS($S($E(Decorators), Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3, $4) {
         var declaration = $4;
         return { type: "ExportDeclaration", declaration, ts: declaration.ts, children: $0 };
       });
-      var ExportDeclaration$$ = [ExportDeclaration$0, ExportDeclaration$1, ExportDeclaration$2, ExportDeclaration$3];
+      var ExportDeclaration$$ = [ExportDeclaration$0, ExportDeclaration$1, ExportDeclaration$2, ExportDeclaration$3, ExportDeclaration$4];
       function ExportDeclaration(ctx, state) {
         return $EVENT_C(ctx, state, "ExportDeclaration", ExportDeclaration$$);
       }
@@ -10979,6 +11050,7 @@ ${input.slice(result.pos)}
       var VariableStatement$0 = $TS($S(Var, __, VariableDeclarationList), function($skip, $loc, $0, $1, $2, $3) {
         return {
           ...$3,
+          names: $3.names,
           children: [$1, ...$2, ...$3.children]
         };
       });
@@ -11154,7 +11226,7 @@ ${input.slice(result.pos)}
         var flags = $4;
         let hasSubstitutions = body.some((part) => part.type === "Substitution");
         if (hasSubstitutions) {
-          const result = [
+          const children = [
             { ...open, token: "RegExp(`" },
             // Escape backticks, backslashes, and '$' in the body text
             body.map(
@@ -11166,13 +11238,16 @@ ${input.slice(result.pos)}
             "`"
           ];
           if (flags.length) {
-            result.push(
+            children.push(
               ", ",
               JSON.stringify(flags)
             );
           }
-          result.push({ ...close, token: ")" });
-          return result;
+          children.push({ ...close, token: ")" });
+          return {
+            type: "RegularExpressionLiteral",
+            children
+          };
         }
         return {
           type: "RegularExpressionLiteral",
@@ -11739,19 +11814,25 @@ ${input.slice(result.pos)}
       function In(ctx, state) {
         return $EVENT(ctx, state, "In", In$0);
       }
-      var LetOrConst$0 = $TS($S($C($EXPECT($L153, 'LetOrConst "let"'), $EXPECT($L154, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Infer$0 = $TS($S($EXPECT($L153, 'Infer "infer"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1 };
+      });
+      function Infer(ctx, state) {
+        return $EVENT(ctx, state, "Infer", Infer$0);
+      }
+      var LetOrConst$0 = $TS($S($C($EXPECT($L154, 'LetOrConst "let"'), $EXPECT($L155, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function LetOrConst(ctx, state) {
         return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
       }
-      var Const$0 = $TS($S($EXPECT($L154, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Const$0 = $TS($S($EXPECT($L155, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Const(ctx, state) {
         return $EVENT(ctx, state, "Const", Const$0);
       }
-      var Is$0 = $TS($S($EXPECT($L155, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Is$0 = $TS($S($EXPECT($L156, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Is(ctx, state) {
@@ -11763,25 +11844,25 @@ ${input.slice(result.pos)}
       function LetOrConstOrVar(ctx, state) {
         return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
       }
-      var Loop$0 = $TS($S($EXPECT($L156, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Loop$0 = $TS($S($EXPECT($L157, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: "while(true)" };
       });
       function Loop(ctx, state) {
         return $EVENT(ctx, state, "Loop", Loop$0);
       }
-      var New$0 = $TS($S($EXPECT($L157, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var New$0 = $TS($S($EXPECT($L158, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function New(ctx, state) {
         return $EVENT(ctx, state, "New", New$0);
       }
-      var Not$0 = $TS($S($EXPECT($L158, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L14, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
+      var Not$0 = $TS($S($EXPECT($L159, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L14, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
         return { $loc, token: "!" };
       });
       function Not(ctx, state) {
         return $EVENT(ctx, state, "Not", Not$0);
       }
-      var Of$0 = $TS($S($EXPECT($L159, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Of$0 = $TS($S($EXPECT($L160, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Of(ctx, state) {
@@ -11799,7 +11880,7 @@ ${input.slice(result.pos)}
       function OpenBrace(ctx, state) {
         return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
       }
-      var OpenBracket$0 = $TV($EXPECT($L160, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
+      var OpenBracket$0 = $TV($EXPECT($L161, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function OpenBracket(ctx, state) {
@@ -11811,43 +11892,43 @@ ${input.slice(result.pos)}
       function OpenParen(ctx, state) {
         return $EVENT(ctx, state, "OpenParen", OpenParen$0);
       }
-      var Operator$0 = $TS($S($EXPECT($L161, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Operator$0 = $TS($S($EXPECT($L162, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Operator(ctx, state) {
         return $EVENT(ctx, state, "Operator", Operator$0);
       }
-      var Own$0 = $TS($S($EXPECT($L162, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Own$0 = $TS($S($EXPECT($L163, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Own(ctx, state) {
         return $EVENT(ctx, state, "Own", Own$0);
       }
-      var Public$0 = $TS($S($EXPECT($L163, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Public$0 = $TS($S($EXPECT($L164, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Public(ctx, state) {
         return $EVENT(ctx, state, "Public", Public$0);
       }
-      var Private$0 = $TS($S($EXPECT($L164, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Private$0 = $TS($S($EXPECT($L165, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Private(ctx, state) {
         return $EVENT(ctx, state, "Private", Private$0);
       }
-      var Protected$0 = $TS($S($EXPECT($L165, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Protected$0 = $TS($S($EXPECT($L166, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Protected(ctx, state) {
         return $EVENT(ctx, state, "Protected", Protected$0);
       }
-      var Pipe$0 = $TV($C($EXPECT($L166, 'Pipe "||>"'), $EXPECT($L167, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
+      var Pipe$0 = $TV($C($EXPECT($L167, 'Pipe "||>"'), $EXPECT($L168, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
         return { $loc, token: "||>" };
       });
-      var Pipe$1 = $TV($C($EXPECT($L168, 'Pipe "|>="'), $EXPECT($L169, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
+      var Pipe$1 = $TV($C($EXPECT($L169, 'Pipe "|>="'), $EXPECT($L170, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
         return { $loc, token: "|>=" };
       });
-      var Pipe$2 = $TV($C($EXPECT($L170, 'Pipe "|>"'), $EXPECT($L171, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
+      var Pipe$2 = $TV($C($EXPECT($L171, 'Pipe "|>"'), $EXPECT($L172, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
         return { $loc, token: "|>" };
       });
       var Pipe$$ = [Pipe$0, Pipe$1, Pipe$2];
@@ -11860,19 +11941,19 @@ ${input.slice(result.pos)}
       function QuestionMark(ctx, state) {
         return $EVENT(ctx, state, "QuestionMark", QuestionMark$0);
       }
-      var Readonly$0 = $TS($S($EXPECT($L172, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Readonly$0 = $TS($S($EXPECT($L173, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1, ts: true };
       });
       function Readonly(ctx, state) {
         return $EVENT(ctx, state, "Readonly", Readonly$0);
       }
-      var Return$0 = $TS($S($EXPECT($L173, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Return$0 = $TS($S($EXPECT($L174, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Return(ctx, state) {
         return $EVENT(ctx, state, "Return", Return$0);
       }
-      var Satisfies$0 = $TS($S($EXPECT($L174, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Satisfies$0 = $TS($S($EXPECT($L175, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Satisfies(ctx, state) {
@@ -11884,7 +11965,7 @@ ${input.slice(result.pos)}
       function Semicolon(ctx, state) {
         return $EVENT(ctx, state, "Semicolon", Semicolon$0);
       }
-      var SingleQuote$0 = $TV($EXPECT($L175, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
+      var SingleQuote$0 = $TV($EXPECT($L176, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function SingleQuote(ctx, state) {
@@ -11896,7 +11977,7 @@ ${input.slice(result.pos)}
       function Star(ctx, state) {
         return $EVENT(ctx, state, "Star", Star$0);
       }
-      var Static$0 = $TS($S($EXPECT($L176, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Static$0 = $TS($S($EXPECT($L177, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       var Static$1 = $TS($S($EXPECT($L120, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L120, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
@@ -11906,127 +11987,127 @@ ${input.slice(result.pos)}
       function Static(ctx, state) {
         return $EVENT_C(ctx, state, "Static", Static$$);
       }
-      var SubstitutionStart$0 = $TV($EXPECT($L177, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
+      var SubstitutionStart$0 = $TV($EXPECT($L178, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function SubstitutionStart(ctx, state) {
         return $EVENT(ctx, state, "SubstitutionStart", SubstitutionStart$0);
       }
-      var Super$0 = $TS($S($EXPECT($L178, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Super$0 = $TS($S($EXPECT($L179, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Super(ctx, state) {
         return $EVENT(ctx, state, "Super", Super$0);
       }
-      var Switch$0 = $TS($S($EXPECT($L179, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Switch$0 = $TS($S($EXPECT($L180, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Switch(ctx, state) {
         return $EVENT(ctx, state, "Switch", Switch$0);
       }
-      var Target$0 = $TS($S($EXPECT($L180, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Target$0 = $TS($S($EXPECT($L181, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Target(ctx, state) {
         return $EVENT(ctx, state, "Target", Target$0);
       }
-      var Then$0 = $TS($S(__, $EXPECT($L181, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
+      var Then$0 = $TS($S(__, $EXPECT($L182, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
         return { $loc, token: "" };
       });
       function Then(ctx, state) {
         return $EVENT(ctx, state, "Then", Then$0);
       }
-      var This$0 = $TS($S($EXPECT($L182, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var This$0 = $TS($S($EXPECT($L183, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function This(ctx, state) {
         return $EVENT(ctx, state, "This", This$0);
       }
-      var Throw$0 = $TS($S($EXPECT($L183, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Throw$0 = $TS($S($EXPECT($L184, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Throw(ctx, state) {
         return $EVENT(ctx, state, "Throw", Throw$0);
       }
-      var TripleDoubleQuote$0 = $TV($EXPECT($L184, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
+      var TripleDoubleQuote$0 = $TV($EXPECT($L185, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
         return { $loc, token: "`" };
       });
       function TripleDoubleQuote(ctx, state) {
         return $EVENT(ctx, state, "TripleDoubleQuote", TripleDoubleQuote$0);
       }
-      var TripleSingleQuote$0 = $TV($EXPECT($L185, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
+      var TripleSingleQuote$0 = $TV($EXPECT($L186, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
         return { $loc, token: "`" };
       });
       function TripleSingleQuote(ctx, state) {
         return $EVENT(ctx, state, "TripleSingleQuote", TripleSingleQuote$0);
       }
-      var TripleSlash$0 = $TV($EXPECT($L186, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
+      var TripleSlash$0 = $TV($EXPECT($L187, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "/" };
       });
       function TripleSlash(ctx, state) {
         return $EVENT(ctx, state, "TripleSlash", TripleSlash$0);
       }
-      var TripleTick$0 = $TV($EXPECT($L187, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
+      var TripleTick$0 = $TV($EXPECT($L188, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "`" };
       });
       function TripleTick(ctx, state) {
         return $EVENT(ctx, state, "TripleTick", TripleTick$0);
       }
-      var Try$0 = $TS($S($EXPECT($L188, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Try$0 = $TS($S($EXPECT($L189, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Try(ctx, state) {
         return $EVENT(ctx, state, "Try", Try$0);
       }
-      var Typeof$0 = $TS($S($EXPECT($L189, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Typeof$0 = $TS($S($EXPECT($L190, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Typeof(ctx, state) {
         return $EVENT(ctx, state, "Typeof", Typeof$0);
       }
-      var Unless$0 = $TS($S($EXPECT($L190, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Unless$0 = $TS($S($EXPECT($L191, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1, negated: true };
       });
       function Unless(ctx, state) {
         return $EVENT(ctx, state, "Unless", Unless$0);
       }
-      var Until$0 = $TS($S($EXPECT($L191, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Until$0 = $TS($S($EXPECT($L192, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Until(ctx, state) {
         return $EVENT(ctx, state, "Until", Until$0);
       }
-      var Using$0 = $TS($S($EXPECT($L192, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Using$0 = $TS($S($EXPECT($L193, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Using(ctx, state) {
         return $EVENT(ctx, state, "Using", Using$0);
       }
-      var Var$0 = $TS($S($EXPECT($L193, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Var$0 = $TS($S($EXPECT($L194, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Var(ctx, state) {
         return $EVENT(ctx, state, "Var", Var$0);
       }
-      var Void$0 = $TS($S($EXPECT($L194, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Void$0 = $TS($S($EXPECT($L195, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Void(ctx, state) {
         return $EVENT(ctx, state, "Void", Void$0);
       }
-      var When$0 = $TS($S($EXPECT($L195, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var When$0 = $TS($S($EXPECT($L196, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: "case" };
       });
       function When(ctx, state) {
         return $EVENT(ctx, state, "When", When$0);
       }
-      var While$0 = $TS($S($EXPECT($L196, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var While$0 = $TS($S($EXPECT($L197, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function While(ctx, state) {
         return $EVENT(ctx, state, "While", While$0);
       }
-      var Yield$0 = $TS($S($EXPECT($L197, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Yield$0 = $TS($S($EXPECT($L198, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1, type: "Yield" };
       });
       function Yield(ctx, state) {
@@ -12105,7 +12186,7 @@ ${input.slice(result.pos)}
       function JSXElement(ctx, state) {
         return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
       }
-      var JSXSelfClosingElement$0 = $TS($S($EXPECT($L16, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L198, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var JSXSelfClosingElement$0 = $TS($S($EXPECT($L16, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L199, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         return { type: "JSXElement", children: $0, tag: $2 };
       });
       function JSXSelfClosingElement(ctx, state) {
@@ -12139,7 +12220,7 @@ ${input.slice(result.pos)}
       function JSXOptionalClosingElement(ctx, state) {
         return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
       }
-      var JSXClosingElement$0 = $S($EXPECT($L199, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L37, 'JSXClosingElement ">"'));
+      var JSXClosingElement$0 = $S($EXPECT($L200, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L37, 'JSXClosingElement ">"'));
       function JSXClosingElement(ctx, state) {
         return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
       }
@@ -12160,7 +12241,7 @@ ${input.slice(result.pos)}
         ];
         return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
       });
-      var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L200, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L201, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var children = $3;
         $0 = $0.slice(1);
         return {
@@ -12173,7 +12254,7 @@ ${input.slice(result.pos)}
       function JSXFragment(ctx, state) {
         return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
       }
-      var PushJSXOpeningFragment$0 = $TV($EXPECT($L200, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
+      var PushJSXOpeningFragment$0 = $TV($EXPECT($L201, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
         module.JSXTagStack.push("");
         return $1;
       });
@@ -12190,7 +12271,7 @@ ${input.slice(result.pos)}
       function JSXOptionalClosingFragment(ctx, state) {
         return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
       }
-      var JSXClosingFragment$0 = $EXPECT($L201, 'JSXClosingFragment "</>"');
+      var JSXClosingFragment$0 = $EXPECT($L202, 'JSXClosingFragment "</>"');
       function JSXClosingFragment(ctx, state) {
         return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
       }
@@ -12664,7 +12745,7 @@ ${input.slice(result.pos)}
       function JSXChild(ctx, state) {
         return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
       }
-      var JSXComment$0 = $TS($S($EXPECT($L202, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L203, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
+      var JSXComment$0 = $TS($S($EXPECT($L203, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L204, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
         return ["{/*", $2, "*/}"];
       });
       function JSXComment(ctx, state) {
@@ -12751,21 +12832,66 @@ ${input.slice(result.pos)}
       var TypeDeclaration$0 = $T($S($E($S(Export, $E(_))), $S(Declare, $E(_)), TypeLexicalDeclaration), function(value) {
         return { "ts": true, "children": value };
       });
-      var TypeDeclaration$1 = $T($S($E($S(Export, $E(_))), $E($S(Declare, $E(_))), TypeDeclarationRest), function(value) {
-        return { "ts": true, "children": value };
+      var TypeDeclaration$1 = $TS($S($E($S(Export, $E(_))), $E($S(Declare, $E(_))), TypeDeclarationRest), function($skip, $loc, $0, $1, $2, $3) {
+        var export_ = $1;
+        var declare = $2;
+        var t = $3;
+        return {
+          ...t,
+          ts: true,
+          export: export_,
+          declare,
+          children: [export_, declare, ...t.children]
+        };
       });
       var TypeDeclaration$$ = [TypeDeclaration$0, TypeDeclaration$1];
       function TypeDeclaration(ctx, state) {
         return $EVENT_C(ctx, state, "TypeDeclaration", TypeDeclaration$$);
       }
-      var TypeDeclarationRest$0 = $S(TypeKeyword, $E(_), IdentifierName, $E(TypeParameters), OptionalEquals, $C($S($E(_), Type), $S(__, Type)));
-      var TypeDeclarationRest$1 = $S(Interface, $E(_), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock);
-      var TypeDeclarationRest$2 = $S(Namespace, $E(_), IdentifierName, ModuleBlock);
+      var TypeDeclarationRest$0 = TypeAliasDeclaration;
+      var TypeDeclarationRest$1 = InterfaceDeclaration;
+      var TypeDeclarationRest$2 = NamespaceDeclaration;
       var TypeDeclarationRest$3 = FunctionSignature;
       var TypeDeclarationRest$$ = [TypeDeclarationRest$0, TypeDeclarationRest$1, TypeDeclarationRest$2, TypeDeclarationRest$3];
       function TypeDeclarationRest(ctx, state) {
         return $EVENT_C(ctx, state, "TypeDeclarationRest", TypeDeclarationRest$$);
       }
+      var TypeAliasDeclaration$0 = $TS($S(TypeKeyword, $E(_), IdentifierName, $E(TypeParameters), OptionalEquals, $C($S($E(_), Type), $S(__, Type))), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var id = $3;
+        return {
+          type: "TypeDeclaration",
+          id,
+          children: $0,
+          ts: true
+        };
+      });
+      function TypeAliasDeclaration(ctx, state) {
+        return $EVENT(ctx, state, "TypeAliasDeclaration", TypeAliasDeclaration$0);
+      }
+      var InterfaceDeclaration$0 = $TS($S(Interface, $E(_), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var id = $3;
+        return {
+          type: "InterfaceDeclaration",
+          id,
+          children: $0,
+          ts: true
+        };
+      });
+      function InterfaceDeclaration(ctx, state) {
+        return $EVENT(ctx, state, "InterfaceDeclaration", InterfaceDeclaration$0);
+      }
+      var NamespaceDeclaration$0 = $TS($S(Namespace, $E(_), IdentifierName, ModuleBlock), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var id = $3;
+        return {
+          type: "NamespaceDeclaration",
+          id,
+          children: $0,
+          ts: true
+        };
+      });
+      function NamespaceDeclaration(ctx, state) {
+        return $EVENT(ctx, state, "NamespaceDeclaration", NamespaceDeclaration$0);
+      }
       var OptionalEquals$0 = $S(__, Equals);
       var OptionalEquals$1 = $T($S($Y(IndentedFurther), InsertSpaceEquals), function(value) {
         return value[1];
@@ -12796,37 +12922,37 @@ ${input.slice(result.pos)}
       function InterfaceExtendsTarget(ctx, state) {
         return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
       }
-      var TypeKeyword$0 = $TS($S($EXPECT($L204, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var TypeKeyword$0 = $TS($S($EXPECT($L205, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function TypeKeyword(ctx, state) {
         return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
       }
-      var Enum$0 = $TS($S($EXPECT($L205, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Enum$0 = $TS($S($EXPECT($L206, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Enum(ctx, state) {
         return $EVENT(ctx, state, "Enum", Enum$0);
       }
-      var Interface$0 = $TS($S($EXPECT($L206, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Interface$0 = $TS($S($EXPECT($L207, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Interface(ctx, state) {
         return $EVENT(ctx, state, "Interface", Interface$0);
       }
-      var Global$0 = $TS($S($EXPECT($L207, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Global$0 = $TS($S($EXPECT($L208, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Global(ctx, state) {
         return $EVENT(ctx, state, "Global", Global$0);
       }
-      var Module$0 = $TS($S($EXPECT($L208, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Module$0 = $TS($S($EXPECT($L209, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Module(ctx, state) {
         return $EVENT(ctx, state, "Module", Module$0);
       }
-      var Namespace$0 = $TS($S($EXPECT($L209, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Namespace$0 = $TS($S($EXPECT($L210, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Namespace(ctx, state) {
@@ -12928,9 +13054,10 @@ ${input.slice(result.pos)}
           children: $0
         };
         const names = new Set(block.properties.map((p) => p.name.name));
-        return [
-          ts,
-          {
+        return {
+          type: "EnumDeclaration",
+          id,
+          children: [ts, {
             js: true,
             children: [
               ["let ", id, " = {};\n"],
@@ -12972,8 +13099,8 @@ ${input.slice(result.pos)}
                 }
               })
             ]
-          }
-        ];
+          }]
+        };
       });
       function EnumDeclaration(ctx, state) {
         return $EVENT(ctx, state, "EnumDeclaration", EnumDeclaration$0);
@@ -13003,26 +13130,26 @@ ${input.slice(result.pos)}
       function EnumBlock(ctx, state) {
         return $EVENT_C(ctx, state, "EnumBlock", EnumBlock$$);
       }
-      var NestedEnumProperties$0 = $TS($S(PushIndent, $Q(NestedEnumProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var NestedEnumProperties$0 = $TS($S(PushIndent, $Q(NestedEnumPropertyLine), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
         var props = $2;
         if (!props.length)
           return $skip;
         return {
-          properties: props.map((p) => p.property),
+          properties: props.flat().map((p) => p.property),
           children: $0
         };
       });
       function NestedEnumProperties(ctx, state) {
         return $EVENT(ctx, state, "NestedEnumProperties", NestedEnumProperties$0);
       }
-      var NestedEnumProperty$0 = $TS($S(Nested, EnumProperty), function($skip, $loc, $0, $1, $2) {
-        return {
-          property: $2,
-          children: $0
-        };
+      var NestedEnumPropertyLine$0 = $TS($S($S(Nested, EnumProperty), $Q($S($E(_), EnumProperty))), function($skip, $loc, $0, $1, $2) {
+        return [$1, ...$2].map((pair) => ({
+          property: pair[1],
+          children: pair
+        }));
       });
-      function NestedEnumProperty(ctx, state) {
-        return $EVENT(ctx, state, "NestedEnumProperty", NestedEnumProperty$0);
+      function NestedEnumPropertyLine(ctx, state) {
+        return $EVENT(ctx, state, "NestedEnumPropertyLine", NestedEnumPropertyLine$0);
       }
       var EnumProperty$0 = $TS($S(Identifier, $E($S(__, Equals, ExtendedExpression)), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
         var name = $1;
@@ -13099,7 +13226,7 @@ ${input.slice(result.pos)}
       function ReturnTypeSuffix(ctx, state) {
         return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
       }
-      var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L210, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
+      var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L211, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
         var asserts = $1;
         var t = $2;
         if (asserts) {
@@ -13120,7 +13247,7 @@ ${input.slice(result.pos)}
       function ReturnType(ctx, state) {
         return $EVENT(ctx, state, "ReturnType", ReturnType$0);
       }
-      var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L155, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
+      var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L156, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
         var lhs = $1;
         var rhs = $2;
         if (!rhs)
@@ -13154,7 +13281,7 @@ ${input.slice(result.pos)}
       function TypeBinary(ctx, state) {
         return $EVENT(ctx, state, "TypeBinary", TypeBinary$0);
       }
-      var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
+      var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
         var prefix = $1;
         var t = $2;
         var suffix = $3;
@@ -13178,10 +13305,9 @@ ${input.slice(result.pos)}
       function TypeUnarySuffix(ctx, state) {
         return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
       }
-      var TypeUnaryOp$0 = $S($EXPECT($L211, 'TypeUnaryOp "keyof"'), NonIdContinue);
-      var TypeUnaryOp$1 = $S($EXPECT($L212, 'TypeUnaryOp "infer"'), NonIdContinue);
-      var TypeUnaryOp$2 = $S($EXPECT($L172, 'TypeUnaryOp "readonly"'), NonIdContinue);
-      var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1, TypeUnaryOp$2];
+      var TypeUnaryOp$0 = $S($EXPECT($L212, 'TypeUnaryOp "keyof"'), NonIdContinue);
+      var TypeUnaryOp$1 = $S($EXPECT($L173, 'TypeUnaryOp "readonly"'), NonIdContinue);
+      var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1];
       function TypeUnaryOp(ctx, state) {
         return $EVENT_C(ctx, state, "TypeUnaryOp", TypeUnaryOp$$);
       }
@@ -13216,19 +13342,20 @@ ${input.slice(result.pos)}
       function UnknownAlias(ctx, state) {
         return $EVENT(ctx, state, "UnknownAlias", UnknownAlias$0);
       }
-      var TypePrimary$0 = $TS($S($E(_), Typeof, $E(_), ConditionalExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var TypePrimary$0 = $S($E(_), Infer, $E(_), IdentifierName, $E($S(NotDedented, ExtendsToken, Type)));
+      var TypePrimary$1 = $TS($S($E(_), Typeof, $E(_), UnaryExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
         return {
           type: "TypeofType",
           children: $0
         };
       });
-      var TypePrimary$1 = $TS($S($E(_), TypeTuple), function($skip, $loc, $0, $1, $2) {
+      var TypePrimary$2 = $TS($S($E(_), TypeTuple), function($skip, $loc, $0, $1, $2) {
         return { ...$2, children: [$1, ...$2.children] };
       });
-      var TypePrimary$2 = InterfaceBlock;
-      var TypePrimary$3 = $S($E(_), FunctionType);
-      var TypePrimary$4 = $S($E(_), InlineInterfaceLiteral);
-      var TypePrimary$5 = $TS($S($E(_), ImportType), function($skip, $loc, $0, $1, $2) {
+      var TypePrimary$3 = InterfaceBlock;
+      var TypePrimary$4 = $S($E(_), FunctionType);
+      var TypePrimary$5 = $S($E(_), InlineInterfaceLiteral);
+      var TypePrimary$6 = $TS($S($E(_), ImportType), function($skip, $loc, $0, $1, $2) {
         var t = $2;
         return {
           type: "ImportType",
@@ -13236,7 +13363,7 @@ ${input.slice(result.pos)}
           children: $0
         };
       });
-      var TypePrimary$6 = $TS($S($E(_), TypeLiteral), function($skip, $loc, $0, $1, $2) {
+      var TypePrimary$7 = $TS($S($E(_), TypeLiteral), function($skip, $loc, $0, $1, $2) {
         var t = $2;
         return {
           type: "LiteralType",
@@ -13244,7 +13371,7 @@ ${input.slice(result.pos)}
           children: $0
         };
       });
-      var TypePrimary$7 = $TS($S($E(_), UnknownAlias), function($skip, $loc, $0, $1, $2) {
+      var TypePrimary$8 = $TS($S($E(_), UnknownAlias), function($skip, $loc, $0, $1, $2) {
         return {
           type: "IdentifierType",
           children: $0,
@@ -13252,7 +13379,7 @@ ${input.slice(result.pos)}
           args: void 0
         };
       });
-      var TypePrimary$8 = $TS($S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var TypePrimary$9 = $TS($S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments)), function($skip, $loc, $0, $1, $2, $3, $4) {
         var args = $4;
         return {
           type: "IdentifierType",
@@ -13261,13 +13388,13 @@ ${input.slice(result.pos)}
           args
         };
       });
-      var TypePrimary$9 = $TS($S($E(_), OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var TypePrimary$10 = $TS($S($E(_), OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         return {
           type: "ParenthesizedType",
           children: $0
         };
       });
-      var TypePrimary$$ = [TypePrimary$0, TypePrimary$1, TypePrimary$2, TypePrimary$3, TypePrimary$4, TypePrimary$5, TypePrimary$6, TypePrimary$7, TypePrimary$8, TypePrimary$9];
+      var TypePrimary$$ = [TypePrimary$0, TypePrimary$1, TypePrimary$2, TypePrimary$3, TypePrimary$4, TypePrimary$5, TypePrimary$6, TypePrimary$7, TypePrimary$8, TypePrimary$9, TypePrimary$10];
       function TypePrimary(ctx, state) {
         return $EVENT_C(ctx, state, "TypePrimary", TypePrimary$$);
       }
@@ -13343,11 +13470,7 @@ ${input.slice(result.pos)}
           return [$1, $2, $3, $7, $5, $6, $4];
         return $0;
       });
-      var TypeConditional$2 = $TS($S(TypeBinary, $E($S($E(IndentedFurther), ExtendsToken, Type))), function($skip, $loc, $0, $1, $2) {
-        if (!$2)
-          return $1;
-        return $0;
-      });
+      var TypeConditional$2 = TypeBinary;
       var TypeConditional$$ = [TypeConditional$0, TypeConditional$1, TypeConditional$2];
       function TypeConditional(ctx, state) {
         return $EVENT_C(ctx, state, "TypeConditional", TypeConditional$$);
@@ -13419,7 +13542,7 @@ ${input.slice(result.pos)}
       }
       var TypeLiteral$0 = TypeTemplateLiteral;
       var TypeLiteral$1 = Literal;
-      var TypeLiteral$2 = $TS($S($EXPECT($L194, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var TypeLiteral$2 = $TS($S($EXPECT($L195, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { type: "VoidType", $loc, token: $1 };
       });
       var TypeLiteral$3 = $TV($EXPECT($L214, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
@@ -13505,7 +13628,7 @@ ${input.slice(result.pos)}
       function TypeParameters(ctx, state) {
         return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
       }
-      var TypeParameter$0 = $S(__, $E($S($EXPECT($L154, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
+      var TypeParameter$0 = $S(__, $E($S($EXPECT($L155, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
       function TypeParameter(ctx, state) {
         return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
       }
@@ -14317,6 +14440,7 @@ ${input.slice(result.pos)}
       exports.ArrowFunction = ArrowFunction;
       exports.FatArrow = FatArrow;
       exports.TrailingDeclaration = TrailingDeclaration;
+      exports.TrailingPipe = TrailingPipe;
       exports.FatArrowBody = FatArrowBody;
       exports.ConditionalExpression = ConditionalExpression;
       exports.TernaryRest = TernaryRest;
@@ -14750,6 +14874,7 @@ ${input.slice(result.pos)}
       exports.If = If;
       exports.Import = Import;
       exports.In = In;
+      exports.Infer = Infer;
       exports.LetOrConst = LetOrConst;
       exports.Const = Const;
       exports.Is = Is;
@@ -14848,6 +14973,9 @@ ${input.slice(result.pos)}
       exports.UsingJSModeError = UsingJSModeError;
       exports.TypeDeclaration = TypeDeclaration;
       exports.TypeDeclarationRest = TypeDeclarationRest;
+      exports.TypeAliasDeclaration = TypeAliasDeclaration;
+      exports.InterfaceDeclaration = InterfaceDeclaration;
+      exports.NamespaceDeclaration = NamespaceDeclaration;
       exports.OptionalEquals = OptionalEquals;
       exports.TypeLexicalDeclaration = TypeLexicalDeclaration;
       exports.TypeDeclarationBinding = TypeDeclarationBinding;
@@ -14875,7 +15003,7 @@ ${input.slice(result.pos)}
       exports.EnumDeclaration = EnumDeclaration;
       exports.EnumBlock = EnumBlock;
       exports.NestedEnumProperties = NestedEnumProperties;
-      exports.NestedEnumProperty = NestedEnumProperty;
+      exports.NestedEnumPropertyLine = NestedEnumPropertyLine;
       exports.EnumProperty = EnumProperty;
       exports.TypeProperty = TypeProperty;
       exports.TypeIndexSignature = TypeIndexSignature;