@danielx/civet 0.7.7 → 0.7.8

package/dist/browser.js

@@ -38,9 +38,9 @@ var Civet = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // ../Hera/dist/machine.js
+  // node_modules/.pnpm/@danielx+hera@0.8.13/node_modules/@danielx/hera/dist/machine.js
   var require_machine = __commonJS({
-    "../Hera/dist/machine.js"(exports, module) {
+    "node_modules/.pnpm/@danielx+hera@0.8.13/node_modules/@danielx/hera/dist/machine.js"(exports, module) {
       "use strict";
       var __defProp2 = Object.defineProperty;
       var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -557,6 +557,7 @@ ${input.slice(result.pos)}
     processForInOf: () => processForInOf,
     processProgram: () => processProgram,
     processProgramAsync: () => processProgramAsync,
+    processTryBlock: () => processTryBlock,
     processUnaryExpression: () => processUnaryExpression,
     quoteString: () => quoteString,
     reorderBindingRestProperty: () => reorderBindingRestProperty,
@@ -1578,7 +1579,6 @@ ${input.slice(result.pos)}
     if (!(node != null)) {
       return false;
     }
-    let ref2;
     switch (node.type) {
       case "ReturnStatement":
       case "ThrowStatement":
@@ -1590,13 +1590,10 @@ ${input.slice(result.pos)}
         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;
@@ -1897,8 +1894,8 @@ ${input.slice(result.pos)}
       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);
       }
     }
@@ -2970,6 +2967,10 @@ ${input.slice(result.pos)}
     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);
@@ -3218,7 +3219,7 @@ ${input.slice(result.pos)}
       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;
@@ -3235,40 +3236,99 @@ ${input.slice(result.pos)}
         }
       });
       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;
         }
@@ -3291,7 +3351,7 @@ ${input.slice(result.pos)}
           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([["", [{
@@ -3321,20 +3381,20 @@ ${input.slice(result.pos)}
     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,
@@ -4785,6 +4845,67 @@ ${js}`
     }
     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") {
@@ -5526,25 +5647,29 @@ ${js}`
   }
   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,
@@ -5617,6 +5742,7 @@ ${js}`
   }
   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;
@@ -5637,9 +5763,15 @@ ${js}`
         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": {
@@ -6007,7 +6139,7 @@ ${js}`
     PrimaryExpression,
     ParenthesizedExpression,
     Placeholder,
-    AmpersandTypeSuffix,
+    PlaceholderTypeSuffix,
     ClassDeclaration,
     ClassExpression,
     ClassBinding,
@@ -6213,7 +6345,6 @@ ${js}`
     IfStatement,
     ElseClause,
     IfClause,
-    UnlessClause,
     IterationStatement,
     _IterationStatement,
     IterationExpression,
@@ -7878,15 +8009,17 @@ ${js}`
   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 {
@@ -7907,11 +8040,11 @@ ${js}`
   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)
@@ -8125,7 +8258,8 @@ ${js}`
       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$$);
   }
@@ -10709,18 +10843,7 @@ ${js}`
       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$$);
   }
@@ -11512,9 +11635,8 @@ ${js}`
   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$$);
   }
@@ -11594,7 +11716,7 @@ ${js}`
   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;
@@ -11602,6 +11724,7 @@ ${js}`
       type: "IfStatement",
       children: [...clause.children, block, e],
       condition: clause.condition,
+      negated: clause.negated,
       then: block,
       else: e
     };
@@ -11616,33 +11739,24 @@ ${js}`
   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];
   });
@@ -11772,7 +11886,7 @@ ${js}`
     var kind = $1;
     var ws = $2;
     var condition = $3;
-    if (kind.token === "until") {
+    if (kind.negated) {
       kind = { ...kind, token: "while" };
       condition = negateCondition(condition);
     }
@@ -11780,7 +11894,8 @@ ${js}`
       type: "IterationStatement",
       subtype: kind.token,
       children: [kind, ws, condition],
-      condition
+      condition,
+      negated: kind.negated
     };
   });
   function WhileClause(ctx, state2) {
@@ -12255,32 +12370,8 @@ ${js}`
   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);
@@ -12302,7 +12393,14 @@ ${js}`
   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);
   }
@@ -12359,7 +12457,8 @@ ${js}`
       return $skip;
     return {
       type: "DeclarationCondition",
-      declaration
+      declaration,
+      children: [declaration]
     };
   });
   function DeclarationCondition(ctx, state2) {
@@ -14159,7 +14258,7 @@ ${js}`
     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);