@danielx/civet 0.6.35 → 0.6.37

package/dist/main.mjs

@@ -523,23 +523,16 @@ var require_lib = __commonJS({
       }
     }
     function addPostfixStatement(statement, ws, post) {
-      let children, expressions;
-      const prefix = post.blockPrefix || post.condition?.expression.blockPrefix;
-      if (prefix?.length) {
-        const indent = prefix[0][0];
-        expressions = [...prefix, [indent, statement]];
-        children = [" {\n", ...expressions, "\n", indent?.slice?.(0, -2), "}"];
-      } else {
-        expressions = [["", statement]];
-        children = [" { ", ...expressions, " }"];
-      }
+      const expressions = [
+        ...post.blockPrefix || [],
+        ["", statement]
+      ];
       const block = {
         type: "BlockStatement",
-        children,
+        children: [" { ", expressions, " }"],
         expressions
       };
-      children = [...post.children];
-      children.push(block);
+      const children = [...post.children, block];
       if (!isWhitespaceOrEmpty(ws))
         children.push(ws);
       post = { ...post, children, block };
@@ -2115,6 +2108,81 @@ var require_lib = __commonJS({
         children
       };
     }
+    function processDeclarationCondition(condition) {
+      if (!(condition.type === "DeclarationCondition")) {
+        return;
+      }
+      const ref = makeRef();
+      const { decl, bindings } = condition.declaration;
+      const binding = bindings[0];
+      const { pattern, suffix, initializer, splices, thisAssignments } = binding;
+      const initCondition = {
+        type: "AssignmentExpression",
+        children: [ref, initializer],
+        hoistDec: {
+          type: "Declaration",
+          children: ["let ", ref, suffix],
+          names: []
+        },
+        blockPrefix: [
+          ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
+          ...thisAssignments
+        ],
+        pattern,
+        ref
+      };
+      Object.assign(condition, initCondition);
+    }
+    function processDeclarationConditions(node) {
+      gatherRecursiveAll(node, (n) => {
+        return n.type === "IfStatement" || n.type === "IterationStatement";
+      }).forEach(processDeclarationConditionStatement);
+    }
+    function processDeclarationConditionStatement(s) {
+      const { condition } = s;
+      if (!condition) {
+        return;
+      }
+      processDeclarationCondition(condition.expression);
+      const { ref, pattern } = condition.expression;
+      if (pattern) {
+        let conditions = [];
+        getPatternConditions(pattern, ref, conditions);
+        conditions = conditions.filter((c) => {
+          return !(c.length === 3 && c[0] === "typeof " && c[1] === ref && c[2] === " === 'object'") && !(c.length === 2 && c[0] === ref && c[1] === " != null");
+        });
+        if (conditions.length) {
+          condition.children.unshift("(");
+          conditions.forEach(function(c) {
+            return condition.children.push(" && ", c);
+          });
+          condition.children.push(")");
+        }
+      }
+      switch (s.type) {
+        case "IfStatement": {
+          const { else: e } = s;
+          const block = blockWithPrefix(condition.expression.blockPrefix, s.then);
+          s.then = block;
+          const toAdd = [block];
+          if (block.bare && e) {
+            toAdd.push(";");
+          }
+          s.children.splice(2, 1, ...toAdd);
+          updateParentPointers(block, s);
+          break;
+        }
+        case "IterationStatement": {
+          const { children, block } = s;
+          const newBlock = blockWithPrefix(condition.expression.blockPrefix, block);
+          s.children = children.map(function(c) {
+            return c.type === "BlockStatement" ? newBlock : c;
+          });
+          updateParentPointers(newBlock, s);
+          break;
+        }
+      }
+    }
     function implicitFunctionBlock(f) {
       if (f.abstract || f.block || f.signature?.optional)
         return;
@@ -2788,6 +2856,7 @@ var require_lib = __commonJS({
       assert.equal(m.JSXTagStack.length, 1, "JSXTagStack");
       addParentPointers(root);
       const { expressions: statements } = root;
+      processDeclarationConditions(statements);
       processPipelineExpressions(statements);
       processAssignments(statements);
       processPatternMatching(statements, ReservedWord);
@@ -3890,6 +3959,7 @@ var require_parser = __commonJS({
       Typeof,
       Unless,
       Until,
+      Using,
       Var,
       Void,
       When,
@@ -3940,6 +4010,9 @@ var require_parser = __commonJS({
       JSXChildExpression,
       IndentedJSXChildExpression,
       NestedJSXChildExpression,
+      UsingDeclaration,
+      UsingBinding,
+      UsingJSModeError,
       TypeDeclaration,
       TypeDeclarationRest,
       OptionalEquals,
@@ -4257,29 +4330,30 @@ var require_parser = __commonJS({
     var $L184 = $L("typeof");
     var $L185 = $L("unless");
     var $L186 = $L("until");
-    var $L187 = $L("var");
-    var $L188 = $L("void");
-    var $L189 = $L("when");
-    var $L190 = $L("while");
-    var $L191 = $L("yield");
-    var $L192 = $L("/>");
-    var $L193 = $L("</");
-    var $L194 = $L("<>");
-    var $L195 = $L("</>");
-    var $L196 = $L("<!--");
-    var $L197 = $L("-->");
-    var $L198 = $L("type");
-    var $L199 = $L("enum");
-    var $L200 = $L("interface");
-    var $L201 = $L("global");
-    var $L202 = $L("module");
-    var $L203 = $L("namespace");
-    var $L204 = $L("asserts");
-    var $L205 = $L("keyof");
-    var $L206 = $L("infer");
-    var $L207 = $L("???");
-    var $L208 = $L("[]");
-    var $L209 = $L("civet");
+    var $L187 = $L("using");
+    var $L188 = $L("var");
+    var $L189 = $L("void");
+    var $L190 = $L("when");
+    var $L191 = $L("while");
+    var $L192 = $L("yield");
+    var $L193 = $L("/>");
+    var $L194 = $L("</");
+    var $L195 = $L("<>");
+    var $L196 = $L("</>");
+    var $L197 = $L("<!--");
+    var $L198 = $L("-->");
+    var $L199 = $L("type");
+    var $L200 = $L("enum");
+    var $L201 = $L("interface");
+    var $L202 = $L("global");
+    var $L203 = $L("module");
+    var $L204 = $L("namespace");
+    var $L205 = $L("asserts");
+    var $L206 = $L("keyof");
+    var $L207 = $L("infer");
+    var $L208 = $L("???");
+    var $L209 = $L("[]");
+    var $L210 = $L("civet");
     var $R0 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
     var $R1 = $R(new RegExp("[0-9]", "suy"));
     var $R2 = $R(new RegExp("[)}]", "suy"));
@@ -8093,16 +8167,10 @@ var require_parser = __commonJS({
       var clause = $1;
       var block = $2;
       var e = $3;
-      const children = [...clause.children];
-      block = blockWithPrefix(clause.condition.expression.blockPrefix, block);
-      children.push(block);
-      if (block.bare && e)
-        children.push(";");
-      if (e)
-        children.push(e);
       return {
-        ...clause,
-        children,
+        type: "IfStatement",
+        children: [...clause.children, block, e],
+        condition: clause.condition,
         then: block,
         else: e
       };
@@ -8325,7 +8393,6 @@ var require_parser = __commonJS({
     var WhileStatement$0 = $TS($S(WhileClause, Block), function($skip, $loc, $0, $1, $2) {
       var clause = $1;
       var block = $2;
-      block = blockWithPrefix(clause.condition.expression.blockPrefix, block);
       return {
         ...clause,
         children: [...clause.children, block],
@@ -8944,27 +9011,13 @@ var require_parser = __commonJS({
       return $EVENT_C(ctx, state, "Condition", Condition$$);
     }
     var DeclarationCondition$0 = $TS($S(ForbidIndentedApplication, $E(LexicalDeclaration), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
-      var dec = $2;
-      if (!dec)
+      var declaration = $2;
+      if (!declaration)
         return $skip;
-      const ref = makeRef();
-      const { decl, bindings } = dec;
-      const binding = bindings[0];
-      const { pattern, suffix, initializer, splices, thisAssignments } = binding;
-      const initCondition = {
-        type: "AssignmentExpression",
-        children: [ref, initializer],
-        hoistDec: {
-          type: "Declaration",
-          children: ["let ", ref, suffix],
-          names: []
-        },
-        blockPrefix: [
-          ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
-          ...thisAssignments
-        ]
+      return {
+        type: "DeclarationCondition",
+        declaration
       };
-      return initCondition;
     });
     function DeclarationCondition(ctx, state) {
       return $EVENT(ctx, state, "DeclarationCondition", DeclarationCondition$0);
@@ -9490,7 +9543,8 @@ var require_parser = __commonJS({
     var Declaration$3 = TypeDeclaration;
     var Declaration$4 = EnumDeclaration;
     var Declaration$5 = OperatorDeclaration;
-    var Declaration$$ = [Declaration$0, Declaration$1, Declaration$2, Declaration$3, Declaration$4, Declaration$5];
+    var Declaration$6 = UsingDeclaration;
+    var Declaration$$ = [Declaration$0, Declaration$1, Declaration$2, Declaration$3, Declaration$4, Declaration$5, Declaration$6];
     function Declaration(ctx, state) {
       return $EVENT_C(ctx, state, "Declaration", Declaration$$);
     }
@@ -10563,31 +10617,37 @@ var require_parser = __commonJS({
     function Until(ctx, state) {
       return $EVENT(ctx, state, "Until", Until$0);
     }
-    var Var$0 = $TS($S($EXPECT($L187, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Using$0 = $TS($S($EXPECT($L187, '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($L188, '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($L188, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Void$0 = $TS($S($EXPECT($L189, '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($L189, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var When$0 = $TS($S($EXPECT($L190, '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($L190, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var While$0 = $TS($S($EXPECT($L191, '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($L191, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Yield$0 = $TS($S($EXPECT($L192, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1, type: "Yield" };
     });
     function Yield(ctx, state) {
@@ -10660,7 +10720,7 @@ var require_parser = __commonJS({
     function JSXElement(ctx, state) {
       return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
     }
-    var JSXSelfClosingElement$0 = $TS($S($EXPECT($L155, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L192, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+    var JSXSelfClosingElement$0 = $TS($S($EXPECT($L155, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L193, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
       return { type: "JSXElement", children: $0, tag: $2 };
     });
     function JSXSelfClosingElement(ctx, state) {
@@ -10694,7 +10754,7 @@ var require_parser = __commonJS({
     function JSXOptionalClosingElement(ctx, state) {
       return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
     }
-    var JSXClosingElement$0 = $S($EXPECT($L193, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L33, 'JSXClosingElement ">"'));
+    var JSXClosingElement$0 = $S($EXPECT($L194, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L33, 'JSXClosingElement ">"'));
     function JSXClosingElement(ctx, state) {
       return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
     }
@@ -10715,7 +10775,7 @@ var require_parser = __commonJS({
       ];
       return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
     });
-    var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L194, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L195, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var children = $3;
       $0 = $0.slice(1);
       return {
@@ -10728,7 +10788,7 @@ var require_parser = __commonJS({
     function JSXFragment(ctx, state) {
       return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
     }
-    var PushJSXOpeningFragment$0 = $TV($EXPECT($L194, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
+    var PushJSXOpeningFragment$0 = $TV($EXPECT($L195, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
       module.JSXTagStack.push("");
       return $1;
     });
@@ -10745,7 +10805,7 @@ var require_parser = __commonJS({
     function JSXOptionalClosingFragment(ctx, state) {
       return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
     }
-    var JSXClosingFragment$0 = $EXPECT($L195, 'JSXClosingFragment "</>"');
+    var JSXClosingFragment$0 = $EXPECT($L196, 'JSXClosingFragment "</>"');
     function JSXClosingFragment(ctx, state) {
       return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
     }
@@ -11214,7 +11274,7 @@ var require_parser = __commonJS({
     function JSXChild(ctx, state) {
       return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
     }
-    var JSXComment$0 = $TS($S($EXPECT($L196, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L197, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
+    var JSXComment$0 = $TS($S($EXPECT($L197, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L198, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
       return ["{/*", $2, "*/}"];
     });
     function JSXComment(ctx, state) {
@@ -11252,6 +11312,52 @@ var require_parser = __commonJS({
     function NestedJSXChildExpression(ctx, state) {
       return $EVENT(ctx, state, "NestedJSXChildExpression", NestedJSXChildExpression$0);
     }
+    var UsingDeclaration$0 = $TS($S(Using, $E(_), UsingBinding, $Q($S(__, Comma, __, UsingBinding)), UsingJSModeError), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var decl = $1;
+      var binding = $3;
+      var tail = $4;
+      const bindings = [binding].concat(tail.map(([, , , b]) => b));
+      return {
+        type: "Declaration",
+        children: $0,
+        names: bindings.flatMap((b) => b.names),
+        bindings,
+        decl,
+        splices: bindings.flatMap((b) => b.splices),
+        thisAssignments: bindings.flatMap((b) => b.thisAssignments)
+      };
+    });
+    function UsingDeclaration(ctx, state) {
+      return $EVENT(ctx, state, "UsingDeclaration", UsingDeclaration$0);
+    }
+    var UsingBinding$0 = $TS($S(BindingIdentifier, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
+      var pattern = $1;
+      var suffix = $2;
+      var initializer = $3;
+      return {
+        type: "Binding",
+        children: $0,
+        names: pattern.names,
+        pattern,
+        suffix,
+        initializer,
+        splices: [],
+        thisAssignments: []
+      };
+    });
+    function UsingBinding(ctx, state) {
+      return $EVENT(ctx, state, "UsingBinding", UsingBinding$0);
+    }
+    var UsingJSModeError$0 = $TV($EXPECT($L0, 'UsingJSModeError ""'), function($skip, $loc, $0, $1) {
+      return {
+        type: "Error",
+        js: true,
+        message: "`using` is not currently transpiled in JS mode."
+      };
+    });
+    function UsingJSModeError(ctx, state) {
+      return $EVENT(ctx, state, "UsingJSModeError", UsingJSModeError$0);
+    }
     var TypeDeclaration$0 = $T($S($E($S(Export, $E(_))), $S(Declare, $E(_)), TypeLexicalDeclaration), function(value) {
       return { "ts": true, "children": value };
     });
@@ -11300,37 +11406,37 @@ var require_parser = __commonJS({
     function InterfaceExtendsTarget(ctx, state) {
       return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
     }
-    var TypeKeyword$0 = $TS($S($EXPECT($L198, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var TypeKeyword$0 = $TS($S($EXPECT($L199, '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($L199, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Enum$0 = $TS($S($EXPECT($L200, '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($L200, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Interface$0 = $TS($S($EXPECT($L201, '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($L201, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Global$0 = $TS($S($EXPECT($L202, '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($L202, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Module$0 = $TS($S($EXPECT($L203, '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($L203, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Namespace$0 = $TS($S($EXPECT($L204, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function Namespace(ctx, state) {
@@ -11575,7 +11681,7 @@ var require_parser = __commonJS({
     function ReturnTypeSuffix(ctx, state) {
       return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
     }
-    var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L204, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
+    var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L205, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
       var asserts = $1;
       var t = $2;
       if (asserts) {
@@ -11644,9 +11750,9 @@ var require_parser = __commonJS({
     function TypeUnarySuffix(ctx, state) {
       return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
     }
-    var TypeUnaryOp$0 = $S($EXPECT($L205, 'TypeUnaryOp "keyof"'), NonIdContinue);
+    var TypeUnaryOp$0 = $S($EXPECT($L206, 'TypeUnaryOp "keyof"'), NonIdContinue);
     var TypeUnaryOp$1 = $S($EXPECT($L184, 'TypeUnaryOp "typeof"'), NonIdContinue);
-    var TypeUnaryOp$2 = $S($EXPECT($L206, 'TypeUnaryOp "infer"'), NonIdContinue);
+    var TypeUnaryOp$2 = $S($EXPECT($L207, 'TypeUnaryOp "infer"'), NonIdContinue);
     var TypeUnaryOp$3 = $S($EXPECT($L167, 'TypeUnaryOp "readonly"'), NonIdContinue);
     var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1, TypeUnaryOp$2, TypeUnaryOp$3];
     function TypeUnaryOp(ctx, state) {
@@ -11656,7 +11762,7 @@ var require_parser = __commonJS({
     function TypeIndexedAccess(ctx, state) {
       return $EVENT(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$0);
     }
-    var UnknownAlias$0 = $TV($EXPECT($L207, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
+    var UnknownAlias$0 = $TV($EXPECT($L208, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
       return { $loc, token: "unknown" };
     });
     function UnknownAlias(ctx, state) {
@@ -11796,10 +11902,10 @@ var require_parser = __commonJS({
     }
     var TypeLiteral$0 = TypeTemplateLiteral;
     var TypeLiteral$1 = Literal;
-    var TypeLiteral$2 = $TS($S($EXPECT($L188, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var TypeLiteral$2 = $TS($S($EXPECT($L189, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { type: "VoidType", $loc, token: $1 };
     });
-    var TypeLiteral$3 = $TV($EXPECT($L208, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
+    var TypeLiteral$3 = $TV($EXPECT($L209, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
       return { $loc, token: "[]" };
     });
     var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3];
@@ -11920,7 +12026,7 @@ var require_parser = __commonJS({
     function CivetPrologue(ctx, state) {
       return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
     }
-    var CivetPrologueContent$0 = $TS($S($EXPECT($L209, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R63, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R63, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
       var options = $3;
       return {
         type: "CivetPrologue",
@@ -13076,6 +13182,7 @@ var require_parser = __commonJS({
     exports.Typeof = Typeof;
     exports.Unless = Unless;
     exports.Until = Until;
+    exports.Using = Using;
     exports.Var = Var;
     exports.Void = Void;
     exports.When = When;
@@ -13126,6 +13233,9 @@ var require_parser = __commonJS({
     exports.JSXChildExpression = JSXChildExpression;
     exports.IndentedJSXChildExpression = IndentedJSXChildExpression;
     exports.NestedJSXChildExpression = NestedJSXChildExpression;
+    exports.UsingDeclaration = UsingDeclaration;
+    exports.UsingBinding = UsingBinding;
+    exports.UsingJSModeError = UsingJSModeError;
     exports.TypeDeclaration = TypeDeclaration;
     exports.TypeDeclarationRest = TypeDeclarationRest;
     exports.OptionalEquals = OptionalEquals;
@@ -13315,17 +13425,17 @@ function gen(node, options) {
     }).join("");
   }
   if (typeof node === "object") {
-    if (node.type === "Error") {
-      options.errors ?? (options.errors = []);
-      options.errors.push(node);
-      return "";
-    }
     if (options.js && node.ts) {
       return "";
     }
     if (!options.js && node.js) {
       return "";
     }
+    if (node.type === "Error") {
+      options.errors ?? (options.errors = []);
+      options.errors.push(node);
+      return "";
+    }
     if (node.$loc != null) {
       const { token, $loc } = node;
       options?.updateSourceMap?.(token, $loc.pos);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielx/civet",
   "type": "commonjs",
-  "version": "0.6.35",
+  "version": "0.6.37",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",