@danielx/civet 0.6.35 → 0.6.37

package/dist/browser.js

@@ -526,23 +526,16 @@ ${input.slice(result.pos)}
         }
       }
       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 };
@@ -2118,6 +2111,81 @@ ${input.slice(result.pos)}
           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;
@@ -2791,6 +2859,7 @@ ${input.slice(result.pos)}
         assert.equal(m.JSXTagStack.length, 1, "JSXTagStack");
         addParentPointers(root);
         const { expressions: statements } = root;
+        processDeclarationConditions(statements);
         processPipelineExpressions(statements);
         processAssignments(statements);
         processPatternMatching(statements, ReservedWord);
@@ -3893,6 +3962,7 @@ ${input.slice(result.pos)}
         Typeof,
         Unless,
         Until,
+        Using,
         Var,
         Void,
         When,
@@ -3943,6 +4013,9 @@ ${input.slice(result.pos)}
         JSXChildExpression,
         IndentedJSXChildExpression,
         NestedJSXChildExpression,
+        UsingDeclaration,
+        UsingBinding,
+        UsingJSModeError,
         TypeDeclaration,
         TypeDeclarationRest,
         OptionalEquals,
@@ -4260,29 +4333,30 @@ ${input.slice(result.pos)}
       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"));
@@ -8096,16 +8170,10 @@ ${input.slice(result.pos)}
         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
         };
@@ -8328,7 +8396,6 @@ ${input.slice(result.pos)}
       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],
@@ -8947,27 +9014,13 @@ ${input.slice(result.pos)}
         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);
@@ -9493,7 +9546,8 @@ ${input.slice(result.pos)}
       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$$);
       }
@@ -10566,31 +10620,37 @@ ${input.slice(result.pos)}
       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) {
@@ -10663,7 +10723,7 @@ ${input.slice(result.pos)}
       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) {
@@ -10697,7 +10757,7 @@ ${input.slice(result.pos)}
       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);
       }
@@ -10718,7 +10778,7 @@ ${input.slice(result.pos)}
         ];
         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 {
@@ -10731,7 +10791,7 @@ ${input.slice(result.pos)}
       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;
       });
@@ -10748,7 +10808,7 @@ ${input.slice(result.pos)}
       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);
       }
@@ -11217,7 +11277,7 @@ ${input.slice(result.pos)}
       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) {
@@ -11255,6 +11315,52 @@ ${input.slice(result.pos)}
       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 };
       });
@@ -11303,37 +11409,37 @@ ${input.slice(result.pos)}
       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) {
@@ -11578,7 +11684,7 @@ ${input.slice(result.pos)}
       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) {
@@ -11647,9 +11753,9 @@ ${input.slice(result.pos)}
       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) {
@@ -11659,7 +11765,7 @@ ${input.slice(result.pos)}
       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) {
@@ -11799,10 +11905,10 @@ ${input.slice(result.pos)}
       }
       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];
@@ -11923,7 +12029,7 @@ ${input.slice(result.pos)}
       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",
@@ -13079,6 +13185,7 @@ ${input.slice(result.pos)}
       exports.Typeof = Typeof;
       exports.Unless = Unless;
       exports.Until = Until;
+      exports.Using = Using;
       exports.Var = Var;
       exports.Void = Void;
       exports.When = When;
@@ -13129,6 +13236,9 @@ ${input.slice(result.pos)}
       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;
@@ -13327,17 +13437,17 @@ ${input.slice(result.pos)}
       }).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/dist/bun-civet.mjs

@@ -2,11 +2,11 @@ import { plugin } from "bun";
 await plugin({
   name: "Civet loader",
   setup: async function(builder) {
-    ({ compile } = await import("./main.mjs"));
-    ({ readFileSync } = await import("fs"));
+    const { compile } = await import("./main.mjs");
+    const { readFileSync } = await import("fs");
     return builder.onLoad({ filter: /\.civet$/ }, function({ path }) {
-      source = readFileSync(path, "utf8");
-      contents = compile(source);
+      const source = readFileSync(path, "utf8");
+      const contents = compile(source);
       return {
         contents,
         loader: "tsx"