@danielx/civet 0.6.71 → 0.6.73

package/dist/main.mjs

@@ -2252,9 +2252,17 @@ function processReturn(f, implicitReturns) {
     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);
+        }
+      }
     }
   }
 }
@@ -2661,8 +2669,8 @@ function nonMatcherBindings(pattern) {
   }
 }
 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) => {
@@ -2692,20 +2700,22 @@ function aggregateDuplicateBindings(bindings, ReservedWord) {
     }
   }
   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);
@@ -2718,7 +2728,7 @@ function aggregateDuplicateBindings(bindings, ReservedWord) {
   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) {
@@ -2732,7 +2742,7 @@ function processPatternMatching(statements, ReservedWord) {
     }
     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")) {
@@ -2746,8 +2756,9 @@ function processPatternMatching(statements, ReservedWord) {
         return;
       });
     }
-    if (errors || !isPattern)
+    if (errors || !isPattern) {
       return;
+    }
     let { condition } = s;
     if (condition.type === "ParenthesizedExpression") {
       condition = condition.expression;
@@ -2959,7 +2970,7 @@ function processPipelineExpressions(statements) {
       };
     }
     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, {
@@ -3082,7 +3093,7 @@ function createVarDecs(statements, scopes, pushVar) {
   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;
@@ -3387,8 +3398,9 @@ function reorderBindingRestProperty(props) {
         }
       ];
     }
-    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 {
@@ -4133,6 +4145,7 @@ var require_parser = __commonJS({
       ArrowFunction,
       FatArrow,
       TrailingDeclaration,
+      TrailingPipe,
       FatArrowBody,
       ConditionalExpression,
       TernaryRest,
@@ -4566,6 +4579,7 @@ var require_parser = __commonJS({
       If,
       Import,
       In,
+      Infer,
       LetOrConst,
       Const,
       Is,
@@ -4664,6 +4678,9 @@ var require_parser = __commonJS({
       UsingJSModeError,
       TypeDeclaration,
       TypeDeclarationRest,
+      TypeAliasDeclaration,
+      InterfaceDeclaration,
+      NamespaceDeclaration,
       OptionalEquals,
       TypeLexicalDeclaration,
       TypeDeclarationBinding,
@@ -4691,7 +4708,7 @@ var require_parser = __commonJS({
       EnumDeclaration,
       EnumBlock,
       NestedEnumProperties,
-      NestedEnumProperty,
+      NestedEnumPropertyLine,
       EnumProperty,
       TypeProperty,
       TypeIndexSignature,
@@ -4950,66 +4967,66 @@ var require_parser = __commonJS({
     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");
@@ -5746,12 +5763,23 @@ var require_parser = __commonJS({
     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];
@@ -5881,7 +5909,7 @@ var require_parser = __commonJS({
       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);
     });
@@ -5898,6 +5926,7 @@ var require_parser = __commonJS({
         decorators,
         abstract,
         binding,
+        id: binding?.[0],
         heritage,
         body,
         children: $0
@@ -6215,7 +6244,8 @@ var require_parser = __commonJS({
           name: id.name,
           children: [".", id]
         }],
-        privateShorthand: true
+        privateShorthand: true,
+        privateId: id
       };
     });
     var PrivateThis$$ = [PrivateThis$0, PrivateThis$1];
@@ -7401,7 +7431,10 @@ var require_parser = __commonJS({
       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;
@@ -7423,7 +7456,10 @@ var require_parser = __commonJS({
       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) {
@@ -8310,14 +8346,17 @@ var require_parser = __commonJS({
     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);
@@ -8715,7 +8754,12 @@ var require_parser = __commonJS({
                   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({
@@ -10794,18 +10838,45 @@ var require_parser = __commonJS({
         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$$);
     }
@@ -10969,6 +11040,7 @@ var require_parser = __commonJS({
     var VariableStatement$0 = $TS($S(Var, __, VariableDeclarationList), function($skip, $loc, $0, $1, $2, $3) {
       return {
         ...$3,
+        names: $3.names,
         children: [$1, ...$2, ...$3.children]
       };
     });
@@ -11144,7 +11216,7 @@ var require_parser = __commonJS({
       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(
@@ -11156,13 +11228,16 @@ var require_parser = __commonJS({
           "`"
         ];
         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",
@@ -11729,19 +11804,25 @@ var require_parser = __commonJS({
     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) {
@@ -11753,25 +11834,25 @@ var require_parser = __commonJS({
     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) {
@@ -11789,7 +11870,7 @@ var require_parser = __commonJS({
     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) {
@@ -11801,43 +11882,43 @@ var require_parser = __commonJS({
     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];
@@ -11850,19 +11931,19 @@ var require_parser = __commonJS({
     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) {
@@ -11874,7 +11955,7 @@ var require_parser = __commonJS({
     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) {
@@ -11886,7 +11967,7 @@ var require_parser = __commonJS({
     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) {
@@ -11896,127 +11977,127 @@ var require_parser = __commonJS({
     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) {
@@ -12095,7 +12176,7 @@ var require_parser = __commonJS({
     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) {
@@ -12129,7 +12210,7 @@ var require_parser = __commonJS({
     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);
     }
@@ -12150,7 +12231,7 @@ var require_parser = __commonJS({
       ];
       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 {
@@ -12163,7 +12244,7 @@ var require_parser = __commonJS({
     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;
     });
@@ -12180,7 +12261,7 @@ var require_parser = __commonJS({
     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);
     }
@@ -12654,7 +12735,7 @@ var require_parser = __commonJS({
     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) {
@@ -12741,21 +12822,66 @@ var require_parser = __commonJS({
     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];
@@ -12786,37 +12912,37 @@ var require_parser = __commonJS({
     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) {
@@ -12918,9 +13044,10 @@ var require_parser = __commonJS({
         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"],
@@ -12962,8 +13089,8 @@ var require_parser = __commonJS({
               }
             })
           ]
-        }
-      ];
+        }]
+      };
     });
     function EnumDeclaration(ctx, state) {
       return $EVENT(ctx, state, "EnumDeclaration", EnumDeclaration$0);
@@ -12993,26 +13120,26 @@ var require_parser = __commonJS({
     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;
@@ -13089,7 +13216,7 @@ var require_parser = __commonJS({
     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) {
@@ -13110,7 +13237,7 @@ var require_parser = __commonJS({
     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)
@@ -13144,7 +13271,7 @@ var require_parser = __commonJS({
     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;
@@ -13168,10 +13295,9 @@ var require_parser = __commonJS({
     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$$);
     }
@@ -13206,19 +13332,20 @@ var require_parser = __commonJS({
     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",
@@ -13226,7 +13353,7 @@ var require_parser = __commonJS({
         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",
@@ -13234,7 +13361,7 @@ var require_parser = __commonJS({
         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,
@@ -13242,7 +13369,7 @@ var require_parser = __commonJS({
         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",
@@ -13251,13 +13378,13 @@ var require_parser = __commonJS({
         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$$);
     }
@@ -13333,11 +13460,7 @@ var require_parser = __commonJS({
         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$$);
@@ -13409,7 +13532,7 @@ var require_parser = __commonJS({
     }
     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) {
@@ -13495,7 +13618,7 @@ var require_parser = __commonJS({
     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);
     }
@@ -14307,6 +14430,7 @@ var require_parser = __commonJS({
     exports.ArrowFunction = ArrowFunction;
     exports.FatArrow = FatArrow;
     exports.TrailingDeclaration = TrailingDeclaration;
+    exports.TrailingPipe = TrailingPipe;
     exports.FatArrowBody = FatArrowBody;
     exports.ConditionalExpression = ConditionalExpression;
     exports.TernaryRest = TernaryRest;
@@ -14740,6 +14864,7 @@ var require_parser = __commonJS({
     exports.If = If;
     exports.Import = Import;
     exports.In = In;
+    exports.Infer = Infer;
     exports.LetOrConst = LetOrConst;
     exports.Const = Const;
     exports.Is = Is;
@@ -14838,6 +14963,9 @@ var require_parser = __commonJS({
     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;
@@ -14865,7 +14993,7 @@ var require_parser = __commonJS({
     exports.EnumDeclaration = EnumDeclaration;
     exports.EnumBlock = EnumBlock;
     exports.NestedEnumProperties = NestedEnumProperties;
-    exports.NestedEnumProperty = NestedEnumProperty;
+    exports.NestedEnumPropertyLine = NestedEnumPropertyLine;
     exports.EnumProperty = EnumProperty;
     exports.TypeProperty = TypeProperty;
     exports.TypeIndexSignature = TypeIndexSignature;