@danielx/civet 0.7.7 → 0.7.9

package/dist/esbuild.js

@@ -37,6 +37,7 @@ module.exports = __toCommonJS(esbuild_exports);
 // src/index.ts
 var import_unplugin = require("unplugin");
 var import_civet = __toESM(require("@danielx/civet"));
+var import_config = require("@danielx/civet/config");
 var import_ts_diagnostic = require("@danielx/civet/ts-diagnostic");
 var fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
@@ -90,6 +91,7 @@ var rawPlugin = (options = {}, meta) => {
     options.emitDeclaration = options.dts;
   if (options.js)
     options.ts = "civet";
+  let compileOptions = {};
   const transformTS = options.emitDeclaration || options.typecheck;
   const outExt = options.outputExtension ?? (options.ts === "preserve" ? ".tsx" : ".jsx");
   const implicitExtension = options.implicitExtension ?? true;
@@ -112,12 +114,20 @@ var rawPlugin = (options = {}, meta) => {
     async buildStart() {
       if (transformTS || options.ts === "tsc") {
         const ts = await tsPromise;
-        const configPath = ts.findConfigFile(process.cwd(), ts.sys.fileExists);
-        if (!configPath) {
+        const civetConfigPath = "config" in options ? options.config : await (0, import_config.findInDir)(process.cwd());
+        if (civetConfigPath) {
+          compileOptions = await (0, import_config.loadConfig)(civetConfigPath);
+        }
+        compileOptions.parseOptions = {
+          ...compileOptions.parseOptions,
+          ...options.parseOptions
+        };
+        const tsConfigPath = ts.findConfigFile(process.cwd(), ts.sys.fileExists);
+        if (!tsConfigPath) {
           throw new Error("Could not find 'tsconfig.json'");
         }
         const { config, error } = ts.readConfigFile(
-          configPath,
+          tsConfigPath,
           ts.sys.readFile
         );
         if (error) {
@@ -164,9 +174,9 @@ var rawPlugin = (options = {}, meta) => {
             encoding
           });
           const compiledTS = import_civet.default.compile(rawCivetSource, {
+            ...compileOptions,
             filename,
             js: false,
-            comptime: Boolean(options.comptime),
             sync: true
             // TS readFile API seems to need to be synchronous
           });
@@ -314,11 +324,9 @@ var rawPlugin = (options = {}, meta) => {
       this.addWatchFile(filename);
       let compiled;
       const civetOptions = {
+        ...compileOptions,
         filename: id,
-        sourceMap: true,
-        parseOptions: {
-          comptime: Boolean(options.comptime)
-        }
+        sourceMap: true
       };
       if (options.ts === "civet" && !transformTS) {
         compiled = await import_civet.default.compile(rawCivetSource, {

package/dist/main.js

@@ -550,6 +550,7 @@ __export(lib_exports, {
   processForInOf: () => processForInOf,
   processProgram: () => processProgram,
   processProgramAsync: () => processProgramAsync,
+  processTryBlock: () => processTryBlock,
   processUnaryExpression: () => processUnaryExpression,
   quoteString: () => quoteString,
   reorderBindingRestProperty: () => reorderBindingRestProperty,
@@ -1571,7 +1572,6 @@ function isExit(node) {
   if (!(node != null)) {
     return false;
   }
-  let ref2;
   switch (node.type) {
     case "ReturnStatement":
     case "ThrowStatement":
@@ -1583,13 +1583,10 @@ function isExit(node) {
       return isExit(node.then) && isExit(node.else?.block);
     }
     case "BlockStatement": {
-      return isExit((ref2 = node.expressions)[ref2.length - 1]?.[1]);
+      return node.expressions.some((s) => isExit(s[1]));
     }
     case "IterationStatement": {
-      return node.condition?.type === "ParenthesizedExpression" && node.condition.expression?.type === "Literal" && node.condition.expression?.raw === "true" && gatherRecursiveWithinFunction(
-        node.block,
-        ({ type }) => type === "BreakStatement"
-      ).length === 0;
+      return node.condition?.type === "ParenthesizedExpression" && node.condition.expression?.type === "Literal" && node.condition.expression?.raw === "true" && gatherRecursiveWithinFunction(node.block, ($) => $.type === "BreakStatement").length === 0;
     }
     default: {
       return false;
@@ -1890,8 +1887,8 @@ function updateParentPointers(node, parent, depth = 1) {
     node.parent = parent;
   }
   if (depth && isParent(node)) {
-    for (let ref3 = node.children, i3 = 0, len3 = ref3.length; i3 < len3; i3++) {
-      const child = ref3[i3];
+    for (let ref2 = node.children, i3 = 0, len3 = ref2.length; i3 < len3; i3++) {
+      const child = ref2[i3];
       updateParentPointers(child, node, depth - 1);
     }
   }
@@ -2963,6 +2960,10 @@ function aggregateDuplicateBindings(bindings) {
   const propsGroupedByName = /* @__PURE__ */ new Map();
   for (const p of props) {
     const { name, value } = p;
+    let m;
+    if (m = value?.type, m === "ArrayBindingPattern" || m === "ObjectBindingPattern") {
+      continue;
+    }
     const key = value?.name || name?.name || name;
     if (propsGroupedByName.has(key)) {
       propsGroupedByName.get(key).push(p);
@@ -3211,7 +3212,7 @@ function processDeclarationConditionStatement(s) {
     return;
   }
   let { expression } = condition;
-  if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "UnaryExpression" && "children" in expression && Array.isArray(expression.children) && len2(expression.children, 2) && expression.children[0] === "!" && typeof expression.children[1] === "object" && expression.children[1] != null && "type" in expression.children[1] && expression.children[1].type === "ParenthesizedExpression" && "expression" in expression.children[1]) {
+  if (expression && typeof expression === "object" && "type" in expression && expression.type === "UnaryExpression" && "children" in expression && Array.isArray(expression.children) && len2(expression.children, 2) && expression.children[0] === "!" && typeof expression.children[1] === "object" && expression.children[1] != null && "type" in expression.children[1] && expression.children[1].type === "ParenthesizedExpression" && "expression" in expression.children[1]) {
     const { type: type1, children: [, { type: type2, expression: expression2 }] } = expression;
     const type = [type1, type2];
     expression = expression2;
@@ -3228,40 +3229,99 @@ function processDeclarationConditionStatement(s) {
       }
     });
     if (conditions.length) {
-      condition.children.unshift("(");
-      conditions.forEach((c) => {
-        return condition.children.push(" && ", c);
-      });
-      condition.children.push(")");
+      if (s.negated) {
+        let m;
+        if (!(m = condition.expression, typeof m === "object" && m != null && "type" in m && m.type === "UnaryExpression" && "children" in m && Array.isArray(m.children) && len2(m.children, 2) && m.children[0] === "!" && typeof m.children[1] === "object" && m.children[1] != null && "type" in m.children[1] && m.children[1].type === "ParenthesizedExpression")) {
+          console.log(condition.expression);
+          throw new Error("Unsupported negated condition");
+        }
+        const { children } = condition.expression.children[1];
+        const close = children.pop();
+        conditions.forEach((c) => {
+          return children.push(" && ", c);
+        });
+        children.push(close);
+      } else {
+        condition.children.unshift("(");
+        conditions.forEach((c) => {
+          return condition.children.push(" && ", c);
+        });
+        condition.children.push(")");
+      }
     }
   }
+  const { blockPrefix } = condition.expression;
+  if (s.negated && blockPrefix && (s.type === "IfStatement" && isExit(s.then) || s.type === "IterationStatement")) {
+    const { ancestor, child } = findAncestor(
+      s,
+      (a) => a.type === "BlockStatement"
+    );
+    if (!(ancestor != null)) {
+      throw new Error("Couldn't find block for postfix declaration");
+    }
+    const index = findChildIndex(ancestor.expressions, child);
+    if (index < 0) {
+      throw new Error("Couldn't find where in block to put postfix declaration");
+    }
+    ancestor.expressions.splice(index + 1, 0, ...blockPrefix);
+    updateParentPointers(ancestor);
+    braceBlock(ancestor);
+    let ref1;
+    switch (s.type) {
+      case "IfStatement": {
+        if (ref1 = s.else?.block) {
+          const elseBlock = ref1;
+          if (elseBlock.bare && !elseBlock.semicolon) {
+            elseBlock.children.push(elseBlock.semicolon = ";");
+          }
+          ancestor.expressions.splice(index + 1 + blockPrefix.length, 0, ["", elseBlock]);
+          s.children = s.children.filter((a1) => a1 !== s.else);
+          s.else = void 0;
+        }
+        const block = s.then;
+        if (block.bare && !block.semicolon) {
+          block.children.push(block.semicolon = ";");
+        }
+        ;
+        break;
+      }
+    }
+    return;
+  }
   switch (s.type) {
     case "IfStatement": {
       const { else: e } = s;
-      const block = blockWithPrefix(condition.expression.blockPrefix, s.then);
-      if (block.bare && e && !block.semicolon) {
-        block.children.push(block.semicolon = ";");
-      }
-      s.children = s.children.map((c) => {
-        if (c === s.then) {
-          return block;
-        } else {
-          return c;
+      if (s.negated) {
+        if (e != null) {
+          const block = blockWithPrefix(blockPrefix, e.block);
+          e.children = e.children.map(($1) => $1 === e.block ? block : $1);
+          e.block = block;
+          updateParentPointers(e);
         }
-      });
-      s.then = block;
-      updateParentPointers(block, s);
+      } else {
+        const block = blockWithPrefix(blockPrefix, s.then);
+        if (block.bare && e && !block.semicolon) {
+          block.children.push(block.semicolon = ";");
+        }
+        s.children = s.children.map(($2) => $2 === s.then ? block : $2);
+        s.then = block;
+        updateParentPointers(s);
+      }
+      ;
       break;
     }
     case "IterationStatement": {
+      if (!blockPrefix) {
+        return;
+      }
       const { children, block } = s;
-      const newBlock = blockWithPrefix(condition.expression.blockPrefix, block);
-      s.children = children.map((c) => c?.type === "BlockStatement" ? newBlock : c);
-      updateParentPointers(newBlock, s);
+      const newBlock = blockWithPrefix(blockPrefix, block);
+      s.children = children.map(($3) => $3 === block ? newBlock : $3);
+      updateParentPointers(s);
       break;
     }
     case "SwitchStatement": {
-      const { blockPrefix, ref: ref2, statementDeclaration } = condition.expression;
+      const { ref: ref2, statementDeclaration } = condition.expression;
       if (!blockPrefix) {
         return;
       }
@@ -3284,7 +3344,7 @@ function processDeclarationConditionStatement(s) {
         const block = makeEmptyBlock();
         replaceBlockExpression(s.parent, s, block);
         block.expressions.push(["", s]);
-        s.children.splice(s.children.findIndex(($1) => $1.token === "switch"), 0, blockPrefix);
+        s.children.splice(s.children.findIndex(($4) => $4.token === "switch"), 0, blockPrefix);
         s.parent = block;
       } else {
         const block = blockWithPrefix([["", [{
@@ -3314,20 +3374,20 @@ function dynamizeImportDeclaration(decl) {
   const { imports } = decl;
   let { star, binding, specifiers } = imports;
   const justDefault = binding && !specifiers && !star;
-  let ref1;
+  let ref2;
   {
     if (binding) {
       if (specifiers) {
-        ref1 = makeRef();
+        ref2 = makeRef();
       } else {
-        ref1 = binding;
+        ref2 = binding;
       }
     } else {
-      ref1 = convertNamedImportsToObject(imports, true);
+      ref2 = convertNamedImportsToObject(imports, true);
     }
   }
   ;
-  const pattern = ref1;
+  const pattern = ref2;
   const c = "const";
   const expression = [
     justDefault ? "(" : void 0,
@@ -4763,6 +4823,67 @@ function handleThisPrivateShorthands(value) {
   }
   return [value, value.thisShorthand];
 }
+function processTryBlock($0) {
+  let [t, , b, c, e, f] = $0;
+  if (!c && (e || !f)) {
+    const emptyCatchBlock = makeEmptyBlock();
+    c = {
+      type: "CatchClause",
+      children: [" ", "catch(e) ", emptyCatchBlock],
+      block: emptyCatchBlock
+    };
+  }
+  let hoistDec;
+  if (e) {
+    c = c;
+    const ok = makeRef("ok");
+    hoistDec = {
+      type: "Declaration",
+      children: ["let ", ok, " = true"],
+      names: []
+    };
+    replaceNode(
+      c.block,
+      blockWithPrefix([["", "ok = false"]], c.block),
+      c
+    );
+    const condition = {
+      type: "ParenthesizedExpression",
+      children: ["(", ok, ")"],
+      expression: ok
+    };
+    const i = makeNode({
+      type: "IfStatement",
+      children: ["if", condition, e.block],
+      condition,
+      then: e.block,
+      else: void 0
+    });
+    if (!f) {
+      const emptyFinallyBlock = makeEmptyBlock();
+      f = {
+        type: "FinallyClause",
+        children: [" ", "finally ", emptyFinallyBlock],
+        block: emptyFinallyBlock
+      };
+    }
+    replaceNode(
+      f.block,
+      blockWithPrefix([["", i]], f.block),
+      f
+    );
+  }
+  const blocks = [b];
+  if (c) {
+    blocks.push(c.block);
+  }
+  return {
+    type: "TryStatement",
+    blocks,
+    children: [t, b, c, f],
+    hoistDec
+  };
+}
 function processCallMemberExpression(node) {
   const { children } = node;
   if (Array.isArray(children) && children.length >= 2 && typeof children[0] === "object" && children[0] != null && "parenthesizedOp" in children[0] && typeof children[0].parenthesizedOp === "object" && children[0].parenthesizedOp != null && "token" in children[0].parenthesizedOp && typeof children[1] === "object" && children[1] != null && "type" in children[1] && children[1].type === "Call") {
@@ -5504,25 +5625,29 @@ function processStatementExpressions(statements) {
 }
 function processNegativeIndexAccess(statements) {
   gatherRecursiveAll(statements, (n) => n.type === "NegativeIndex").forEach((exp) => {
-    const { parent } = exp;
-    const index = parent.children.indexOf(exp);
+    const { children } = exp.parent;
+    let start = 0;
+    while (start < children.length && isWhitespaceOrEmpty(children[start])) {
+      start++;
+    }
+    const index = children.indexOf(exp);
     let ref, subexp;
-    if (index === 1) {
-      const child = parent.children[0];
+    if (index === start + 1) {
+      const child = children[start];
       ref = maybeRef(child);
       if (ref !== child) {
-        subexp = parent.children.splice(0, 1);
+        subexp = children.splice(start, 1);
       }
-    } else if (index > 1) {
+    } else if (index > start + 1) {
       ref = makeRef();
-      subexp = parent.children.splice(0, index);
+      subexp = children.splice(start, index);
     } else {
       throw new Error("Invalid parse tree for negative index access");
     }
     if (subexp) {
       const { hoistDec, refAssignment } = makeRefAssignment(ref, subexp);
       exp.hoistDec = hoistDec;
-      parent.children.unshift(makeLeftHandSideExpression(refAssignment));
+      children.splice(start, 0, makeLeftHandSideExpression(refAssignment));
     }
     return exp.len.children = [
       ref,
@@ -5595,6 +5720,7 @@ function populateRefs(statements) {
 }
 function processPlaceholders(statements) {
   const placeholderMap = /* @__PURE__ */ new Map();
+  const liftedIfs = /* @__PURE__ */ new Set();
   gatherRecursiveAll(statements, ($3) => $3.type === "Placeholder").forEach((_exp) => {
     const exp = _exp;
     let ancestor;
@@ -5615,9 +5741,15 @@ function processPlaceholders(statements) {
       let child;
       ({ ancestor, child } = findAncestor(exp, (ancestor2, child2) => {
         const { type } = ancestor2;
-        return type === "Call" || type === "BlockStatement" || type === "PipelineExpression" || // Declaration
+        if (type === "IfStatement") {
+          liftedIfs.add(ancestor2);
+        }
+        let m;
+        let m1;
+        return type === "Call" || // Block, except for if/else blocks when condition already lifted
+        type === "BlockStatement" && !((m = ancestor2.parent, typeof m === "object" && m != null && "type" in m && m.type === "IfStatement") && liftedIfs.has(ancestor2.parent)) && !((m1 = ancestor2.parent, typeof m1 === "object" && m1 != null && "type" in m1 && m1.type === "ElseClause" && "parent" in m1 && typeof m1.parent === "object" && m1.parent != null && "type" in m1.parent && m1.parent.type === "IfStatement") && liftedIfs.has(ancestor2.parent.parent)) || type === "PipelineExpression" || // Declaration
         type === "Initializer" || // Right-hand side of assignment
-        type === "AssignmentExpression" && ancestor2.expression === child2 || type === "ReturnStatement" || type === "YieldExpression";
+        type === "AssignmentExpression" && findChildIndex(ancestor2, child2) === ancestor2.children.indexOf(ancestor2.expression) || type === "ReturnStatement" || type === "YieldExpression";
       }));
       switch (ancestor?.type) {
         case "Call": {
@@ -5985,7 +6117,7 @@ var grammar = {
   PrimaryExpression,
   ParenthesizedExpression,
   Placeholder,
-  AmpersandTypeSuffix,
+  PlaceholderTypeSuffix,
   ClassDeclaration,
   ClassExpression,
   ClassBinding,
@@ -6191,7 +6323,6 @@ var grammar = {
   IfStatement,
   ElseClause,
   IfClause,
-  UnlessClause,
   IterationStatement,
   _IterationStatement,
   IterationExpression,
@@ -6882,7 +7013,7 @@ var $R2 = (0, import_lib3.$R)(new RegExp("(as|of|satisfies|then|when|implements|
 var $R3 = (0, import_lib3.$R)(new RegExp("[0-9]", "suy"));
 var $R4 = (0, import_lib3.$R)(new RegExp("(?!\\p{ID_Start}|[_$0-9(\\[{])", "suy"));
 var $R5 = (0, import_lib3.$R)(new RegExp("[ \\t]", "suy"));
-var $R6 = (0, import_lib3.$R)(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$.])", "suy"));
+var $R6 = (0, import_lib3.$R)(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$.#])", "suy"));
 var $R7 = (0, import_lib3.$R)(new RegExp("[&=]", "suy"));
 var $R8 = (0, import_lib3.$R)(new RegExp("(?=['\"`])", "suy"));
 var $R9 = (0, import_lib3.$R)(new RegExp("(?=[\\/?])", "suy"));
@@ -7856,15 +7987,17 @@ var ParenthesizedExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(OpenPar
 function ParenthesizedExpression(ctx, state2) {
   return (0, import_lib3.$EVENT)(ctx, state2, "ParenthesizedExpression", ParenthesizedExpression$0);
 }
-var Placeholder$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Dot, (0, import_lib3.$N)((0, import_lib3.$EXPECT)($R6, "Placeholder /(?:\\p{ID_Continue}|[\\u200C\\u200D$.])/"))), function($skip, $loc, $0, $1, $2) {
+var Placeholder$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Dot, (0, import_lib3.$N)((0, import_lib3.$EXPECT)($R6, "Placeholder /(?:\\p{ID_Continue}|[\\u200C\\u200D$.#])/")), (0, import_lib3.$E)(PlaceholderTypeSuffix)), function($skip, $loc, $0, $1, $2, $3) {
   var dot = $1;
+  var typeSuffix = $3;
   return {
     type: "Placeholder",
     subtype: ".",
+    typeSuffix,
     children: [dot]
   };
 });
-var Placeholder$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(Ampersand, (0, import_lib3.$N)((0, import_lib3.$EXPECT)($R7, "Placeholder /[&=]/")), (0, import_lib3.$E)(AmpersandTypeSuffix)), function($skip, $loc, $0, $1, $2, $3) {
+var Placeholder$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(Ampersand, (0, import_lib3.$N)((0, import_lib3.$EXPECT)($R7, "Placeholder /[&=]/")), (0, import_lib3.$E)(PlaceholderTypeSuffix)), function($skip, $loc, $0, $1, $2, $3) {
   var amp = $1;
   var typeSuffix = $3;
   return {
@@ -7885,11 +8018,11 @@ var Placeholder$$ = [Placeholder$0, Placeholder$1, Placeholder$2];
 function Placeholder(ctx, state2) {
   return (0, import_lib3.$EVENT_C)(ctx, state2, "Placeholder", Placeholder$$);
 }
-var AmpersandTypeSuffix$0 = (0, import_lib3.$T)((0, import_lib3.$S)((0, import_lib3.$Y)((0, import_lib3.$S)((0, import_lib3.$E)(_), (0, import_lib3.$E)(QuestionMark), (0, import_lib3.$E)(_), Colon)), TypeSuffix), function(value) {
+var PlaceholderTypeSuffix$0 = (0, import_lib3.$T)((0, import_lib3.$S)((0, import_lib3.$Y)((0, import_lib3.$S)((0, import_lib3.$E)(QuestionMark), Colon)), TypeSuffix), function(value) {
   return value[1];
 });
-function AmpersandTypeSuffix(ctx, state2) {
-  return (0, import_lib3.$EVENT)(ctx, state2, "AmpersandTypeSuffix", AmpersandTypeSuffix$0);
+function PlaceholderTypeSuffix(ctx, state2) {
+  return (0, import_lib3.$EVENT)(ctx, state2, "PlaceholderTypeSuffix", PlaceholderTypeSuffix$0);
 }
 var ClassDeclaration$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(ClassExpression), function($skip, $loc, $0, $1) {
   if ($1.id)
@@ -8103,7 +8236,8 @@ var ClassElement$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(Static, BracedBloc
     children: $0
   };
 });
-var ClassElement$$ = [ClassElement$0, ClassElement$1];
+var ClassElement$2 = EmptyStatement;
+var ClassElement$$ = [ClassElement$0, ClassElement$1, ClassElement$2];
 function ClassElement(ctx, state2) {
   return (0, import_lib3.$EVENT_C)(ctx, state2, "ClassElement", ClassElement$$);
 }
@@ -10687,18 +10821,7 @@ var ComputedPropertyName$2 = (0, import_lib3.$TS)((0, import_lib3.$S)(InsertOpen
     implicit: true
   };
 });
-var ComputedPropertyName$3 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$Y)((0, import_lib3.$EXPECT)($L7, 'ComputedPropertyName "."')), InsertOpenBracket, Placeholder, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
-  var open = $2;
-  var expression = $3;
-  var close = $4;
-  return {
-    type: "ComputedPropertyName",
-    expression,
-    children: [open, expression, close],
-    implicit: true
-  };
-});
-var ComputedPropertyName$$ = [ComputedPropertyName$0, ComputedPropertyName$1, ComputedPropertyName$2, ComputedPropertyName$3];
+var ComputedPropertyName$$ = [ComputedPropertyName$0, ComputedPropertyName$1, ComputedPropertyName$2];
 function ComputedPropertyName(ctx, state2) {
   return (0, import_lib3.$EVENT_C)(ctx, state2, "ComputedPropertyName", ComputedPropertyName$$);
 }
@@ -11490,9 +11613,8 @@ function PostfixStatement(ctx, state2) {
 var _PostfixStatement$0 = ForClause;
 var _PostfixStatement$1 = IfClause;
 var _PostfixStatement$2 = LoopClause;
-var _PostfixStatement$3 = UnlessClause;
-var _PostfixStatement$4 = WhileClause;
-var _PostfixStatement$$ = [_PostfixStatement$0, _PostfixStatement$1, _PostfixStatement$2, _PostfixStatement$3, _PostfixStatement$4];
+var _PostfixStatement$3 = WhileClause;
+var _PostfixStatement$$ = [_PostfixStatement$0, _PostfixStatement$1, _PostfixStatement$2, _PostfixStatement$3];
 function _PostfixStatement(ctx, state2) {
   return (0, import_lib3.$EVENT_C)(ctx, state2, "_PostfixStatement", _PostfixStatement$$);
 }
@@ -11572,7 +11694,7 @@ var LabelledItem$$ = [LabelledItem$0, LabelledItem$1];
 function LabelledItem(ctx, state2) {
   return (0, import_lib3.$EVENT_C)(ctx, state2, "LabelledItem", LabelledItem$$);
 }
-var IfStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)(IfClause, UnlessClause), BlockOrEmpty, (0, import_lib3.$E)(ElseClause)), function($skip, $loc, $0, $1, $2, $3) {
+var IfStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(IfClause, BlockOrEmpty, (0, import_lib3.$E)(ElseClause)), function($skip, $loc, $0, $1, $2, $3) {
   var clause = $1;
   var block = $2;
   var e = $3;
@@ -11580,6 +11702,7 @@ var IfStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)
     type: "IfStatement",
     children: [...clause.children, block, e],
     condition: clause.condition,
+    negated: clause.negated,
     then: block,
     else: e
   };
@@ -11594,33 +11717,24 @@ var ElseClause$0 = (0, import_lib3.$T)((0, import_lib3.$S)((0, import_lib3.$C)(N
 function ElseClause(ctx, state2) {
   return (0, import_lib3.$EVENT)(ctx, state2, "ElseClause", ElseClause$0);
 }
-var IfClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(If, Condition), function($skip, $loc, $0, $1, $2) {
-  var condition = $2;
+var IfClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)(If, Unless), (0, import_lib3.$E)(_), Condition), function($skip, $loc, $0, $1, $2, $3) {
+  var kind = $1;
+  var ws = $2;
+  var condition = $3;
+  if (kind.negated) {
+    kind = { ...kind, token: "if" };
+    condition = negateCondition(condition);
+  }
   return {
     type: "IfStatement",
-    children: $0,
-    condition
+    children: [kind, ws, condition],
+    condition,
+    negated: kind.negated
   };
 });
 function IfClause(ctx, state2) {
   return (0, import_lib3.$EVENT)(ctx, state2, "IfClause", IfClause$0);
 }
-var UnlessClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Unless, Condition), function($skip, $loc, $0, $1, $2) {
-  var kind = $1;
-  var condition = $2;
-  kind = { ...kind, token: "if" };
-  kind.token += getTrimmingSpace(condition);
-  condition = insertTrimmingSpace(condition, "");
-  condition = negateCondition(condition);
-  return {
-    type: "IfStatement",
-    children: [kind, condition],
-    condition
-  };
-});
-function UnlessClause(ctx, state2) {
-  return (0, import_lib3.$EVENT)(ctx, state2, "UnlessClause", UnlessClause$0);
-}
 var IterationStatement$0 = (0, import_lib3.$T)((0, import_lib3.$S)((0, import_lib3.$EXPECT)($R25, "IterationStatement /(?=loop|comptime|do|for|until|while)/"), _IterationStatement), function(value) {
   return value[1];
 });
@@ -11750,7 +11864,7 @@ var WhileClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)
   var kind = $1;
   var ws = $2;
   var condition = $3;
-  if (kind.token === "until") {
+  if (kind.negated) {
     kind = { ...kind, token: "while" };
     condition = negateCondition(condition);
   }
@@ -11758,7 +11872,8 @@ var WhileClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)
     type: "IterationStatement",
     subtype: kind.token,
     children: [kind, ws, condition],
-    condition
+    condition,
+    negated: kind.negated
   };
 });
 function WhileClause(ctx, state2) {
@@ -12233,32 +12348,8 @@ var IgnoreColon$0 = (0, import_lib3.$TV)((0, import_lib3.$E)((0, import_lib3.$S)
 function IgnoreColon(ctx, state2) {
   return (0, import_lib3.$EVENT)(ctx, state2, "IgnoreColon", IgnoreColon$0);
 }
-var TryStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Try, (0, import_lib3.$N)((0, import_lib3.$EXPECT)($L15, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, (0, import_lib3.$E)(CatchClause), (0, import_lib3.$E)(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-  var t = $1;
-  var b = $3;
-  var c = $4;
-  var f = $5;
-  if (!c && !f) {
-    const emptyCatchBlock = makeEmptyBlock();
-    c = {
-      type: "CatchClause",
-      children: [" catch(e) ", emptyCatchBlock],
-      block: emptyCatchBlock
-    };
-    return {
-      type: "TryStatement",
-      blocks: [b, emptyCatchBlock],
-      children: [t, b, c]
-    };
-  }
-  const blocks = [b];
-  if (c)
-    blocks.push(c.block);
-  return {
-    type: "TryStatement",
-    blocks,
-    children: [t, b, c, f]
-  };
+var TryStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Try, (0, import_lib3.$N)((0, import_lib3.$EXPECT)($L15, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, (0, import_lib3.$E)(CatchClause), (0, import_lib3.$E)(ElseClause), (0, import_lib3.$E)(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+  return processTryBlock($0);
 });
 function TryStatement(ctx, state2) {
   return (0, import_lib3.$EVENT)(ctx, state2, "TryStatement", TryStatement$0);
@@ -12280,7 +12371,14 @@ var CatchBind$$ = [CatchBind$0, CatchBind$1];
 function CatchBind(ctx, state2) {
   return (0, import_lib3.$EVENT_C)(ctx, state2, "CatchBind", CatchBind$$);
 }
-var FinallyClause$0 = (0, import_lib3.$S)((0, import_lib3.$C)(Nested, _), Finally, (0, import_lib3.$C)(BracedThenClause, BracedOrEmptyBlock));
+var FinallyClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)(Nested, _), Finally, (0, import_lib3.$C)(BracedThenClause, BracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3) {
+  var block = $3;
+  return {
+    type: "FinallyClause",
+    children: $0,
+    block
+  };
+});
 function FinallyClause(ctx, state2) {
   return (0, import_lib3.$EVENT)(ctx, state2, "FinallyClause", FinallyClause$0);
 }
@@ -12337,7 +12435,8 @@ var DeclarationCondition$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(ForbidBrac
     return $skip;
   return {
     type: "DeclarationCondition",
-    declaration
+    declaration,
+    children: [declaration]
   };
 });
 function DeclarationCondition(ctx, state2) {
@@ -14137,7 +14236,7 @@ function Unless(ctx, state2) {
   return (0, import_lib3.$EVENT)(ctx, state2, "Unless", Unless$0);
 }
 var Until$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$EXPECT)($L205, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-  return { $loc, token: $1 };
+  return { $loc, token: $1, negated: true };
 });
 function Until(ctx, state2) {
   return (0, import_lib3.$EVENT)(ctx, state2, "Until", Until$0);