@danielx/civet 0.7.0 → 0.7.1

package/dist/browser.js

@@ -41,1061 +41,629 @@ var Civet = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // source/parser/op.civet
-  function getPrecedence(op) {
-    if (typeof op === "string") {
-      return precedenceMap.get(op) ?? (() => {
-        throw new Error(`Unknown operator: ${op}`);
-      })();
-    } else if (typeof op.prec === "number") {
-      return op.prec;
-    } else {
-      return precedenceMap.get(op.prec ?? op.token) ?? (op.relational ? precedenceRelational : precedenceCustomDefault);
-    }
-  }
-  function processBinaryOpExpression($0) {
-    return recurse(expandChainedComparisons($0));
-    function recurse(expandedOps) {
-      let i = 2;
-      while (i < expandedOps.length) {
-        let op = expandedOps[i];
-        if (op.special) {
-          let advanceLeft2 = function(allowEqual) {
-            while (start >= 4) {
-              const prevPrec = getPrecedence(expandedOps[start - 2]);
-              if (!(prevPrec > prec || allowEqual && prevPrec === prec)) {
-                return prevPrec === prec;
-              }
-              start -= 4;
-            }
-            return false;
-          }, advanceRight2 = function(allowEqual) {
-            while (end + 4 < expandedOps.length) {
-              const nextPrec = getPrecedence(expandedOps[end + 2]);
-              if (!(nextPrec > prec || allowEqual && nextPrec === prec)) {
-                return nextPrec === prec;
-              }
-              end += 4;
-            }
-            return false;
-          };
-          var advanceLeft = advanceLeft2, advanceRight = advanceRight2;
-          let start = i - 2, end = i + 2;
-          const prec = getPrecedence(op);
-          let error;
-          switch (op.assoc) {
-            case "left":
-            case void 0: {
-              advanceLeft2(true);
-              advanceRight2(false);
-              break;
-            }
-            case "right": {
-              advanceLeft2(false);
-              advanceRight2(true);
-              break;
-            }
-            case "non": {
-              if (advanceLeft2(false) || advanceRight2(false)) {
-                error = {
-                  type: "Error",
-                  message: `non-associative operator ${op.token} used at same precedence level without parenthesization`
-                };
-              }
-              ;
-              break;
-            }
-            case "arguments": {
-              if (advanceLeft2(false)) {
-                error = {
-                  type: "Error",
-                  message: `arguments operator ${op.token} used at same precedence level as ${expandedOps[start - 2].token} to the left`
-                };
-              }
-              advanceRight2(true);
-              break;
-            }
-            default: {
-              throw new Error(`Unsupported associativity: ${op.assoc}`);
-            }
-          }
-          let a = start === i - 2 ? expandedOps[start] : expandedOps.slice(start, i - 1);
-          let wsOp = expandedOps[i - 1];
-          let wsB = expandedOps[i + 1];
-          let b = end === i + 2 ? expandedOps[i + 2] : expandedOps.slice(i + 2, end + 1);
-          if (op.assoc === "arguments") {
-            let i2 = 2;
-            while (i2 < b.length) {
-              if (prec === getPrecedence(b[i2])) {
-                if (!(b[i2].token === op.token)) {
-                  error ??= {
-                    type: "Error",
-                    message: `arguments operator ${op.token} used at same precedence level as ${b[i2].token} to the right`
-                  };
-                }
-                b[i2] = ",";
-              }
-              i2 += 4;
-            }
-          } else {
-            b = recurse(b);
-          }
-          if (op.token === "instanceof" && b.type === "Literal" && b.children?.[0]?.type === "StringLiteral") {
-            a = ["typeof ", makeLeftHandSideExpression(a)];
-            if (op.negated) {
-              op = { ...op, token: "!==", negated: false };
-            } else {
-              op = { ...op, token: "===" };
-            }
-          }
-          if (op.asConst) {
-            a = makeAsConst(a);
-            b = makeAsConst(b);
-          }
-          let children;
-          if (op.call) {
-            wsOp = insertTrimmingSpace(wsOp, "");
-            if (op.reversed) {
-              wsB = insertTrimmingSpace(wsB, "");
-              children = [wsOp, op.call, "(", wsB, b, ", ", a, ")", op.suffix];
-            } else {
-              children = [wsOp, op.call, "(", a, ",", wsB, b, ")", op.suffix];
-            }
-          } else if (op.method) {
-            wsOp = insertTrimmingSpace(wsOp, "");
-            wsB = insertTrimmingSpace(wsB, "");
-            if (op.reversed) {
-              if (end !== i + 2)
-                b = makeLeftHandSideExpression(b);
-              b = dotNumericLiteral(b);
-              children = [wsB, b, wsOp, ".", op.method, "(", a, ")"];
-            } else {
-              if (start !== i - 2 || a.type === "NumericLiteral") {
-                a = makeLeftHandSideExpression(a);
-              }
-              a = dotNumericLiteral(a);
-              children = [a, wsOp, ".", op.method, "(", wsB, b, ")"];
-            }
-          } else if (op.token) {
-            children = [a, wsOp, op, wsB, b];
-            if (op.negated)
-              children = ["(", ...children, ")"];
-          } else {
-            throw new Error("Unknown operator: " + JSON.stringify(op));
-          }
-          if (op.negated)
-            children.unshift("!");
-          if (error != null) {
-            children.push(error);
-          }
-          expandedOps.splice(start, end - start + 1, {
-            children
-          });
-          i = start + 2;
-        } else {
-          i += 4;
-        }
-      }
-      return expandedOps;
-    }
-    ;
-    return recurse;
-  }
-  function dotNumericLiteral(literal) {
-    if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
-      literal.children.push(".");
-      literal.raw += ".";
-    }
-    return literal;
-  }
-  function makeAsConst(node) {
-    if (Array.isArray(node) && node.length === 1) {
-      node = node[0];
-    }
-    if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
-      return { ...node, children: [...node.children, asConst] };
-    } else {
-      return node;
-    }
-  }
-  function isExistence(exp) {
-    if (exp?.type === "ParenthesizedExpression" && exp.implicit) {
-      exp = exp.expression;
-    }
-    if (exp?.type === "Existence") {
-      return exp;
-    }
-    ;
-    return;
-  }
-  function isRelationalOp(op) {
-    return op.relational || getPrecedence(op) === precedenceRelational;
-  }
-  function expandChainedComparisons([first, binops]) {
-    if (!binops.length) {
-      return [first];
-    }
-    const results = [];
-    let start = 0;
-    const chains = [];
-    var i = 0;
-    for (let i3 = 0, len2 = binops.length; i3 < len2; i3++) {
-      var i = i3;
-      var [, op] = binops[i3];
-      if (isRelationalOp(op)) {
-        chains.push(i);
-      } else if (getPrecedence(op) < precedenceRelational) {
-        processChains();
-        first = results.pop();
-      }
-    }
-    processChains();
-    return results;
-    function processChains() {
-      if (chains.length > 0) {
-        first = expandExistence(first);
-        for (let i4 = 0, len3 = chains.length; i4 < len3; i4++) {
-          const k = i4;
-          const index = chains[i4];
-          if (k > 0) {
-            results.push(" ", "&&", " ");
-          }
-          const binop = binops[index];
-          const exp = binop[3] = expandExistence(binop[3]);
-          results.push(first);
-          const endIndex = chains[k + 1] ?? i + 1;
-          results.push(...binops.slice(start, endIndex).flat());
-          first = [exp].concat(binops.slice(index + 1, endIndex));
-          start = endIndex;
-        }
-      } else {
-        results.push(first);
-        results.push(...binops.slice(start, i + 1).flat());
-        start = i + 1;
-      }
-      chains.length = 0;
-    }
-    function expandExistence(exp) {
-      let ref;
-      if (ref = isExistence(exp)) {
-        const existence = ref;
-        results.push(existence, " ", "&&", " ");
-        return existence.expression;
-      } else {
-        return exp;
-      }
-    }
-    ;
-  }
-  var precedenceOrder, precedenceMap, precedenceStep, precedenceRelational, precedenceCustomDefault, asConst;
-  var init_op = __esm({
-    "source/parser/op.civet"() {
-      "use strict";
-      init_util();
-      precedenceOrder = [
-        ["||", "??"],
-        ["^^"],
-        ["&&"],
-        ["|"],
-        ["^"],
-        ["&"],
-        // NOTE: Equality and inequality merged because of relational chaining
-        [
-          "==",
-          "!=",
-          "===",
-          "!==",
-          "<",
-          "<=",
-          ">",
-          ">=",
-          "in",
-          "instanceof"
-        ],
-        // NOTE: Extra in-between level for default custom operators
-        ["custom"],
-        ["<<", ">>", ">>>"],
-        ["+", "-"],
-        ["*", "/", "%"],
-        ["**"]
-      ];
-      precedenceMap = /* @__PURE__ */ new Map();
-      for (let i1 = 0, len = precedenceOrder.length; i1 < len; i1++) {
-        const prec = i1;
-        const ops = precedenceOrder[i1];
-        for (let i2 = 0, len1 = ops.length; i2 < len1; i2++) {
-          const op = ops[i2];
-          precedenceMap.set(op, prec);
-        }
-      }
-      precedenceStep = 1 / 64;
-      precedenceRelational = precedenceMap.get("==");
-      precedenceCustomDefault = precedenceMap.get("custom");
-      asConst = {
-        ts: true,
-        children: [" as const"]
-      };
-    }
-  });
-
-  // source/parser/unary.civet
-  function processUnaryExpression(pre, exp, post) {
-    if (!(pre.length || post))
-      return exp;
-    if (post?.token === "?") {
-      post = {
-        $loc: post.$loc,
-        token: " != null"
-      };
-      if (pre.length) {
-        const lastPre = pre.at(-1);
-        if (lastPre.token === "!") {
-          post.token = " == null";
-          pre = pre.slice(0, -1);
-        } else if (lastPre.length === 2 && lastPre[0].token === "!") {
-          post.token = " == null";
-          pre = pre.slice(0, -1);
-        }
-      }
-      const existence = {
-        type: "Existence",
-        expression: exp,
-        children: [exp, post],
-        parent: void 0
-      };
-      exp = makeLeftHandSideExpression(existence);
-      if (pre.length) {
-        return {
-          type: "UnaryExpression",
-          children: [...pre, exp]
-        };
-      }
-      return exp;
-    }
-    if (exp.type === "Literal") {
-      if (pre.length === 1) {
-        const { token } = pre[0];
-        if (token === "-" || token === "+") {
-          const children = [pre[0], ...exp.children];
-          const literal = {
-            type: "Literal",
-            children,
-            raw: `${token}${exp.raw}`
-          };
-          if (post) {
-            return {
-              type: "UnaryExpression",
-              children: [literal, post]
-            };
-          }
-          return literal;
-        }
-      }
-    }
-    let ref;
-    while (ref = pre.length) {
-      const l = ref;
-      const last = pre[l - 1];
-      if (last.type === "Await") {
-        if (last.op) {
-          if (exp.type !== "ParenthesizedExpression") {
-            exp = ["(", exp, ")"];
-          }
-          exp = {
-            type: "CallExpression",
-            children: [...last.children, "Promise", last.op, exp]
-          };
-          pre = pre.slice(0, -1);
-        } else {
-          exp = {
-            type: "AwaitExpression",
-            children: [...last.children, exp]
-          };
-          pre = pre.slice(0, -1);
-        }
-      } else {
-        break;
-      }
-    }
-    return {
-      type: "UnaryExpression",
-      children: [...pre, exp, post]
-    };
-  }
-  var init_unary = __esm({
-    "source/parser/unary.civet"() {
-      "use strict";
-      init_util();
-    }
-  });
-
-  // source/parser/util.civet
-  function addParentPointers(node, parent) {
-    if (node == null)
-      return;
-    if (typeof node !== "object")
-      return;
-    if (Array.isArray(node)) {
-      for (const child of node) {
-        addParentPointers(child, parent);
-      }
-      return;
-    }
-    node = node;
-    node.parent = parent;
-    if (node.children) {
-      for (const child of node.children) {
-        addParentPointers(child, node);
-      }
-    }
-  }
-  function clone(node) {
-    removeParentPointers(node);
-    return deepCopy(node);
-  }
-  function removeParentPointers(node) {
-    if (node == null)
-      return;
-    if (typeof node !== "object")
-      return;
-    if (Array.isArray(node)) {
-      for (const child of node) {
-        removeParentPointers(child);
-      }
-      return;
-    }
-    node.parent = null;
-    if (node.children) {
-      for (const child of node.children) {
-        removeParentPointers(child);
-      }
-    }
-  }
-  function maybeWrap(node, parent) {
-    if (!isASTNodeObject(node)) {
-      updateParentPointers(node = {
-        type: "Wrapper",
-        children: [node],
-        parent
-      });
-    }
-    return node;
-  }
-  function maybeUnwrap(node) {
-    if (node?.type === "Wrapper") {
-      return node.children[0];
-    } else {
-      return node;
-    }
-  }
-  function isASTNodeObject(node) {
-    return typeof node === "object" && node != null && !Array.isArray(node);
-  }
-  function isParent(node) {
-    return node != null && node.children != null;
-  }
-  function isToken(node) {
-    return node != null && node.token != null;
-  }
-  function isEmptyBareBlock(node) {
-    if (node?.type !== "BlockStatement")
-      return false;
-    const { bare, expressions } = node;
-    return bare && (expressions.length === 0 || expressions.length === 1 && expressions[0][1]?.type === "EmptyStatement");
-  }
-  function isFunction(node) {
-    const { type } = node;
-    return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || !!node.async;
-  }
-  function isWhitespaceOrEmpty(node) {
-    if (!node)
-      return true;
-    if (node.type === "Ref")
-      return false;
-    if (node.token)
-      return node.token.match(/^\s*$/);
-    if (node.children)
-      node = node.children;
-    if (!node.length)
-      return true;
-    if (typeof node === "string")
-      return node.match(/^\s*$/);
-    if (Array.isArray(node))
-      return node.every(isWhitespaceOrEmpty);
-    return;
-  }
-  function isExit(node) {
-    if (!(node != null)) {
-      return false;
-    }
-    switch (node.type) {
-      case "ReturnStatement":
-      case "ThrowStatement":
-      case "BreakStatement":
-      case "ContinueStatement": {
-        return true;
-      }
-      case "IfStatement": {
-        return isExit(node.then) && isExit(node.else?.at(-1));
-      }
-      case "BlockStatement": {
-        return isExit(node.expressions.at(-1)?.[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;
+  // source/parser/binding.civet
+  function adjustAtBindings(statements, asThis = false) {
+    gatherRecursiveAll(statements, (n) => n.type === "AtBindingProperty").forEach((binding) => {
+      const { ref } = binding;
+      if (asThis) {
+        const atBinding = binding.binding;
+        atBinding.children.pop();
+        atBinding.type = void 0;
+        binding.children.unshift(ref.id, ": this.", ref.base);
+        binding.type = "Property";
+        binding.ref = void 0;
+        return;
       }
-      default: {
-        return false;
+      if (ref.names[0] !== ref.base) {
+        return binding.children.unshift(ref.base, ": ");
       }
-    }
-  }
-  function isComma(node) {
-    if (node?.token === ",") {
-      return node;
-    } else if (Array.isArray(node) && node.at(-1)?.token === ",") {
-      return node.at(-1);
-    }
-    ;
-    return;
+      ;
+      return;
+    });
   }
-  function insertTrimmingSpace(target, c) {
-    if (!(target != null)) {
-      return target;
-    }
-    if (Array.isArray(target)) {
-      if (target.length === 0) {
-        return c;
+  function adjustBindingElements(elements) {
+    const names = elements.flatMap((p) => p.names || []), { length } = elements;
+    let blockPrefix, restIndex = -1, restCount = 0;
+    elements.forEach(({ type }, i) => {
+      if (type === "BindingRestElement") {
+        if (restIndex < 0)
+          restIndex = i;
+        return restCount++;
       }
-      return target.map((e, i) => {
-        if (i === 0) {
-          return insertTrimmingSpace(e, c);
-        } else {
-          return e;
-        }
-      });
-    } else if (isParent(target)) {
-      return {
-        ...target,
-        children: insertTrimmingSpace(target.children, c)
-      };
-    } else if (isToken(target)) {
+      ;
+      return;
+    });
+    if (restCount === 0) {
       return {
-        ...target,
-        token: target.token.replace(/^ ?/, c)
+        children: elements,
+        names,
+        blockPrefix,
+        length
       };
-    } else {
-      return target;
-    }
-  }
-  function inplaceInsertTrimmingSpace(target, c) {
-    if (!(target != null)) {
-      return target;
-    }
-    if (Array.isArray(target)) {
-      inplaceInsertTrimmingSpace(target[0], c);
-    } else if (isParent(target)) {
-      inplaceInsertTrimmingSpace(target.children, c);
-    } else if (isToken(target)) {
-      target.token = target.token.replace(/^ ?/, c);
-    }
-  }
-  function getTrimmingSpace(target) {
-    if (!(target != null)) {
-      return;
-    }
-    if (Array.isArray(target)) {
-      return getTrimmingSpace(target[0]);
-    } else if (isParent(target)) {
-      return getTrimmingSpace(target.children[0]);
-    } else if (isToken(target)) {
-      return target.token.match(/^ ?/)[0];
-    }
-    ;
-    return;
-  }
-  function prepend(prefix, node) {
-    if (!(prefix && prefix.length)) {
-      return node;
-    }
-    if (Array.isArray(node)) {
-      return [prefix, ...node];
-    } else if (isParent(node)) {
+    } else if (restCount === 1) {
+      const rest = elements[restIndex];
+      const after = elements.slice(restIndex + 1);
+      const restIdentifier = rest.binding.ref || rest.binding;
+      names.push(...rest.names || []);
+      let l = after.length;
+      if (l) {
+        if (arrayElementHasTrailingComma(after[l - 1]))
+          l++;
+        blockPrefix = {
+          type: "PostRestBindingElements",
+          children: ["[", insertTrimmingSpace(after, ""), "] = ", restIdentifier, ".splice(-", l.toString(), ")"],
+          names: after.flatMap((p) => p.names)
+        };
+      }
       return {
-        ...node,
-        children: [prefix, ...node.children]
+        names,
+        children: [...elements.slice(0, restIndex), {
+          ...rest,
+          children: rest.children.slice(0, -1)
+          // remove trailing comma
+        }],
+        blockPrefix,
+        length
       };
-    } else {
-      return [prefix, node];
-    }
-  }
-  function inplacePrepend(prefix, node) {
-    if (!prefix) {
-      return;
-    }
-    if (Array.isArray(prefix) && !prefix.length) {
-      return;
-    }
-    if (Array.isArray(node)) {
-      node.unshift(prefix);
-    } else if (isParent(node)) {
-      node.children.unshift(prefix);
-    } else {
-      throw new Error("Can't prepend to a leaf node");
     }
+    const err = {
+      type: "Error",
+      children: ["Multiple rest elements in array pattern"]
+    };
+    return {
+      names,
+      children: [...elements, err],
+      blockPrefix,
+      length
+    };
   }
-  function literalValue(literal) {
-    let { raw } = literal;
-    switch (raw) {
-      case "null":
-        return null;
-      case "true":
-        return true;
-      case "false":
-        return false;
-    }
-    if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
-      return raw.slice(1, -1);
-    }
-    const numeric = literal.children.find(
-      (child) => child.type === "NumericLiteral"
-    );
-    if (numeric) {
-      raw = raw.replace(/_/g, "");
-      const { token } = numeric;
-      if (token.endsWith("n")) {
-        return BigInt(raw.slice(0, -1));
-      } else if (token.match(/[\.eE]/)) {
-        return parseFloat(raw);
-      } else if (token.startsWith("0")) {
-        switch (token.charAt(1).toLowerCase()) {
-          case "x":
-            return parseInt(raw.replace(/0[xX]/, ""), 16);
-          case "b":
-            return parseInt(raw.replace(/0[bB]/, ""), 2);
-          case "o":
-            return parseInt(raw.replace(/0[oO]/, ""), 8);
+  function gatherBindingCode(statements, opts) {
+    const thisAssignments = [];
+    const splices = [];
+    function insertRestSplices(s, p, thisAssignments2) {
+      gatherRecursiveAll(s, (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding").forEach((n) => {
+        if (n.type === "AtBinding") {
+          const { ref } = n;
+          const { id } = ref;
+          thisAssignments2.push([`this.${id} = `, ref]);
+          return;
         }
-      }
-      return parseInt(raw, 10);
-    }
-    throw new Error("Unrecognized literal " + JSON.stringify(literal));
-  }
-  function startsWith(target, value) {
-    if (!target)
-      return;
-    if (Array.isArray(target)) {
-      let i = 0;
-      let l = target.length;
-      while (i < l) {
-        const t = target[i];
-        if (t && (t.length || t.token || t.children)) {
-          break;
+        if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
+          n.names.forEach((id) => ({
+            push: thisAssignments2.push({
+              type: "AssignmentExpression",
+              children: [`this.${id} = `, id],
+              js: true
+            })
+          }));
+          return;
         }
-        i++;
-      }
-      if (i < l) {
-        return startsWith(target[i], value);
-      }
+        const { blockPrefix } = n;
+        p.push(blockPrefix);
+        return insertRestSplices(blockPrefix, p, thisAssignments2);
+      });
     }
-    if (typeof target === "string")
-      return value.test(target);
-    if (target.children)
-      return startsWith(target.children, value);
-    if (target.token)
-      return value.test(target.token);
-    return;
+    insertRestSplices(statements, splices, thisAssignments);
+    return [splices, thisAssignments];
   }
-  function hasAwait(exp) {
-    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
+  function arrayElementHasTrailingComma(elementNode) {
+    const lastChild = elementNode.children.at(-1);
+    return lastChild && lastChild[lastChild.length - 1]?.token === ",";
   }
-  function hasYield(exp) {
-    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Yield").length > 0;
+  var init_binding = __esm({
+    "source/parser/binding.civet"() {
+      "use strict";
+      init_traversal();
+      init_util();
+    }
+  });
+
+  // source/parser/function.civet
+  function isVoidType(t) {
+    return t?.type === "LiteralType" && t.t.type === "VoidType";
   }
-  function hasImportDeclaration(exp) {
-    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "ImportDeclaration").length > 0;
+  function isPromiseVoidType(t) {
+    return t?.type === "IdentifierType" && t.raw === "Promise" && t.args?.types?.length === 1 && isVoidType(t.args.types[0]);
+  }
+  function isGeneratorVoidType(t) {
+    return t?.type === "IdentifierType" && (t.raw === "Iterator" || t.raw === "Generator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
   }
-  function deepCopy(node) {
-    if (node == null)
-      return node;
-    if (typeof node !== "object")
-      return node;
-    if (Array.isArray(node)) {
-      return node.map(deepCopy);
-    }
-    if (node?.type === "Ref")
-      return node;
-    return Object.fromEntries(
-      Object.entries(node).map(([key, value]) => {
-        return [key, deepCopy(value)];
-      })
-    );
+  function isAsyncGeneratorVoidType(t) {
+    return t?.type === "IdentifierType" && (t.raw === "AsyncIterator" || t.raw === "AsyncGenerator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
   }
-  function removeHoistDecs(node) {
-    if (node == null)
+  function implicitFunctionBlock(f) {
+    if (f.abstract || f.block || f.signature?.optional)
       return;
-    if (typeof node !== "object")
+    const { name, parent } = f;
+    if (parent?.type === "ExportDeclaration")
       return;
-    if ("hoistDec" in node) {
-      node.hoistDec = void 0;
+    const expressions = parent?.expressions ?? parent?.elements;
+    const currentIndex = expressions?.findIndex(([, def]) => def === f);
+    const following = currentIndex >= 0 && expressions[currentIndex + 1]?.[1];
+    if (f.type === following?.type && name && name === following.name) {
+      f.ts = true;
+    } else {
+      const block = makeEmptyBlock();
+      block.parent = f;
+      f.block = block;
+      f.children.push(block);
+      f.ts = false;
     }
-    if (Array.isArray(node)) {
-      for (const child of node) {
-        removeHoistDecs(child);
-      }
-      return;
+  }
+  function processReturn(f, implicitReturns) {
+    let { returnType } = f.signature;
+    if (returnType && returnType.optional) {
+      convertOptionalType(returnType);
     }
-    if (node.children) {
-      for (const child of node.children) {
-        removeHoistDecs(child);
+    if (!processReturnValue(f) && implicitReturns) {
+      const { signature, block } = f;
+      const { modifier, name, returnType: returnType2 } = signature;
+      const { async, generator, set } = modifier;
+      const isMethod = f.type === "MethodDefinition";
+      const isConstructor = isMethod && name === "constructor";
+      const isVoid = isVoidType(returnType2?.t) || async && (isPromiseVoidType(returnType2?.t) || generator && isAsyncGeneratorVoidType(returnType2?.t)) || !async && generator && isGeneratorVoidType(returnType2?.t);
+      if (block?.type === "BlockStatement") {
+        if (isVoid || set || isConstructor) {
+          if (block.bare && block.implicitlyReturned) {
+            braceBlock(block);
+          }
+        } else {
+          if (!block.implicitlyReturned) {
+            insertReturn(block);
+          }
+        }
       }
     }
   }
-  function makeAmpersandFunction(rhs) {
-    let { ref, typeSuffix, body } = rhs;
-    if (!(ref != null)) {
-      ref = makeRef("$");
-      inplacePrepend(ref, body);
-    }
-    if (body?.type === "ObjectExpression") {
-      body = makeLeftHandSideExpression(body);
+  function processReturnValue(func) {
+    const { block } = func;
+    const values = gatherRecursiveWithinFunction(
+      block,
+      ({ type }) => type === "ReturnValue"
+    );
+    if (!values.length) {
+      return false;
     }
-    const parameters = makeNode({
-      type: "Parameters",
-      children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
-      names: []
-    });
-    const expressions = [body];
-    const block = makeNode({
-      bare: true,
-      expressions,
-      children: [expressions]
+    const ref = makeRef("ret");
+    let declaration;
+    values.forEach((value) => {
+      value.children = [ref];
+      const { ancestor, child } = findAncestor(
+        value,
+        ({ type }) => type === "Declaration",
+        isFunction
+      );
+      if (ancestor) {
+        return declaration ??= child;
+      }
+      ;
+      return;
     });
-    const children = [parameters, " => ", block];
-    const async = hasAwait(body);
-    if (async) {
-      children.unshift("async ");
+    let returnType = func.returnType ?? func.signature?.returnType;
+    if (returnType) {
+      const { t } = returnType;
+      let m;
+      if (m = t.type, m === "TypePredicate") {
+        returnType = ": boolean";
+      } else if (m === "AssertsType") {
+        returnType = void 0;
+      }
     }
-    return makeNode({
-      type: "ArrowFunction",
-      signature: {
-        modifier: {
-          async
-        }
-      },
-      children,
-      ref,
-      body,
-      ampersandBlock: true,
+    if (declaration) {
+      if (!(declaration.suffix != null)) {
+        declaration.children[1] = declaration.suffix = returnType;
+      }
+    } else {
+      block.expressions.unshift([
+        getIndent(block.expressions[0]),
+        {
+          type: "Declaration",
+          children: ["let ", ref, returnType],
+          names: []
+        },
+        ";"
+      ]);
+    }
+    gatherRecursiveWithinFunction(
       block,
-      parameters
+      (r) => r.type === "ReturnStatement" && !r.expression
+    ).forEach((r) => {
+      r.expression = ref;
+      return r.children.splice(-1, 1, " ", ref);
     });
-  }
-  function makeLeftHandSideExpression(expression) {
-    if (expression.parenthesized) {
-      return expression;
+    if (!(block.children.at(-2)?.type === "ReturnStatement")) {
+      const indent = getIndent(block.expressions.at(-1)) || ";";
+      block.expressions.push([
+        [indent],
+        {
+          type: "ReturnStatement",
+          expression: ref,
+          children: ["return ", ref]
+        }
+      ]);
     }
-    switch (expression.type) {
-      case "AmpersandRef":
-      case "CallExpression":
+    return true;
+  }
+  function patternAsValue(pattern) {
+    switch (pattern.type) {
+      case "ArrayBindingPattern": {
+        const children = [...pattern.children];
+        const index = children.indexOf(pattern.elements);
+        if (index < 0)
+          throw new Error("failed to find elements in ArrayBindingPattern");
+        children[index] = pattern.elements.map((el) => {
+          const [ws, e, delim] = el.children;
+          return { ...el, children: [ws, patternAsValue(e), delim] };
+        });
+        return { ...pattern, children };
+      }
+      case "ObjectBindingPattern": {
+        const children = [...pattern.children];
+        const index = children.indexOf(pattern.properties);
+        if (index < 0)
+          throw new Error("failed to find properties in ArrayBindingPattern");
+        children[index] = pattern.properties.map(patternAsValue);
+        return { ...pattern, children };
+      }
       case "Identifier":
-      case "JSXElement":
-      case "JSXFragment":
-      case "Literal":
-      case "MemberExpression":
-      case "NewExpression":
-      case "ParenthesizedExpression":
-      case "Ref":
-      case "Placeholder":
-      case "StatementExpression":
-        return expression;
+      case "BindingProperty": {
+        const children = [
+          // { name: value } = ... declares value, not name
+          pattern.value ?? pattern.name,
+          pattern.delim
+        ];
+        if (isWhitespaceOrEmpty(pattern.children[0])) {
+          children.unshift(pattern.children[0]);
+        }
+        return { ...pattern, children };
+      }
+      default:
+        return pattern;
     }
-    return makeNode({
-      type: "ParenthesizedExpression",
-      children: ["(", expression, ")"],
-      expression,
-      implicit: true,
-      parent: void 0
-    });
   }
-  function updateParentPointers(node, parent, depth = 1) {
-    if (!(node != null)) {
+  function assignResults(node, collect) {
+    if (!node)
+      return;
+    switch (node.type) {
+      case "BlockStatement":
+        if (node.expressions.length) {
+          assignResults(node.expressions.at(-1), collect);
+        } else {
+          node.expressions.push(["", collect("void 0"), ";"]);
+        }
+        return;
+      case "CaseBlock":
+        node.clauses.forEach((clause) => {
+          return assignResults(clause, collect);
+        });
+        return;
+      case "WhenClause":
+      case "DefaultClause":
+      case "PatternClause": {
+        assignResults(node.block, collect);
+        return;
+      }
+    }
+    if (!Array.isArray(node)) {
       return;
     }
-    if (!(typeof node === "object")) {
+    let [, exp, semi] = node;
+    if (semi?.type === "SemicolonDelimiter") {
       return;
     }
-    if (Array.isArray(node)) {
-      for (const child of node) {
-        updateParentPointers(child, parent, depth);
-      }
+    if (!exp) {
+      return;
+    }
+    if (isExit(exp)) {
       return;
     }
-    node = node;
-    if (parent != null) {
-      node.parent = parent;
-    }
-    if (depth && isParent(node)) {
-      for (const child of node.children) {
-        updateParentPointers(child, node, depth - 1);
-      }
+    const outer = exp;
+    let { type } = exp;
+    if (type === "LabelledStatement") {
+      exp = exp.statement;
+      ({ type } = exp);
     }
-  }
-  function makeNode(node) {
-    updateParentPointers(node);
-    return node;
-  }
-  function makeRef(base = "ref", id = base) {
-    return {
-      type: "Ref",
-      base,
-      id
-    };
-  }
-  function needsRef(expression, base = "ref") {
-    switch (expression.type) {
-      case "Ref":
-      case "Identifier":
-      case "Literal":
+    switch (exp.type) {
+      case "BreakStatement":
+      case "ContinueStatement":
+      case "DebuggerStatement":
+      case "EmptyStatement":
+      case "ReturnStatement":
+      case "ThrowStatement":
+        return;
+      case "Declaration":
+        exp.children.push([
+          "",
+          [";", collect(patternAsValue(exp.bindings.at(-1).pattern))]
+        ]);
+        return;
+      case "ForStatement":
+      case "IterationStatement":
+      case "DoStatement":
+        wrapIterationReturningResults(exp, outer, collect);
+        return;
+      case "BlockStatement":
+        assignResults(exp.expressions[exp.expressions.length - 1], collect);
+        return;
+      case "IfStatement":
+        assignResults(exp.then, collect);
+        if (exp.then.bare && !exp.then.semicolon) {
+          exp.then.children.push(exp.then.semicolon = ";");
+        }
+        if (exp.else) {
+          assignResults(exp.else[2], collect);
+        } else {
+          exp.children.push([" else {", collect("undefined"), "}"]);
+        }
+        return;
+      case "PatternMatchingStatement":
+        assignResults(exp.children[0][0], collect);
+        return;
+      case "SwitchStatement":
+        assignResults(exp.children[2], collect);
+        return;
+      case "TryStatement":
+        exp.blocks.forEach((block) => assignResults(block, collect));
         return;
     }
-    return makeRef(base);
-  }
-  function maybeRef(exp, base = "ref") {
-    if (!needsRef(exp))
-      return exp;
-    return makeRef(base);
-  }
-  function skipIfOnlyWS(target) {
-    if (!target)
-      return target;
-    if (Array.isArray(target)) {
-      if (target.length === 1) {
-        return skipIfOnlyWS(target[0]);
-      } else if (target.every((e) => skipIfOnlyWS(e) === void 0)) {
-        return void 0;
-      }
-      return target;
-    }
-    if (target.token != null && target.token.trim() === "") {
-      return void 0;
+    if (node.at(-1)?.type === "SemicolonDelimiter") {
+      return;
     }
-    return target;
+    node[1] = collect(node[1]);
   }
-  function spliceChild(node, child, del, ...replacements) {
-    const children = node?.children ?? node;
-    if (!Array.isArray(children)) {
-      throw new Error("spliceChild: non-array node has no children field");
+  function insertReturn(node, outerNode = node) {
+    if (!node)
+      return;
+    switch (node.type) {
+      case "BlockStatement":
+        if (node.expressions.length) {
+          const last = node.expressions[node.expressions.length - 1];
+          insertReturn(last);
+        } else {
+          if (node.parent.type === "CatchClause") {
+            node.expressions.push(["return"]);
+          }
+        }
+        return;
+      case "WhenClause":
+        if (node.break) {
+          node.children.splice(node.children.indexOf(node.break), 1);
+        }
+        if (node.block.expressions.length) {
+          insertReturn(node.block);
+        } else {
+          node.block.expressions.push(wrapWithReturn());
+        }
+        return;
+      case "DefaultClause":
+        insertReturn(node.block);
+        return;
     }
-    const index = children.indexOf(child);
-    if (index < 0) {
-      throw new Error("spliceChild: child not found");
+    if (!Array.isArray(node))
+      return;
+    let [, exp, semi] = node;
+    if (semi?.type === "SemicolonDelimiter") {
+      return;
     }
-    return children.splice(index, del, ...replacements);
-  }
-  function convertOptionalType(suffix) {
-    if (suffix.t.type === "AssertsType") {
-      spliceChild(suffix, suffix.optional, 1, suffix.optional = {
-        type: "Error",
-        message: "Can't use optional ?: syntax with asserts type"
-      });
+    if (!exp) {
       return;
     }
-    spliceChild(suffix, suffix.optional, 1, suffix.optional = void 0);
-    const wrap = suffix.type === "ReturnTypeAnnotation";
-    spliceChild(suffix, suffix.t, 1, suffix.t = [
-      getTrimmingSpace(suffix.t),
-      wrap && "(",
-      // TODO: avoid parens if unnecessary
-      "undefined | ",
-      parenthesizeType(insertTrimmingSpace(suffix.t, "")),
-      wrap && ")"
-    ]);
-  }
-  function parenthesizeType(type) {
-    if (typeNeedsNoParens.has(type.type)) {
-      return type;
+    if (isExit(exp)) {
+      return;
     }
-    return ["(", type, ")"];
-  }
-  function wrapIIFE(expressions, asyncFlag) {
-    let prefix;
-    let async;
-    if (asyncFlag) {
-      async = "async ";
-    } else if (hasAwait(expressions)) {
-      async = "async ";
-      prefix = {
-        type: "Await",
-        children: ["await "]
-      };
+    const outer = exp;
+    let { type } = exp;
+    if (type === "LabelledStatement") {
+      exp = exp.statement;
+      ({ type } = exp);
     }
-    const block = makeNode({
-      type: "BlockStatement",
-      expressions,
-      children: ["{", expressions, "}"],
-      bare: false,
-      root: false,
-      parent: void 0
-    });
-    const parameters = {
-      type: "Parameters",
-      children: ["()"],
-      names: []
-    };
-    const signature = {
-      modifier: {
-        async: !!async
-      },
-      returnType: void 0
-    };
-    const fn = makeNode({
-      type: "ArrowFunction",
-      signature,
-      parameters,
-      returnType: void 0,
-      ts: false,
-      async,
-      block,
-      children: [async, parameters, "=>", block]
-    });
-    const exp = makeNode({
-      type: "CallExpression",
-      children: [makeLeftHandSideExpression(fn), "()"]
-    });
-    if (prefix) {
-      return [makeLeftHandSideExpression([prefix, exp])];
+    switch (type) {
+      case "BreakStatement":
+      case "ContinueStatement":
+      case "DebuggerStatement":
+      case "EmptyStatement":
+      case "ReturnStatement":
+      case "ThrowStatement":
+        return;
+      case "Declaration":
+        exp.children.push(["", {
+          type: "ReturnStatement",
+          children: [";return ", patternAsValue(exp.bindings.at(-1).pattern)],
+          parent: exp
+        }]);
+        return;
+      case "FunctionExpression":
+        if (exp.id) {
+          exp.children.push([
+            "",
+            {
+              type: "ReturnStatement",
+              children: [";return ", exp.id],
+              parent: exp
+            }
+          ]);
+          return;
+        }
+        break;
+      case "ForStatement":
+      case "IterationStatement":
+      case "DoStatement":
+        wrapIterationReturningResults(exp, outer);
+        return;
+      case "BlockStatement":
+        insertReturn(exp.expressions[exp.expressions.length - 1]);
+        return;
+      case "IfStatement":
+        insertReturn(exp.then);
+        if (exp.else && exp.else.length !== 0)
+          insertReturn(exp.else[2]);
+        else
+          exp.children.push(["", {
+            type: "ReturnStatement",
+            // NOTE: add a prefixed semi-colon because the if block may not be braced
+            children: [";return"],
+            parent: exp
+          }]);
+        return;
+      case "PatternMatchingStatement":
+        insertReturn(exp.children[0][0]);
+        return;
+      case "SwitchStatement":
+        insertSwitchReturns(exp);
+        return;
+      case "TryStatement":
+        exp.blocks.forEach((block) => insertReturn(block));
+        return;
     }
-    return [exp];
+    if (node[node.length - 1]?.type === "SemicolonDelimiter")
+      return;
+    const returnStatement = wrapWithReturn(node[1]);
+    node.splice(1, 1, returnStatement);
   }
-  function wrapWithReturn(expression) {
-    const children = expression ? ["return ", expression] : ["return"];
-    return makeNode({
-      type: "ReturnStatement",
-      children,
-      expression,
-      parent: expression?.parent
+  function insertSwitchReturns(exp) {
+    exp.caseBlock.clauses.forEach((clause) => {
+      return insertReturn(clause);
     });
   }
-  var assert, typeNeedsNoParens;
-  var init_util = __esm({
-    "source/parser/util.civet"() {
-      "use strict";
-      init_traversal();
-      init_op();
-      init_unary();
-      assert = {
-        equal(a, b, msg) {
-          if (a !== b) {
-            throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`);
-          }
-        }
-      };
-      typeNeedsNoParens = /* @__PURE__ */ new Set([
-        "IdentifierType",
-        "ImportType",
-        "LiteralType",
-        "TupleType",
-        "ParenthesizedType",
-        "UnaryType"
-      ]);
+  function wrapIterationReturningResults(statement, outer, collect) {
+    if (statement.type === "DoStatement") {
+      if (collect) {
+        assignResults(statement.block, collect);
+      } else {
+        insertReturn(statement.block, outer);
+      }
+      return;
     }
-  });
-
-  // source/parser/traversal.civet
-  function gatherRecursiveWithinFunction(node, predicate) {
-    return gatherRecursive(node, predicate, isFunction);
-  }
-  function findChildIndex(parent, child) {
-    if (!(parent != null)) {
-      return -1;
+    assert.equal(
+      statement.resultsRef,
+      void 0,
+      "wrapIterationReturningResults should not be called twice on the same statement"
+    );
+    const resultsRef = statement.resultsRef = makeRef("results");
+    const declaration = {
+      type: "Declaration",
+      children: ["const ", resultsRef, "=[]"]
+    };
+    outer.children.unshift(["", declaration, ";"]);
+    assignResults(statement.block, (node) => {
+      return [resultsRef, ".push(", node, ")"];
+    });
+    if (collect) {
+      statement.children.push(collect(resultsRef));
+    } else {
+      statement.children.push(";return ", resultsRef, ";");
     }
-    const children = Array.isArray(parent) ? parent : parent.children;
-    if (!(children != null)) {
-      return -1;
+  }
+  function processParams(f) {
+    const { type, parameters, block } = f;
+    const isConstructor = f.name === "constructor";
+    if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
+      parameters.tp.parameters.push(",");
     }
-    for (let i1 = 0, len = children.length; i1 < len; i1++) {
-      const i = i1;
-      const c = children[i1];
-      if (c === child || Array.isArray(c) && arrayRecurse(c)) {
-        return i;
-      }
+    if (!block)
+      return;
+    const { expressions } = block;
+    if (!expressions)
+      return;
+    const { blockPrefix } = parameters;
+    let indent;
+    if (!expressions.length) {
+      indent = "";
+    } else {
+      indent = expressions[0][0];
     }
-    function arrayRecurse(array) {
-      for (let i2 = 0, len1 = array.length; i2 < len1; i2++) {
-        const c = array[i2];
-        if (c === child || Array.isArray(c) && arrayRecurse(c)) {
-          return true;
+    const [splices, thisAssignments] = gatherBindingCode(parameters, {
+      injectParamProps: isConstructor
+    });
+    const delimiter = {
+      type: "SemicolonDelimiter",
+      children: [";"]
+    };
+    const prefix = splices.map((s) => ["let ", s]).concat(thisAssignments).map(
+      (s) => s.type ? {
+        // TODO: figure out how to get JS only statement tuples
+        ...s,
+        children: [indent, ...s.children, delimiter]
+      } : [indent, s, delimiter]
+    );
+    if (!prefix.length)
+      return;
+    if (isConstructor) {
+      const superCalls = gatherNodes(expressions, (exp) => {
+        return exp.type === "CallExpression" && exp.children[0]?.token === "super";
+      });
+      if (superCalls.length) {
+        const { child } = findAncestor(
+          superCalls[0],
+          (ancestor) => ancestor === block
+        );
+        const index = findChildIndex(expressions, child);
+        if (index < 0) {
+          throw new Error("Could not find super call within top-level expressions");
         }
+        expressions.splice(index + 1, 0, ...prefix);
+        return;
       }
-      return false;
-    }
-    return -1;
-  }
-  function findAncestor(node, predicate, stopPredicate) {
-    let { parent } = node;
-    while (parent && !stopPredicate?.(parent, node)) {
-      if (predicate(parent, node)) {
-        return { ancestor: parent, child: node };
-      }
-      node = parent;
-      ({ parent } = node);
     }
-    return { ancestor: void 0, child: node };
+    expressions.unshift(...prefix);
   }
-  function gatherNodes(node, predicate) {
-    if (node == null)
-      return [];
-    if (Array.isArray(node)) {
-      return node.flatMap((n) => gatherNodes(n, predicate));
-    }
-    if (predicate(node)) {
-      return [node];
-    }
-    switch (node.type) {
-      case "BlockStatement":
-        return [];
-      case "ForStatement":
-        const isDec = node.declaration?.type === "Declaration";
-        return node.children.flatMap((n) => {
-          if (isDec && n === node.declaration)
-            return [];
-          return gatherNodes(n, predicate);
-        });
-      default:
-        return gatherNodes(node.children, predicate);
-    }
+  function processFunctions(statements, config) {
+    gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
+      if (f.type === "FunctionExpression")
+        implicitFunctionBlock(f);
+      processParams(f);
+      return processReturn(f, config.implicitReturns);
+    });
+    gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
+      implicitFunctionBlock(f);
+      processParams(f);
+      return processReturn(f, config.implicitReturns);
+    });
   }
-  function gatherRecursive(node, predicate, skipPredicate) {
-    if (node == null)
-      return [];
-    if (Array.isArray(node)) {
-      return node.flatMap((n) => gatherRecursive(n, predicate, skipPredicate));
+  function expressionizeIteration(exp) {
+    const { async, subtype, block, children, statement } = exp;
+    const i = children.indexOf(statement);
+    if (i < 0) {
+      throw new Error("Could not find iteration statement in iteration expression");
     }
-    if (skipPredicate?.(node))
-      return [];
-    if (predicate(node)) {
-      return [node];
+    if (subtype === "DoStatement") {
+      children.splice(i, 1, ...wrapIIFE([["", statement, void 0]], async));
+      updateParentPointers(exp);
+      return;
     }
-    return gatherRecursive(node.children, predicate, skipPredicate);
+    exp.resultsRef ??= makeRef("results");
+    const { resultsRef } = exp;
+    assignResults(block, (node) => {
+      return [resultsRef, ".push(", node, ")"];
+    });
+    braceBlock(block);
+    children.splice(
+      i,
+      1,
+      ...wrapIIFE([
+        ["", ["const ", resultsRef, "=[]"], ";"],
+        ...children.map((c) => ["", c, void 0]),
+        ["", wrapWithReturn(resultsRef)]
+      ], async)
+    );
+    updateParentPointers(exp);
   }
-  function gatherRecursiveAll(node, predicate) {
-    if (node == null)
-      return [];
-    if (Array.isArray(node)) {
-      return node.flatMap((n) => gatherRecursiveAll(n, predicate));
-    }
-    const nodes = gatherRecursiveAll(node.children, predicate);
-    if (predicate(node)) {
-      nodes.push(node);
+  function skipImplicitArguments(args) {
+    if (args.length === 1) {
+      let arg0 = args[0];
+      if (arg0.type === "StatementExpression") {
+        arg0 = arg0.statement;
+      }
+      return arg0.type === "IterationExpression" && arg0.subtype !== "DoStatement" && !arg0.async && isEmptyBareBlock(arg0.block);
     }
-    return nodes;
+    return false;
   }
-  var init_traversal = __esm({
-    "source/parser/traversal.civet"() {
+  var init_function = __esm({
+    "source/parser/function.civet"() {
       "use strict";
+      init_block();
+      init_binding();
+      init_traversal();
       init_util();
     }
   });
@@ -1128,7 +696,13 @@ var Civet = (() => {
       }
       block.children.unshift(" {");
       block.children.push("}");
-      return block.bare = false;
+      const { implicitlyReturned } = block;
+      block.bare = block.implicitlyReturned = false;
+      if (implicitlyReturned) {
+        return processReturn(block.parent, true);
+      }
+      ;
+      return;
     }
     ;
     return;
@@ -1302,1010 +876,1379 @@ var Civet = (() => {
       "use strict";
       init_util();
       init_traversal();
+      init_function();
     }
   });
 
-  // source/parser/binding.civet
-  function adjustAtBindings(statements, asThis = false) {
-    gatherRecursiveAll(statements, (n) => n.type === "AtBindingProperty").forEach((binding) => {
-      const { ref } = binding;
-      if (asThis) {
-        const atBinding = binding.binding;
-        atBinding.children.pop();
-        atBinding.type = void 0;
-        binding.children.unshift(ref.id, ": this.", ref.base);
-        binding.type = "Property";
-        binding.ref = void 0;
-        return;
-      }
-      if (ref.names[0] !== ref.base) {
-        return binding.children.unshift(ref.base, ": ");
+  // source/parser/util.civet
+  function addParentPointers(node, parent) {
+    if (node == null)
+      return;
+    if (typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        addParentPointers(child, parent);
       }
-      ;
       return;
-    });
+    }
+    node = node;
+    node.parent = parent;
+    if (node.children) {
+      for (const child of node.children) {
+        addParentPointers(child, node);
+      }
+    }
   }
-  function adjustBindingElements(elements) {
-    const names = elements.flatMap((p) => p.names || []), { length } = elements;
-    let blockPrefix, restIndex = -1, restCount = 0;
-    elements.forEach(({ type }, i) => {
-      if (type === "BindingRestElement") {
-        if (restIndex < 0)
-          restIndex = i;
-        return restCount++;
+  function clone(node) {
+    removeParentPointers(node);
+    return deepCopy(node);
+  }
+  function removeParentPointers(node) {
+    if (node == null)
+      return;
+    if (typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        removeParentPointers(child);
       }
-      ;
       return;
-    });
-    if (restCount === 0) {
+    }
+    node.parent = null;
+    if (node.children) {
+      for (const child of node.children) {
+        removeParentPointers(child);
+      }
+    }
+  }
+  function maybeWrap(node, parent) {
+    if (!isASTNodeObject(node)) {
+      updateParentPointers(node = {
+        type: "Wrapper",
+        children: [node],
+        parent
+      });
+    }
+    return node;
+  }
+  function maybeUnwrap(node) {
+    if (node?.type === "Wrapper") {
+      return node.children[0];
+    } else {
+      return node;
+    }
+  }
+  function isASTNodeObject(node) {
+    return typeof node === "object" && node != null && !Array.isArray(node);
+  }
+  function isParent(node) {
+    return node != null && node.children != null;
+  }
+  function isToken(node) {
+    return node != null && node.token != null;
+  }
+  function isEmptyBareBlock(node) {
+    if (node?.type !== "BlockStatement")
+      return false;
+    const { bare, expressions } = node;
+    return bare && (expressions.length === 0 || expressions.length === 1 && expressions[0][1]?.type === "EmptyStatement");
+  }
+  function isFunction(node) {
+    const { type } = node;
+    return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || !!node.async;
+  }
+  function isStatement(node) {
+    return isASTNodeObject(node) && node.type != null && // forbid leaf
+    statementTypes.has(node.type);
+  }
+  function isWhitespaceOrEmpty(node) {
+    if (!node)
+      return true;
+    if (node.type === "Ref")
+      return false;
+    if (node.token)
+      return node.token.match(/^\s*$/);
+    if (node.children)
+      node = node.children;
+    if (!node.length)
+      return true;
+    if (typeof node === "string")
+      return node.match(/^\s*$/);
+    if (Array.isArray(node))
+      return node.every(isWhitespaceOrEmpty);
+    return;
+  }
+  function isExit(node) {
+    if (!(node != null)) {
+      return false;
+    }
+    switch (node.type) {
+      case "ReturnStatement":
+      case "ThrowStatement":
+      case "BreakStatement":
+      case "ContinueStatement": {
+        return true;
+      }
+      case "IfStatement": {
+        return isExit(node.then) && isExit(node.else?.at(-1));
+      }
+      case "BlockStatement": {
+        return isExit(node.expressions.at(-1)?.[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;
+      }
+      default: {
+        return false;
+      }
+    }
+  }
+  function isComma(node) {
+    if (node?.token === ",") {
+      return node;
+    } else if (Array.isArray(node) && node.at(-1)?.token === ",") {
+      return node.at(-1);
+    }
+    ;
+    return;
+  }
+  function insertTrimmingSpace(target, c) {
+    if (!(target != null)) {
+      return target;
+    }
+    if (Array.isArray(target)) {
+      if (target.length === 0) {
+        return c;
+      }
+      return target.map((e, i) => {
+        if (i === 0) {
+          return insertTrimmingSpace(e, c);
+        } else {
+          return e;
+        }
+      });
+    } else if (isParent(target)) {
       return {
-        children: elements,
-        names,
-        blockPrefix,
-        length
+        ...target,
+        children: insertTrimmingSpace(target.children, c)
       };
-    } else if (restCount === 1) {
-      const rest = elements[restIndex];
-      const after = elements.slice(restIndex + 1);
-      const restIdentifier = rest.binding.ref || rest.binding;
-      names.push(...rest.names || []);
-      let l = after.length;
-      if (l) {
-        if (arrayElementHasTrailingComma(after[l - 1]))
-          l++;
-        blockPrefix = {
-          type: "PostRestBindingElements",
-          children: ["[", insertTrimmingSpace(after, ""), "] = ", restIdentifier, ".splice(-", l.toString(), ")"],
-          names: after.flatMap((p) => p.names)
-        };
-      }
+    } else if (isToken(target)) {
       return {
-        names,
-        children: [...elements.slice(0, restIndex), {
-          ...rest,
-          children: rest.children.slice(0, -1)
-          // remove trailing comma
-        }],
-        blockPrefix,
-        length
+        ...target,
+        token: target.token.replace(/^ ?/, c)
       };
+    } else {
+      return target;
     }
-    const err = {
-      type: "Error",
-      children: ["Multiple rest elements in array pattern"]
-    };
-    return {
-      names,
-      children: [...elements, err],
-      blockPrefix,
-      length
-    };
   }
-  function gatherBindingCode(statements, opts) {
-    const thisAssignments = [];
-    const splices = [];
-    function insertRestSplices(s, p, thisAssignments2) {
-      gatherRecursiveAll(s, (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding").forEach((n) => {
-        if (n.type === "AtBinding") {
-          const { ref } = n;
-          const { id } = ref;
-          thisAssignments2.push([`this.${id} = `, ref]);
-          return;
-        }
-        if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-          n.names.forEach((id) => ({
-            push: thisAssignments2.push({
-              type: "AssignmentExpression",
-              children: [`this.${id} = `, id],
-              js: true
-            })
-          }));
-          return;
-        }
-        const { blockPrefix } = n;
-        p.push(blockPrefix);
-        return insertRestSplices(blockPrefix, p, thisAssignments2);
-      });
+  function inplaceInsertTrimmingSpace(target, c) {
+    if (!(target != null)) {
+      return target;
+    }
+    if (Array.isArray(target)) {
+      inplaceInsertTrimmingSpace(target[0], c);
+    } else if (isParent(target)) {
+      inplaceInsertTrimmingSpace(target.children, c);
+    } else if (isToken(target)) {
+      target.token = target.token.replace(/^ ?/, c);
+    }
+  }
+  function getTrimmingSpace(target) {
+    if (!(target != null)) {
+      return;
     }
-    insertRestSplices(statements, splices, thisAssignments);
-    return [splices, thisAssignments];
+    if (Array.isArray(target)) {
+      return getTrimmingSpace(target[0]);
+    } else if (isParent(target)) {
+      return getTrimmingSpace(target.children[0]);
+    } else if (isToken(target)) {
+      return target.token.match(/^ ?/)[0];
+    }
+    ;
+    return;
   }
-  function arrayElementHasTrailingComma(elementNode) {
-    const lastChild = elementNode.children.at(-1);
-    return lastChild && lastChild[lastChild.length - 1]?.token === ",";
+  function prepend(prefix, node) {
+    if (!(prefix && prefix.length)) {
+      return node;
+    }
+    if (Array.isArray(node)) {
+      return [prefix, ...node];
+    } else if (isParent(node)) {
+      return {
+        ...node,
+        children: [prefix, ...node.children]
+      };
+    } else {
+      return [prefix, node];
+    }
   }
-  var init_binding = __esm({
-    "source/parser/binding.civet"() {
-      "use strict";
-      init_traversal();
-      init_util();
+  function inplacePrepend(prefix, node) {
+    if (!prefix) {
+      return;
     }
-  });
-
-  // source/parser/pattern-matching.civet
-  function processPatternMatching(statements, ReservedWord, getRef) {
-    gatherRecursiveAll(statements, ($) => $.type === "SwitchStatement").forEach((s) => {
-      const { caseBlock } = s;
-      const { clauses } = caseBlock;
-      for (const c of clauses) {
-        if (c.type === "WhenClause" && c.break) {
-          if (isExit(c.block)) {
-            c.children.splice(c.children.indexOf(c.break), 1);
-            c.break = void 0;
-          }
+    if (Array.isArray(prefix) && !prefix.length) {
+      return;
+    }
+    if (Array.isArray(node)) {
+      node.unshift(prefix);
+    } else if (isParent(node)) {
+      node.children.unshift(prefix);
+    } else {
+      throw new Error("Can't prepend to a leaf node");
+    }
+  }
+  function literalValue(literal) {
+    let { raw } = literal;
+    switch (raw) {
+      case "null":
+        return null;
+      case "true":
+        return true;
+      case "false":
+        return false;
+    }
+    if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+      return raw.slice(1, -1);
+    }
+    const numeric = literal.children.find(
+      (child) => child.type === "NumericLiteral"
+    );
+    if (numeric) {
+      raw = raw.replace(/_/g, "");
+      const { token } = numeric;
+      if (token.endsWith("n")) {
+        return BigInt(raw.slice(0, -1));
+      } else if (token.match(/[\.eE]/)) {
+        return parseFloat(raw);
+      } else if (token.startsWith("0")) {
+        switch (token.charAt(1).toLowerCase()) {
+          case "x":
+            return parseInt(raw.replace(/0[xX]/, ""), 16);
+          case "b":
+            return parseInt(raw.replace(/0[bB]/, ""), 2);
+          case "o":
+            return parseInt(raw.replace(/0[oO]/, ""), 8);
         }
       }
-      let errors = false;
-      let isPattern = false;
-      if (clauses.some(($1) => $1.type === "PatternClause")) {
-        isPattern = true;
-        clauses.forEach((c) => {
-          if (!(c.type === "PatternClause" || c.type === "DefaultClause")) {
-            errors = true;
-            return c.children.push({
-              type: "Error",
-              message: "Can't mix pattern matching and non-pattern matching clauses"
-            });
-          }
-          ;
-          return;
-        });
+      return parseInt(raw, 10);
+    }
+    throw new Error("Unrecognized literal " + JSON.stringify(literal));
+  }
+  function startsWith(target, value) {
+    if (!target)
+      return;
+    if (Array.isArray(target)) {
+      let i = 0;
+      let l = target.length;
+      while (i < l) {
+        const t = target[i];
+        if (t && (t.length || t.token || t.children)) {
+          break;
+        }
+        i++;
       }
-      if (errors || !isPattern) {
-        return;
+      if (i < l) {
+        return startsWith(target[i], value);
       }
-      let { condition } = s;
-      if (condition.type === "ParenthesizedExpression") {
-        condition = condition.expression;
+    }
+    if (typeof target === "string")
+      return value.test(target);
+    if (target.children)
+      return startsWith(target.children, value);
+    if (target.token)
+      return value.test(target.token);
+    return;
+  }
+  function hasAwait(exp) {
+    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
+  }
+  function hasYield(exp) {
+    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Yield").length > 0;
+  }
+  function hasImportDeclaration(exp) {
+    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "ImportDeclaration").length > 0;
+  }
+  function deepCopy(node) {
+    if (node == null)
+      return node;
+    if (typeof node !== "object")
+      return node;
+    if (Array.isArray(node)) {
+      return node.map(deepCopy);
+    }
+    if (node?.type === "Ref")
+      return node;
+    return Object.fromEntries(
+      Object.entries(node).map(([key, value]) => {
+        return [key, deepCopy(value)];
+      })
+    );
+  }
+  function removeHoistDecs(node) {
+    if (node == null)
+      return;
+    if (typeof node !== "object")
+      return;
+    if ("hoistDec" in node) {
+      node.hoistDec = void 0;
+    }
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        removeHoistDecs(child);
       }
-      let hoistDec, refAssignment = [], ref = maybeRef(condition, "m");
-      if (ref !== condition) {
-        hoistDec = {
-          type: "Declaration",
-          children: ["let ", ref],
-          names: []
-        };
-        refAssignment = [{
-          type: "AssignmentExpression",
-          children: [ref, " = ", condition]
-        }, ","];
+      return;
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        removeHoistDecs(child);
       }
-      let prev = [], root = prev;
-      const l = clauses.length;
-      clauses.forEach((c, i) => {
-        if (c.type === "DefaultClause") {
-          prev.push(c.block);
-          return;
-        }
-        let { patterns, block } = c;
-        let pattern = patterns[0];
-        const indent = block.expressions?.[0]?.[0] || "";
-        const alternativeConditions = patterns.map((pattern2, i2) => {
-          const conditions = [];
-          getPatternConditions(pattern2, ref, conditions, getRef);
-          return conditions;
-        });
-        const conditionExpression = alternativeConditions.map((conditions, i2) => {
-          const conditionArray = conditions.map((c2, i3) => {
-            if (i3 === 0)
-              return c2;
-            return [" && ", ...c2];
-          });
-          if (i2 === 0)
-            return conditionArray;
-          return [" || ", ...conditionArray];
-        });
-        const condition2 = {
-          type: "ParenthesizedExpression",
-          children: ["(", ...refAssignment, conditionExpression, ")"],
-          expression: conditionExpression
-        };
-        const prefix = [];
-        switch (pattern.type) {
-          case "ArrayBindingPattern":
-            if (pattern.length === 0)
-              break;
-          case "ObjectBindingPattern": {
-            if (pattern.properties?.length === 0)
-              break;
-            let [splices, thisAssignments] = gatherBindingCode(pattern);
-            const patternBindings = nonMatcherBindings(pattern);
-            splices = splices.map((s2) => [", ", nonMatcherBindings(s2)]);
-            thisAssignments = thisAssignments.map((a) => [indent, a, ";"]);
-            const duplicateDeclarations = aggregateDuplicateBindings([patternBindings, splices], ReservedWord);
-            prefix.push([indent, "const ", patternBindings, " = ", ref, splices, ";"]);
-            prefix.push(...thisAssignments);
-            prefix.push(...duplicateDeclarations.map((d) => [indent, d, ";"]));
-            break;
-          }
+    }
+  }
+  function makeAmpersandFunction(rhs) {
+    let { ref, typeSuffix, body } = rhs;
+    if (!(ref != null)) {
+      ref = makeRef("$");
+      inplacePrepend(ref, body);
+    }
+    if (body?.type === "ObjectExpression") {
+      body = makeLeftHandSideExpression(body);
+    }
+    const parameters = makeNode({
+      type: "Parameters",
+      children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
+      names: []
+    });
+    const expressions = [[" ", body]];
+    const block = makeNode({
+      type: "BlockStatement",
+      bare: true,
+      expressions,
+      children: [expressions],
+      implicitlyReturned: true
+    });
+    const children = [parameters, " =>", block];
+    const async = hasAwait(body);
+    if (async) {
+      children.unshift("async ");
+    }
+    const fn = makeNode({
+      type: "ArrowFunction",
+      signature: {
+        modifier: {
+          async
         }
-        block.expressions.unshift(...prefix);
-        const next = [];
-        braceBlock(block);
-        if (i < l - 1)
-          next.push("\n", "else ");
-        prev.push(["", {
-          type: "IfStatement",
-          children: ["if", condition2, block, next],
-          then: block,
-          else: next,
-          hoistDec
-        }]);
-        hoistDec = void 0;
-        refAssignment = [];
-        return prev = next;
-      });
-      s.type = "PatternMatchingStatement";
-      s.children = [root];
-      return addParentPointers(s, s.parent);
+      },
+      children,
+      ref,
+      block,
+      parameters,
+      ampersandBlock: true,
+      body
     });
+    if (isStatement(body)) {
+      braceBlock(block);
+      fn.ampersandBlock = false;
+      delete fn.body;
+    }
+    return fn;
   }
-  function getPatternConditions(pattern, ref, conditions, getRef) {
-    if (pattern.rest)
+  function makeLeftHandSideExpression(expression) {
+    if (expression.parenthesized) {
+      return expression;
+    }
+    switch (expression.type) {
+      case "AmpersandRef":
+      case "CallExpression":
+      case "Identifier":
+      case "JSXElement":
+      case "JSXFragment":
+      case "Literal":
+      case "MemberExpression":
+      case "NewExpression":
+      case "ParenthesizedExpression":
+      case "Ref":
+      case "Placeholder":
+      case "StatementExpression":
+        return expression;
+    }
+    return makeNode({
+      type: "ParenthesizedExpression",
+      children: ["(", expression, ")"],
+      expression,
+      implicit: true,
+      parent: void 0
+    });
+  }
+  function updateParentPointers(node, parent, depth = 1) {
+    if (!(node != null)) {
       return;
-    switch (pattern.type) {
-      case "ArrayBindingPattern": {
-        const { elements, length } = pattern, hasRest = elements.some((e) => e.rest), l = (length - hasRest).toString(), lengthCheck = hasRest ? [ref, ".length >= ", l] : [getRef("len"), "(", ref, ", ", l, ")"];
-        conditions.push(
-          ["Array.isArray(", ref, ")"],
-          lengthCheck
-        );
-        elements.forEach(({ children: [, e] }, i) => {
-          const subRef = [ref, "[", i.toString(), "]"];
-          return getPatternConditions(e, subRef, conditions, getRef);
-        });
-        const { blockPrefix } = pattern;
-        if (blockPrefix) {
-          const postElements = blockPrefix.children[1], { length: postLength } = postElements;
-          postElements.forEach(({ children: [, e] }, i) => {
-            const subRef = [ref, "[", ref, ".length - ", (postLength + i).toString(), "]"];
-            return getPatternConditions(e, subRef, conditions, getRef);
-          });
-        }
-        break;
-      }
-      case "ObjectBindingPattern": {
-        conditions.push(
-          ["typeof ", ref, " === 'object'"],
-          [ref, " != null"]
-        );
-        pattern.properties.forEach((p) => {
-          switch (p.type) {
-            case "PinProperty":
-            case "BindingProperty": {
-              const { name, value } = p;
-              let subRef;
-              switch (name.type) {
-                case "ComputedPropertyName":
-                  conditions.push([name.expression, " in ", ref]);
-                  subRef = [ref, name];
-                  break;
-                case "Literal":
-                case "StringLiteral":
-                case "NumericLiteral":
-                  conditions.push([name, " in ", ref]);
-                  subRef = [ref, "[", name, "]"];
-                  break;
-                default:
-                  conditions.push(["'", name, "' in ", ref]);
-                  subRef = [ref, ".", name];
-              }
-              if (value) {
-                getPatternConditions(value, subRef, conditions, getRef);
-              }
-              break;
-            }
-          }
-        });
-        break;
-      }
-      case "ConditionFragment": {
-        let { children } = pattern;
-        if (children.length) {
-          let [first, ...rest] = children;
-          let [ws, ...op] = first;
-          ws = [" "].concat(ws);
-          first = [ws, ...op];
-          children = [first, ...rest];
-        }
-        conditions.push(
-          processBinaryOpExpression([ref, children])
-        );
-        break;
+    }
+    if (!(typeof node === "object")) {
+      return;
+    }
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        updateParentPointers(child, parent, depth);
       }
-      case "RegularExpressionLiteral": {
-        conditions.push(
-          ["typeof ", ref, " === 'string'"],
-          [pattern, ".test(", ref, ")"]
-        );
-        break;
+      return;
+    }
+    node = node;
+    if (parent != null) {
+      node.parent = parent;
+    }
+    if (depth && isParent(node)) {
+      for (const child of node.children) {
+        updateParentPointers(child, node, depth - 1);
       }
-      case "PinPattern":
-        conditions.push([
-          ref,
-          " === ",
-          pattern.expression
-        ]);
-        break;
+    }
+  }
+  function makeNode(node) {
+    updateParentPointers(node);
+    return node;
+  }
+  function makeRef(base = "ref", id = base) {
+    return {
+      type: "Ref",
+      base,
+      id
+    };
+  }
+  function needsRef(expression, base = "ref") {
+    switch (expression.type) {
+      case "Ref":
+      case "Identifier":
       case "Literal":
-        conditions.push([
-          ref,
-          " === ",
-          pattern
-        ]);
-        break;
-      default:
-        break;
+        return;
+    }
+    return makeRef(base);
+  }
+  function maybeRef(exp, base = "ref") {
+    if (!needsRef(exp))
+      return exp;
+    return makeRef(base);
+  }
+  function skipIfOnlyWS(target) {
+    if (!target)
+      return target;
+    if (Array.isArray(target)) {
+      if (target.length === 1) {
+        return skipIfOnlyWS(target[0]);
+      } else if (target.every((e) => skipIfOnlyWS(e) === void 0)) {
+        return void 0;
+      }
+      return target;
+    }
+    if (target.token != null && target.token.trim() === "") {
+      return void 0;
+    }
+    return target;
+  }
+  function spliceChild(node, child, del, ...replacements) {
+    const children = node?.children ?? node;
+    if (!Array.isArray(children)) {
+      throw new Error("spliceChild: non-array node has no children field");
+    }
+    const index = children.indexOf(child);
+    if (index < 0) {
+      throw new Error("spliceChild: child not found");
+    }
+    return children.splice(index, del, ...replacements);
+  }
+  function convertOptionalType(suffix) {
+    if (suffix.t.type === "AssertsType") {
+      spliceChild(suffix, suffix.optional, 1, suffix.optional = {
+        type: "Error",
+        message: "Can't use optional ?: syntax with asserts type"
+      });
+      return;
+    }
+    spliceChild(suffix, suffix.optional, 1, suffix.optional = void 0);
+    const wrap = suffix.type === "ReturnTypeAnnotation";
+    spliceChild(suffix, suffix.t, 1, suffix.t = [
+      getTrimmingSpace(suffix.t),
+      wrap && "(",
+      // TODO: avoid parens if unnecessary
+      "undefined | ",
+      parenthesizeType(insertTrimmingSpace(suffix.t, "")),
+      wrap && ")"
+    ]);
+  }
+  function parenthesizeType(type) {
+    if (typeNeedsNoParens.has(type.type)) {
+      return type;
+    }
+    return ["(", type, ")"];
+  }
+  function wrapIIFE(expressions, asyncFlag) {
+    let prefix;
+    let async;
+    if (asyncFlag) {
+      async = "async ";
+    } else if (hasAwait(expressions)) {
+      async = "async ";
+      prefix = {
+        type: "Await",
+        children: ["await "]
+      };
+    }
+    const block = makeNode({
+      type: "BlockStatement",
+      expressions,
+      children: ["{", expressions, "}"],
+      bare: false,
+      root: false,
+      parent: void 0
+    });
+    const parameters = {
+      type: "Parameters",
+      children: ["()"],
+      names: []
+    };
+    const signature = {
+      modifier: {
+        async: !!async
+      },
+      returnType: void 0
+    };
+    const fn = makeNode({
+      type: "ArrowFunction",
+      signature,
+      parameters,
+      returnType: void 0,
+      ts: false,
+      async,
+      block,
+      children: [async, parameters, "=>", block]
+    });
+    const exp = makeNode({
+      type: "CallExpression",
+      children: [makeLeftHandSideExpression(fn), "()"]
+    });
+    if (prefix) {
+      return [makeLeftHandSideExpression([prefix, exp])];
     }
+    return [exp];
   }
-  function elideMatchersFromArrayBindings(elements) {
-    return elements.map((el) => {
-      if (el.type === "BindingRestElement") {
-        return ["", el, void 0];
-      }
-      const { children: [ws, e, delim] } = el;
-      switch (e.type) {
-        case "Literal":
-        case "RegularExpressionLiteral":
-        case "StringLiteral":
-        case "PinPattern":
-          return delim;
-        default:
-          return [ws, nonMatcherBindings(e), delim];
-      }
+  function wrapWithReturn(expression) {
+    const children = expression ? ["return ", expression] : ["return"];
+    return makeNode({
+      type: "ReturnStatement",
+      children,
+      expression,
+      parent: expression?.parent
     });
   }
-  function elideMatchersFromPropertyBindings(properties) {
-    return properties.map((p) => {
-      switch (p.type) {
-        case "BindingProperty": {
-          const { children, name, value } = p;
-          const [ws] = children;
-          switch (value && value.type) {
-            case "ArrayBindingPattern":
-            case "ObjectBindingPattern":
-              return {
-                ...p,
-                children: [ws, name, ": ", nonMatcherBindings(value), p.delim]
-              };
-            case "Identifier":
-              return p;
-            case "Literal":
-            case "RegularExpressionLiteral":
-            case "StringLiteral":
-            default:
-              return {
-                ...p,
-                children: [ws, name, p.delim]
-              };
+  var assert, statementTypes, typeNeedsNoParens;
+  var init_util = __esm({
+    "source/parser/util.civet"() {
+      "use strict";
+      init_block();
+      init_traversal();
+      init_function();
+      assert = {
+        equal(a, b, msg) {
+          if (a !== b) {
+            throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`);
           }
         }
-        case "PinProperty":
-        case "BindingRestProperty":
-        default:
-          return p;
-      }
-    });
+      };
+      statementTypes = /* @__PURE__ */ new Set([
+        "BlockStatement",
+        "BreakStatement",
+        "ContinueStatement",
+        "DebuggerStatement",
+        "Declaration",
+        "DoStatement",
+        "ForStatement",
+        "IfStatement",
+        "IterationStatement",
+        "LabeledStatement",
+        "ReturnStatement",
+        "SwitchStatement",
+        "ThrowStatement",
+        "TryStatement"
+      ]);
+      typeNeedsNoParens = /* @__PURE__ */ new Set([
+        "IdentifierType",
+        "ImportType",
+        "LiteralType",
+        "TupleType",
+        "ParenthesizedType",
+        "UnaryType"
+      ]);
+    }
+  });
+
+  // source/parser/traversal.civet
+  function gatherRecursiveWithinFunction(node, predicate) {
+    return gatherRecursive(node, predicate, isFunction);
   }
-  function nonMatcherBindings(pattern) {
-    switch (pattern.type) {
-      case "ArrayBindingPattern": {
-        const elements = elideMatchersFromArrayBindings(pattern.elements);
-        const children = ["[", elements, "]"];
-        return {
-          ...pattern,
-          children,
-          elements
-        };
-      }
-      case "PostRestBindingElements": {
-        const els = elideMatchersFromArrayBindings(pattern.children[1]);
-        return {
-          ...pattern,
-          children: [
-            pattern.children[0],
-            els,
-            ...pattern.children.slice(2)
-          ]
-        };
+  function findChildIndex(parent, child) {
+    if (!(parent != null)) {
+      return -1;
+    }
+    const children = Array.isArray(parent) ? parent : parent.children;
+    if (!(children != null)) {
+      return -1;
+    }
+    for (let i1 = 0, len = children.length; i1 < len; i1++) {
+      const i = i1;
+      const c = children[i1];
+      if (c === child || Array.isArray(c) && arrayRecurse(c)) {
+        return i;
       }
-      case "ObjectBindingPattern":
-        return ["{", elideMatchersFromPropertyBindings(pattern.properties), "}"];
-      default:
-        return pattern;
     }
-  }
-  function aggregateDuplicateBindings(bindings, ReservedWord) {
-    const props = gatherRecursiveAll(bindings, ($2) => $2.type === "BindingProperty");
-    const arrayBindings = gatherRecursiveAll(bindings, ($3) => $3.type === "ArrayBindingPattern");
-    arrayBindings.forEach((a) => {
-      const { elements } = a;
-      return elements.forEach((element) => {
-        if (Array.isArray(element)) {
-          const [, e] = element;
-          if (e.type === "Identifier") {
-            return props.push(e);
-          } else if (e.type === "BindingRestElement") {
-            return props.push(e);
-          }
-          ;
-          return;
+    function arrayRecurse(array) {
+      for (let i2 = 0, len1 = array.length; i2 < len1; i2++) {
+        const c = array[i2];
+        if (c === child || Array.isArray(c) && arrayRecurse(c)) {
+          return true;
         }
-        ;
-        return;
-      });
-    });
-    const declarations = [];
-    const propsGroupedByName = /* @__PURE__ */ new Map();
-    for (const p of props) {
-      const { name, value } = p;
-      const key = value?.name || name?.name || name;
-      if (propsGroupedByName.has(key)) {
-        propsGroupedByName.get(key).push(p);
-      } else {
-        propsGroupedByName.set(key, [p]);
       }
+      return false;
     }
-    propsGroupedByName.forEach((shared, key) => {
-      if (!key) {
-        return;
+    return -1;
+  }
+  function findAncestor(node, predicate, stopPredicate) {
+    let { parent } = node;
+    while (parent && !stopPredicate?.(parent, node)) {
+      if (predicate(parent, node)) {
+        return { ancestor: parent, child: node };
       }
-      if (ReservedWord({ fail() {
-      } }, {
-        pos: 0,
-        input: key
-      })) {
-        shared.forEach((p) => {
-          return aliasBinding(p, makeRef(`_${key}`, key));
+      node = parent;
+      ({ parent } = node);
+    }
+    return { ancestor: void 0, child: node };
+  }
+  function gatherNodes(node, predicate) {
+    if (node == null)
+      return [];
+    if (Array.isArray(node)) {
+      return node.flatMap((n) => gatherNodes(n, predicate));
+    }
+    if (predicate(node)) {
+      return [node];
+    }
+    switch (node.type) {
+      case "BlockStatement":
+        return [];
+      case "ForStatement":
+        const isDec = node.declaration?.type === "Declaration";
+        return node.children.flatMap((n) => {
+          if (isDec && n === node.declaration)
+            return [];
+          return gatherNodes(n, predicate);
         });
-        return;
-      }
-      if (shared.length === 1) {
-        return;
-      }
-      const refs = shared.map((p) => {
-        const ref = makeRef(key);
-        aliasBinding(p, ref);
-        return ref;
-      });
-      return declarations.push(["const ", key, " = [", ...refs.map((r, i) => {
-        return i === 0 ? r : [", ", r];
-      }), "]"]);
-    });
-    return declarations;
+      default:
+        return gatherNodes(node.children, predicate);
+    }
+  }
+  function gatherRecursive(node, predicate, skipPredicate) {
+    if (node == null)
+      return [];
+    if (Array.isArray(node)) {
+      return node.flatMap((n) => gatherRecursive(n, predicate, skipPredicate));
+    }
+    if (skipPredicate?.(node))
+      return [];
+    if (predicate(node)) {
+      return [node];
+    }
+    return gatherRecursive(node.children, predicate, skipPredicate);
   }
-  function aliasBinding(p, ref) {
-    if (p.type === "Identifier") {
-      p.children[0] = ref;
-    } else if (p.type === "BindingRestElement") {
-      aliasBinding(p.binding, ref);
-    } else if (p.value?.type === "Identifier") {
-      aliasBinding(p.value, ref);
-    } else {
-      p.value = ref;
-      const index = p.children.indexOf(p.name);
-      p.children.splice(index + 1, 0, ": ", ref);
+  function gatherRecursiveAll(node, predicate) {
+    if (node == null)
+      return [];
+    if (Array.isArray(node)) {
+      return node.flatMap((n) => gatherRecursiveAll(n, predicate));
+    }
+    const nodes = gatherRecursiveAll(node.children, predicate);
+    if (predicate(node)) {
+      nodes.push(node);
     }
+    return nodes;
   }
-  var init_pattern_matching = __esm({
-    "source/parser/pattern-matching.civet"() {
+  var init_traversal = __esm({
+    "source/parser/traversal.civet"() {
       "use strict";
-      init_traversal();
       init_util();
-      init_block();
-      init_binding();
-      init_op();
     }
   });
 
-  // source/parser/function.civet
-  function isVoidType(t) {
-    return t?.type === "LiteralType" && t.t.type === "VoidType";
-  }
-  function isPromiseVoidType(t) {
-    return t?.type === "IdentifierType" && t.raw === "Promise" && t.args?.types?.length === 1 && isVoidType(t.args.types[0]);
-  }
-  function isGeneratorVoidType(t) {
-    return t?.type === "IdentifierType" && (t.raw === "Iterator" || t.raw === "Generator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
-  }
-  function isAsyncGeneratorVoidType(t) {
-    return t?.type === "IdentifierType" && (t.raw === "AsyncIterator" || t.raw === "AsyncGenerator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
-  }
-  function implicitFunctionBlock(f) {
-    if (f.abstract || f.block || f.signature?.optional)
-      return;
-    const { name, parent } = f;
-    if (parent?.type === "ExportDeclaration")
-      return;
-    const expressions = parent?.expressions ?? parent?.elements;
-    const currentIndex = expressions?.findIndex(([, def]) => def === f);
-    const following = currentIndex >= 0 && expressions[currentIndex + 1]?.[1];
-    if (f.type === following?.type && name && name === following.name) {
-      f.ts = true;
+  // source/parser/op.civet
+  function getPrecedence(op) {
+    if (typeof op === "string") {
+      return precedenceMap.get(op) ?? (() => {
+        throw new Error(`Unknown operator: ${op}`);
+      })();
+    } else if (typeof op.prec === "number") {
+      return op.prec;
     } else {
-      const block = makeEmptyBlock();
-      block.parent = f;
-      f.block = block;
-      f.children.push(block);
-      f.ts = false;
+      return precedenceMap.get(op.prec ?? op.token) ?? (op.relational ? precedenceRelational : precedenceCustomDefault);
     }
   }
-  function processReturn(f, implicitReturns) {
-    let { returnType } = f.signature;
-    if (returnType && returnType.optional) {
-      convertOptionalType(returnType);
-    }
-    if (!processReturnValue(f) && implicitReturns) {
-      const { signature, block } = f;
-      const { modifier, name, returnType: returnType2 } = signature;
-      const { async, generator, set } = modifier;
-      const isMethod = f.type === "MethodDefinition";
-      const isConstructor = isMethod && name === "constructor";
-      const isVoid = isVoidType(returnType2?.t) || async && (isPromiseVoidType(returnType2?.t) || generator && isAsyncGeneratorVoidType(returnType2?.t)) || !async && generator && isGeneratorVoidType(returnType2?.t);
-      if (block?.type === "BlockStatement") {
-        if (isVoid || set || isConstructor) {
-          if (block.bare && block.implicitlyReturned) {
-            block.children = [" {", ...block.children, " }"];
-            block.bare = block.implicitlyReturned = false;
+  function processBinaryOpExpression($0) {
+    return recurse(expandChainedComparisons($0));
+    function recurse(expandedOps) {
+      let i = 2;
+      while (i < expandedOps.length) {
+        let op = expandedOps[i];
+        if (op.special) {
+          let advanceLeft2 = function(allowEqual) {
+            while (start >= 4) {
+              const prevPrec = getPrecedence(expandedOps[start - 2]);
+              if (!(prevPrec > prec || allowEqual && prevPrec === prec)) {
+                return prevPrec === prec;
+              }
+              start -= 4;
+            }
+            return false;
+          }, advanceRight2 = function(allowEqual) {
+            while (end + 4 < expandedOps.length) {
+              const nextPrec = getPrecedence(expandedOps[end + 2]);
+              if (!(nextPrec > prec || allowEqual && nextPrec === prec)) {
+                return nextPrec === prec;
+              }
+              end += 4;
+            }
+            return false;
+          };
+          var advanceLeft = advanceLeft2, advanceRight = advanceRight2;
+          let start = i - 2, end = i + 2;
+          const prec = getPrecedence(op);
+          let error;
+          switch (op.assoc) {
+            case "left":
+            case void 0: {
+              advanceLeft2(true);
+              advanceRight2(false);
+              break;
+            }
+            case "right": {
+              advanceLeft2(false);
+              advanceRight2(true);
+              break;
+            }
+            case "non": {
+              if (advanceLeft2(false) || advanceRight2(false)) {
+                error = {
+                  type: "Error",
+                  message: `non-associative operator ${op.token} used at same precedence level without parenthesization`
+                };
+              }
+              ;
+              break;
+            }
+            case "arguments": {
+              if (advanceLeft2(false)) {
+                error = {
+                  type: "Error",
+                  message: `arguments operator ${op.token} used at same precedence level as ${expandedOps[start - 2].token} to the left`
+                };
+              }
+              advanceRight2(true);
+              break;
+            }
+            default: {
+              throw new Error(`Unsupported associativity: ${op.assoc}`);
+            }
           }
-        } else {
-          if (!block.implicitlyReturned) {
-            insertReturn(block);
+          let a = start === i - 2 ? expandedOps[start] : expandedOps.slice(start, i - 1);
+          let wsOp = expandedOps[i - 1];
+          let wsB = expandedOps[i + 1];
+          let b = end === i + 2 ? expandedOps[i + 2] : expandedOps.slice(i + 2, end + 1);
+          if (op.assoc === "arguments") {
+            let i2 = 2;
+            while (i2 < b.length) {
+              if (prec === getPrecedence(b[i2])) {
+                if (!(b[i2].token === op.token)) {
+                  error ??= {
+                    type: "Error",
+                    message: `arguments operator ${op.token} used at same precedence level as ${b[i2].token} to the right`
+                  };
+                }
+                b[i2] = ",";
+              }
+              i2 += 4;
+            }
+          } else {
+            b = recurse(b);
           }
+          if (op.token === "instanceof" && b.type === "Literal" && b.children?.[0]?.type === "StringLiteral") {
+            a = ["typeof ", makeLeftHandSideExpression(a)];
+            if (op.negated) {
+              op = { ...op, token: "!==", negated: false };
+            } else {
+              op = { ...op, token: "===" };
+            }
+          }
+          if (op.asConst) {
+            a = makeAsConst(a);
+            b = makeAsConst(b);
+          }
+          let children;
+          if (op.call) {
+            wsOp = insertTrimmingSpace(wsOp, "");
+            if (op.reversed) {
+              wsB = insertTrimmingSpace(wsB, "");
+              children = [wsOp, op.call, "(", wsB, b, ", ", a, ")", op.suffix];
+            } else {
+              children = [wsOp, op.call, "(", a, ",", wsB, b, ")", op.suffix];
+            }
+          } else if (op.method) {
+            wsOp = insertTrimmingSpace(wsOp, "");
+            wsB = insertTrimmingSpace(wsB, "");
+            if (op.reversed) {
+              if (end !== i + 2)
+                b = makeLeftHandSideExpression(b);
+              b = dotNumericLiteral(b);
+              children = [wsB, b, wsOp, ".", op.method, "(", a, ")"];
+            } else {
+              if (start !== i - 2 || a.type === "NumericLiteral") {
+                a = makeLeftHandSideExpression(a);
+              }
+              a = dotNumericLiteral(a);
+              children = [a, wsOp, ".", op.method, "(", wsB, b, ")"];
+            }
+          } else if (op.token) {
+            children = [a, wsOp, op, wsB, b];
+            if (op.negated)
+              children = ["(", ...children, ")"];
+          } else {
+            throw new Error("Unknown operator: " + JSON.stringify(op));
+          }
+          if (op.negated)
+            children.unshift("!");
+          if (error != null) {
+            children.push(error);
+          }
+          expandedOps.splice(start, end - start + 1, {
+            children
+          });
+          i = start + 2;
+        } else {
+          i += 4;
         }
-      }
-    }
-  }
-  function processReturnValue(func) {
-    const { block } = func;
-    const values = gatherRecursiveWithinFunction(
-      block,
-      ({ type }) => type === "ReturnValue"
-    );
-    if (!values.length) {
-      return false;
-    }
-    const ref = makeRef("ret");
-    let declaration;
-    values.forEach((value) => {
-      value.children = [ref];
-      const { ancestor, child } = findAncestor(
-        value,
-        ({ type }) => type === "Declaration",
-        isFunction
-      );
-      if (ancestor) {
-        return declaration ??= child;
-      }
-      ;
-      return;
-    });
-    let returnType = func.returnType ?? func.signature?.returnType;
-    if (returnType) {
-      const { t } = returnType;
-      let m;
-      if (m = t.type, m === "TypePredicate") {
-        returnType = ": boolean";
-      } else if (m === "AssertsType") {
-        returnType = void 0;
-      }
-    }
-    if (declaration) {
-      if (!(declaration.suffix != null)) {
-        declaration.children[1] = declaration.suffix = returnType;
-      }
-    } else {
-      block.expressions.unshift([
-        getIndent(block.expressions[0]),
-        {
-          type: "Declaration",
-          children: ["let ", ref, returnType],
-          names: []
-        },
-        ";"
-      ]);
-    }
-    gatherRecursiveWithinFunction(
-      block,
-      (r) => r.type === "ReturnStatement" && !r.expression
-    ).forEach((r) => {
-      r.expression = ref;
-      return r.children.splice(-1, 1, " ", ref);
-    });
-    if (!(block.children.at(-2)?.type === "ReturnStatement")) {
-      const indent = getIndent(block.expressions.at(-1)) || ";";
-      block.expressions.push([
-        [indent],
-        {
-          type: "ReturnStatement",
-          expression: ref,
-          children: ["return ", ref]
-        }
-      ]);
+      }
+      return expandedOps;
     }
-    return true;
+    ;
+    return recurse;
   }
-  function patternAsValue(pattern) {
-    switch (pattern.type) {
-      case "ArrayBindingPattern": {
-        const children = [...pattern.children];
-        const index = children.indexOf(pattern.elements);
-        if (index < 0)
-          throw new Error("failed to find elements in ArrayBindingPattern");
-        children[index] = pattern.elements.map((el) => {
-          const [ws, e, delim] = el.children;
-          return { ...el, children: [ws, patternAsValue(e), delim] };
-        });
-        return { ...pattern, children };
-      }
-      case "ObjectBindingPattern": {
-        const children = [...pattern.children];
-        const index = children.indexOf(pattern.properties);
-        if (index < 0)
-          throw new Error("failed to find properties in ArrayBindingPattern");
-        children[index] = pattern.properties.map(patternAsValue);
-        return { ...pattern, children };
-      }
-      case "Identifier":
-      case "BindingProperty": {
-        const children = [
-          // { name: value } = ... declares value, not name
-          pattern.value ?? pattern.name,
-          pattern.delim
-        ];
-        if (isWhitespaceOrEmpty(pattern.children[0])) {
-          children.unshift(pattern.children[0]);
-        }
-        return { ...pattern, children };
-      }
-      default:
-        return pattern;
+  function dotNumericLiteral(literal) {
+    if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
+      literal.children.push(".");
+      literal.raw += ".";
     }
+    return literal;
   }
-  function assignResults(node, collect) {
-    if (!node)
-      return;
-    switch (node.type) {
-      case "BlockStatement":
-        if (node.expressions.length) {
-          assignResults(node.expressions.at(-1), collect);
-        } else {
-          node.expressions.push(["", collect("void 0"), ";"]);
-        }
-        return;
-      case "CaseBlock":
-        node.clauses.forEach((clause) => {
-          return assignResults(clause, collect);
-        });
-        return;
-      case "WhenClause":
-      case "DefaultClause":
-      case "PatternClause": {
-        assignResults(node.block, collect);
-        return;
-      }
+  function makeAsConst(node) {
+    if (Array.isArray(node) && node.length === 1) {
+      node = node[0];
     }
-    if (!Array.isArray(node)) {
-      return;
+    if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
+      return { ...node, children: [...node.children, asConst] };
+    } else {
+      return node;
     }
-    let [, exp, semi] = node;
-    if (semi?.type === "SemicolonDelimiter") {
-      return;
+  }
+  function isExistence(exp) {
+    if (exp?.type === "ParenthesizedExpression" && exp.implicit) {
+      exp = exp.expression;
     }
-    if (!exp) {
-      return;
+    if (exp?.type === "Existence") {
+      return exp;
     }
-    if (isExit(exp)) {
-      return;
+    ;
+    return;
+  }
+  function isRelationalOp(op) {
+    return op.relational || getPrecedence(op) === precedenceRelational;
+  }
+  function expandChainedComparisons([first, binops]) {
+    if (!binops.length) {
+      return [first];
     }
-    const outer = exp;
-    let { type } = exp;
-    if (type === "LabelledStatement") {
-      exp = exp.statement;
-      ({ type } = exp);
+    const results = [];
+    let start = 0;
+    const chains = [];
+    var i = 0;
+    for (let i3 = 0, len2 = binops.length; i3 < len2; i3++) {
+      var i = i3;
+      var [, op] = binops[i3];
+      if (isRelationalOp(op)) {
+        chains.push(i);
+      } else if (getPrecedence(op) < precedenceRelational) {
+        processChains();
+        first = results.pop();
+      }
     }
-    switch (exp.type) {
-      case "BreakStatement":
-      case "ContinueStatement":
-      case "DebuggerStatement":
-      case "EmptyStatement":
-      case "ReturnStatement":
-      case "ThrowStatement":
-        return;
-      case "Declaration":
-        exp.children.push([
-          "",
-          [";", collect(patternAsValue(exp.bindings.at(-1).pattern))]
-        ]);
-        return;
-      case "ForStatement":
-      case "IterationStatement":
-      case "DoStatement":
-        wrapIterationReturningResults(exp, outer, collect);
-        return;
-      case "BlockStatement":
-        assignResults(exp.expressions[exp.expressions.length - 1], collect);
-        return;
-      case "IfStatement":
-        assignResults(exp.then, collect);
-        if (exp.then.bare && !exp.then.semicolon) {
-          exp.then.children.push(exp.then.semicolon = ";");
+    processChains();
+    return results;
+    function processChains() {
+      if (chains.length > 0) {
+        first = expandExistence(first);
+        for (let i4 = 0, len3 = chains.length; i4 < len3; i4++) {
+          const k = i4;
+          const index = chains[i4];
+          if (k > 0) {
+            results.push(" ", "&&", " ");
+          }
+          const binop = binops[index];
+          const exp = binop[3] = expandExistence(binop[3]);
+          results.push(first);
+          const endIndex = chains[k + 1] ?? i + 1;
+          results.push(...binops.slice(start, endIndex).flat());
+          first = [exp].concat(binops.slice(index + 1, endIndex));
+          start = endIndex;
         }
-        if (exp.else) {
-          assignResults(exp.else[2], collect);
-        } else {
-          exp.children.push([" else {", collect("undefined"), "}"]);
+      } else {
+        results.push(first);
+        results.push(...binops.slice(start, i + 1).flat());
+        start = i + 1;
+      }
+      chains.length = 0;
+    }
+    function expandExistence(exp) {
+      let ref;
+      if (ref = isExistence(exp)) {
+        const existence = ref;
+        results.push(existence, " ", "&&", " ");
+        return existence.expression;
+      } else {
+        return exp;
+      }
+    }
+    ;
+  }
+  var precedenceOrder, precedenceMap, precedenceStep, precedenceRelational, precedenceCustomDefault, asConst;
+  var init_op = __esm({
+    "source/parser/op.civet"() {
+      "use strict";
+      init_util();
+      precedenceOrder = [
+        ["||", "??"],
+        ["^^"],
+        ["&&"],
+        ["|"],
+        ["^"],
+        ["&"],
+        // NOTE: Equality and inequality merged because of relational chaining
+        [
+          "==",
+          "!=",
+          "===",
+          "!==",
+          "<",
+          "<=",
+          ">",
+          ">=",
+          "in",
+          "instanceof"
+        ],
+        // NOTE: Extra in-between level for default custom operators
+        ["custom"],
+        ["<<", ">>", ">>>"],
+        ["+", "-"],
+        ["*", "/", "%"],
+        ["**"]
+      ];
+      precedenceMap = /* @__PURE__ */ new Map();
+      for (let i1 = 0, len = precedenceOrder.length; i1 < len; i1++) {
+        const prec = i1;
+        const ops = precedenceOrder[i1];
+        for (let i2 = 0, len1 = ops.length; i2 < len1; i2++) {
+          const op = ops[i2];
+          precedenceMap.set(op, prec);
         }
-        return;
-      case "PatternMatchingStatement":
-        assignResults(exp.children[0][0], collect);
-        return;
-      case "SwitchStatement":
-        assignResults(exp.children[2], collect);
-        return;
-      case "TryStatement":
-        exp.blocks.forEach((block) => assignResults(block, collect));
-        return;
-    }
-    if (node.at(-1)?.type === "SemicolonDelimiter") {
-      return;
+      }
+      precedenceStep = 1 / 64;
+      precedenceRelational = precedenceMap.get("==");
+      precedenceCustomDefault = precedenceMap.get("custom");
+      asConst = {
+        ts: true,
+        children: [" as const"]
+      };
     }
-    node[1] = collect(node[1]);
-  }
-  function insertReturn(node, outerNode = node) {
-    if (!node)
-      return;
-    switch (node.type) {
-      case "BlockStatement":
-        if (node.expressions.length) {
-          const last = node.expressions[node.expressions.length - 1];
-          insertReturn(last);
-        } else {
-          if (node.parent.type === "CatchClause") {
-            node.expressions.push(["return"]);
+  });
+
+  // source/parser/pattern-matching.civet
+  function processPatternMatching(statements, ReservedWord, getRef) {
+    gatherRecursiveAll(statements, ($) => $.type === "SwitchStatement").forEach((s) => {
+      const { caseBlock } = s;
+      const { clauses } = caseBlock;
+      for (const c of clauses) {
+        if (c.type === "WhenClause" && c.break) {
+          if (isExit(c.block)) {
+            c.children.splice(c.children.indexOf(c.break), 1);
+            c.break = void 0;
           }
         }
+      }
+      let errors = false;
+      let isPattern = false;
+      if (clauses.some(($1) => $1.type === "PatternClause")) {
+        isPattern = true;
+        clauses.forEach((c) => {
+          if (!(c.type === "PatternClause" || c.type === "DefaultClause")) {
+            errors = true;
+            return c.children.push({
+              type: "Error",
+              message: "Can't mix pattern matching and non-pattern matching clauses"
+            });
+          }
+          ;
+          return;
+        });
+      }
+      if (errors || !isPattern) {
         return;
-      case "WhenClause":
-        if (node.break) {
-          node.children.splice(node.children.indexOf(node.break), 1);
+      }
+      let { condition } = s;
+      if (condition.type === "ParenthesizedExpression") {
+        condition = condition.expression;
+      }
+      let hoistDec, refAssignment = [], ref = maybeRef(condition, "m");
+      if (ref !== condition) {
+        hoistDec = {
+          type: "Declaration",
+          children: ["let ", ref],
+          names: []
+        };
+        refAssignment = [{
+          type: "AssignmentExpression",
+          children: [ref, " = ", condition]
+        }, ","];
+      }
+      let prev = [], root = prev;
+      const l = clauses.length;
+      clauses.forEach((c, i) => {
+        if (c.type === "DefaultClause") {
+          prev.push(c.block);
+          return;
         }
-        if (node.block.expressions.length) {
-          insertReturn(node.block);
-        } else {
-          node.block.expressions.push(wrapWithReturn());
+        let { patterns, block } = c;
+        let pattern = patterns[0];
+        const indent = block.expressions?.[0]?.[0] || "";
+        const alternativeConditions = patterns.map((pattern2, i2) => {
+          const conditions = [];
+          getPatternConditions(pattern2, ref, conditions, getRef);
+          return conditions;
+        });
+        const conditionExpression = alternativeConditions.map((conditions, i2) => {
+          const conditionArray = conditions.map((c2, i3) => {
+            if (i3 === 0)
+              return c2;
+            return [" && ", ...c2];
+          });
+          if (i2 === 0)
+            return conditionArray;
+          return [" || ", ...conditionArray];
+        });
+        const condition2 = {
+          type: "ParenthesizedExpression",
+          children: ["(", ...refAssignment, conditionExpression, ")"],
+          expression: conditionExpression
+        };
+        const prefix = [];
+        switch (pattern.type) {
+          case "ArrayBindingPattern":
+            if (pattern.length === 0)
+              break;
+          case "ObjectBindingPattern": {
+            if (pattern.properties?.length === 0)
+              break;
+            let [splices, thisAssignments] = gatherBindingCode(pattern);
+            const patternBindings = nonMatcherBindings(pattern);
+            splices = splices.map((s2) => [", ", nonMatcherBindings(s2)]);
+            thisAssignments = thisAssignments.map((a) => [indent, a, ";"]);
+            const duplicateDeclarations = aggregateDuplicateBindings([patternBindings, splices], ReservedWord);
+            prefix.push([indent, "const ", patternBindings, " = ", ref, splices, ";"]);
+            prefix.push(...thisAssignments);
+            prefix.push(...duplicateDeclarations.map((d) => [indent, d, ";"]));
+            break;
+          }
         }
-        return;
-      case "DefaultClause":
-        insertReturn(node.block);
-        return;
-    }
-    if (!Array.isArray(node))
-      return;
-    let [, exp, semi] = node;
-    if (semi?.type === "SemicolonDelimiter") {
-      return;
-    }
-    if (!exp) {
-      return;
-    }
-    if (isExit(exp)) {
-      return;
-    }
-    const outer = exp;
-    let { type } = exp;
-    if (type === "LabelledStatement") {
-      exp = exp.statement;
-      ({ type } = exp);
-    }
-    switch (type) {
-      case "BreakStatement":
-      case "ContinueStatement":
-      case "DebuggerStatement":
-      case "EmptyStatement":
-      case "ReturnStatement":
-      case "ThrowStatement":
-        return;
-      case "Declaration":
-        exp.children.push(["", {
-          type: "ReturnStatement",
-          children: [";return ", patternAsValue(exp.bindings.at(-1).pattern)],
-          parent: exp
+        block.expressions.unshift(...prefix);
+        const next = [];
+        braceBlock(block);
+        if (i < l - 1)
+          next.push("\n", "else ");
+        prev.push(["", {
+          type: "IfStatement",
+          children: ["if", condition2, block, next],
+          then: block,
+          else: next,
+          hoistDec
         }]);
-        return;
-      case "FunctionExpression":
-        if (exp.id) {
-          exp.children.push([
-            "",
-            {
-              type: "ReturnStatement",
-              children: [";return ", exp.id],
-              parent: exp
+        hoistDec = void 0;
+        refAssignment = [];
+        return prev = next;
+      });
+      s.type = "PatternMatchingStatement";
+      s.children = [root];
+      return addParentPointers(s, s.parent);
+    });
+  }
+  function getPatternConditions(pattern, ref, conditions, getRef) {
+    if (pattern.rest)
+      return;
+    switch (pattern.type) {
+      case "ArrayBindingPattern": {
+        const { elements, length } = pattern, hasRest = elements.some((e) => e.rest), l = (length - hasRest).toString(), lengthCheck = hasRest ? [ref, ".length >= ", l] : [getRef("len"), "(", ref, ", ", l, ")"];
+        conditions.push(
+          ["Array.isArray(", ref, ")"],
+          lengthCheck
+        );
+        elements.forEach(({ children: [, e] }, i) => {
+          const subRef = [ref, "[", i.toString(), "]"];
+          return getPatternConditions(e, subRef, conditions, getRef);
+        });
+        const { blockPrefix } = pattern;
+        if (blockPrefix) {
+          const postElements = blockPrefix.children[1], { length: postLength } = postElements;
+          postElements.forEach(({ children: [, e] }, i) => {
+            const subRef = [ref, "[", ref, ".length - ", (postLength + i).toString(), "]"];
+            return getPatternConditions(e, subRef, conditions, getRef);
+          });
+        }
+        break;
+      }
+      case "ObjectBindingPattern": {
+        conditions.push(
+          ["typeof ", ref, " === 'object'"],
+          [ref, " != null"]
+        );
+        pattern.properties.forEach((p) => {
+          switch (p.type) {
+            case "PinProperty":
+            case "BindingProperty": {
+              const { name, value } = p;
+              let subRef;
+              switch (name.type) {
+                case "ComputedPropertyName":
+                  conditions.push([name.expression, " in ", ref]);
+                  subRef = [ref, name];
+                  break;
+                case "Literal":
+                case "StringLiteral":
+                case "NumericLiteral":
+                  conditions.push([name, " in ", ref]);
+                  subRef = [ref, "[", name, "]"];
+                  break;
+                default:
+                  conditions.push(["'", name, "' in ", ref]);
+                  subRef = [ref, ".", name];
+              }
+              if (value) {
+                getPatternConditions(value, subRef, conditions, getRef);
+              }
+              break;
             }
-          ]);
-          return;
+          }
+        });
+        break;
+      }
+      case "ConditionFragment": {
+        let { children } = pattern;
+        if (children.length) {
+          let [first, ...rest] = children;
+          let [ws, ...op] = first;
+          ws = [" "].concat(ws);
+          first = [ws, ...op];
+          children = [first, ...rest];
         }
+        conditions.push(
+          processBinaryOpExpression([ref, children])
+        );
+        break;
+      }
+      case "RegularExpressionLiteral": {
+        conditions.push(
+          ["typeof ", ref, " === 'string'"],
+          [pattern, ".test(", ref, ")"]
+        );
+        break;
+      }
+      case "PinPattern":
+        conditions.push([
+          ref,
+          " === ",
+          pattern.expression
+        ]);
+        break;
+      case "Literal":
+        conditions.push([
+          ref,
+          " === ",
+          pattern
+        ]);
+        break;
+      default:
         break;
-      case "ForStatement":
-      case "IterationStatement":
-      case "DoStatement":
-        wrapIterationReturningResults(exp, outer);
-        return;
-      case "BlockStatement":
-        insertReturn(exp.expressions[exp.expressions.length - 1]);
-        return;
-      case "IfStatement":
-        insertReturn(exp.then);
-        if (exp.else && exp.else.length !== 0)
-          insertReturn(exp.else[2]);
-        else
-          exp.children.push(["", {
-            type: "ReturnStatement",
-            // NOTE: add a prefixed semi-colon because the if block may not be braced
-            children: [";return"],
-            parent: exp
-          }]);
-        return;
-      case "PatternMatchingStatement":
-        insertReturn(exp.children[0][0]);
-        return;
-      case "SwitchStatement":
-        insertSwitchReturns(exp);
-        return;
-      case "TryStatement":
-        exp.blocks.forEach((block) => insertReturn(block));
-        return;
     }
-    if (node[node.length - 1]?.type === "SemicolonDelimiter")
-      return;
-    const returnStatement = wrapWithReturn(node[1]);
-    node.splice(1, 1, returnStatement);
   }
-  function insertSwitchReturns(exp) {
-    exp.caseBlock.clauses.forEach((clause) => {
-      return insertReturn(clause);
+  function elideMatchersFromArrayBindings(elements) {
+    return elements.map((el) => {
+      if (el.type === "BindingRestElement") {
+        return ["", el, void 0];
+      }
+      const { children: [ws, e, delim] } = el;
+      switch (e.type) {
+        case "Literal":
+        case "RegularExpressionLiteral":
+        case "StringLiteral":
+        case "PinPattern":
+          return delim;
+        default:
+          return [ws, nonMatcherBindings(e), delim];
+      }
     });
   }
-  function wrapIterationReturningResults(statement, outer, collect) {
-    if (statement.type === "DoStatement") {
-      if (collect) {
-        assignResults(statement.block, collect);
-      } else {
-        insertReturn(statement.block, outer);
+  function elideMatchersFromPropertyBindings(properties) {
+    return properties.map((p) => {
+      switch (p.type) {
+        case "BindingProperty": {
+          const { children, name, value } = p;
+          const [ws] = children;
+          switch (value && value.type) {
+            case "ArrayBindingPattern":
+            case "ObjectBindingPattern":
+              return {
+                ...p,
+                children: [ws, name, ": ", nonMatcherBindings(value), p.delim]
+              };
+            case "Identifier":
+              return p;
+            case "Literal":
+            case "RegularExpressionLiteral":
+            case "StringLiteral":
+            default:
+              return {
+                ...p,
+                children: [ws, name, p.delim]
+              };
+          }
+        }
+        case "PinProperty":
+        case "BindingRestProperty":
+        default:
+          return p;
       }
-      return;
-    }
-    assert.equal(
-      statement.resultsRef,
-      void 0,
-      "wrapIterationReturningResults should not be called twice on the same statement"
-    );
-    const resultsRef = statement.resultsRef = makeRef("results");
-    const declaration = {
-      type: "Declaration",
-      children: ["const ", resultsRef, "=[]"]
-    };
-    outer.children.unshift(["", declaration, ";"]);
-    assignResults(statement.block, (node) => {
-      return [resultsRef, ".push(", node, ")"];
     });
-    if (collect) {
-      statement.children.push(collect(resultsRef));
-    } else {
-      statement.children.push(";return ", resultsRef, ";");
-    }
   }
-  function processParams(f) {
-    const { type, parameters, block } = f;
-    const isConstructor = f.name === "constructor";
-    if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
-      parameters.tp.parameters.push(",");
-    }
-    if (!block)
-      return;
-    const { expressions } = block;
-    if (!expressions)
-      return;
-    const { blockPrefix } = parameters;
-    let indent;
-    if (!expressions.length) {
-      indent = "";
-    } else {
-      indent = expressions[0][0];
-    }
-    const [splices, thisAssignments] = gatherBindingCode(parameters, {
-      injectParamProps: isConstructor
-    });
-    const delimiter = {
-      type: "SemicolonDelimiter",
-      children: [";"]
-    };
-    const prefix = splices.map((s) => ["let ", s]).concat(thisAssignments).map(
-      (s) => s.type ? {
-        // TODO: figure out how to get JS only statement tuples
-        ...s,
-        children: [indent, ...s.children, delimiter]
-      } : [indent, s, delimiter]
-    );
-    if (!prefix.length)
-      return;
-    if (isConstructor) {
-      const superCalls = gatherNodes(expressions, (exp) => {
-        return exp.type === "CallExpression" && exp.children[0]?.token === "super";
-      });
-      if (superCalls.length) {
-        const { child } = findAncestor(
-          superCalls[0],
-          (ancestor) => ancestor === block
-        );
-        const index = findChildIndex(expressions, child);
-        if (index < 0) {
-          throw new Error("Could not find super call within top-level expressions");
-        }
-        expressions.splice(index + 1, 0, ...prefix);
-        return;
+  function nonMatcherBindings(pattern) {
+    switch (pattern.type) {
+      case "ArrayBindingPattern": {
+        const elements = elideMatchersFromArrayBindings(pattern.elements);
+        const children = ["[", elements, "]"];
+        return {
+          ...pattern,
+          children,
+          elements
+        };
+      }
+      case "PostRestBindingElements": {
+        const els = elideMatchersFromArrayBindings(pattern.children[1]);
+        return {
+          ...pattern,
+          children: [
+            pattern.children[0],
+            els,
+            ...pattern.children.slice(2)
+          ]
+        };
       }
+      case "ObjectBindingPattern":
+        return ["{", elideMatchersFromPropertyBindings(pattern.properties), "}"];
+      default:
+        return pattern;
     }
-    expressions.unshift(...prefix);
   }
-  function processFunctions(statements, config) {
-    gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
-      if (f.type === "FunctionExpression")
-        implicitFunctionBlock(f);
-      processParams(f);
-      return processReturn(f, config.implicitReturns);
-    });
-    gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
-      implicitFunctionBlock(f);
-      processParams(f);
-      return processReturn(f, config.implicitReturns);
+  function aggregateDuplicateBindings(bindings, ReservedWord) {
+    const props = gatherRecursiveAll(bindings, ($2) => $2.type === "BindingProperty");
+    const arrayBindings = gatherRecursiveAll(bindings, ($3) => $3.type === "ArrayBindingPattern");
+    arrayBindings.forEach((a) => {
+      const { elements } = a;
+      return elements.forEach((element) => {
+        if (Array.isArray(element)) {
+          const [, e] = element;
+          if (e.type === "Identifier") {
+            return props.push(e);
+          } else if (e.type === "BindingRestElement") {
+            return props.push(e);
+          }
+          ;
+          return;
+        }
+        ;
+        return;
+      });
     });
-  }
-  function expressionizeIteration(exp) {
-    const { async, subtype, block, children, statement } = exp;
-    const i = children.indexOf(statement);
-    if (i < 0) {
-      throw new Error("Could not find iteration statement in iteration expression");
-    }
-    if (subtype === "DoStatement") {
-      children.splice(i, 1, ...wrapIIFE([["", statement, void 0]], async));
-      updateParentPointers(exp);
-      return;
+    const declarations = [];
+    const propsGroupedByName = /* @__PURE__ */ new Map();
+    for (const p of props) {
+      const { name, value } = p;
+      const key = value?.name || name?.name || name;
+      if (propsGroupedByName.has(key)) {
+        propsGroupedByName.get(key).push(p);
+      } else {
+        propsGroupedByName.set(key, [p]);
+      }
     }
-    exp.resultsRef ??= makeRef("results");
-    const { resultsRef } = exp;
-    assignResults(block, (node) => {
-      return [resultsRef, ".push(", node, ")"];
+    propsGroupedByName.forEach((shared, key) => {
+      if (!key) {
+        return;
+      }
+      if (ReservedWord({ fail() {
+      } }, {
+        pos: 0,
+        input: key
+      })) {
+        shared.forEach((p) => {
+          return aliasBinding(p, makeRef(`_${key}`, key));
+        });
+        return;
+      }
+      if (shared.length === 1) {
+        return;
+      }
+      const refs = shared.map((p) => {
+        const ref = makeRef(key);
+        aliasBinding(p, ref);
+        return ref;
+      });
+      return declarations.push(["const ", key, " = [", ...refs.map((r, i) => {
+        return i === 0 ? r : [", ", r];
+      }), "]"]);
     });
-    braceBlock(block);
-    children.splice(
-      i,
-      1,
-      ...wrapIIFE([
-        ["", ["const ", resultsRef, "=[]"], ";"],
-        ...children.map((c) => ["", c, void 0]),
-        ["", wrapWithReturn(resultsRef)]
-      ], async)
-    );
-    updateParentPointers(exp);
+    return declarations;
   }
-  function skipImplicitArguments(args) {
-    if (args.length === 1) {
-      let arg0 = args[0];
-      if (arg0.type === "StatementExpression") {
-        arg0 = arg0.statement;
-      }
-      return arg0.type === "IterationExpression" && arg0.subtype !== "DoStatement" && !arg0.async && isEmptyBareBlock(arg0.block);
+  function aliasBinding(p, ref) {
+    if (p.type === "Identifier") {
+      p.children[0] = ref;
+    } else if (p.type === "BindingRestElement") {
+      aliasBinding(p.binding, ref);
+    } else if (p.value?.type === "Identifier") {
+      aliasBinding(p.value, ref);
+    } else {
+      p.value = ref;
+      const index = p.children.indexOf(p.name);
+      p.children.splice(index + 1, 0, ": ", ref);
     }
-    return false;
   }
-  var init_function = __esm({
-    "source/parser/function.civet"() {
+  var init_pattern_matching = __esm({
+    "source/parser/pattern-matching.civet"() {
       "use strict";
-      init_block();
-      init_binding();
       init_traversal();
       init_util();
+      init_block();
+      init_binding();
+      init_op();
     }
   });
 
@@ -2323,7 +2266,7 @@ var Civet = (() => {
     const thisAssignments = assignments.map((a) => ["", a, ";"]);
     const initializer = makeNode({
       type: "Initializer",
-      exp: e,
+      expression: e,
       children: [ws, assign, e]
     });
     const binding = makeNode({
@@ -2364,7 +2307,7 @@ var Civet = (() => {
     });
   }
   function prependStatementExpressionBlock(initializer, statement) {
-    let { exp } = initializer;
+    let { expression: exp } = initializer;
     let ws;
     if (Array.isArray(exp)) {
       ws = exp[0];
@@ -2384,7 +2327,7 @@ var Civet = (() => {
       const statement2 = statementExp.statement;
       blockStatement[1] = statement2;
       if (statement2.type === "DoStatement") {
-        ref = initializer.exp = initializer.children[2] = makeRef();
+        ref = initializer.expression = initializer.children[2] = makeRef();
         assignResults(blockStatement, (resultNode) => {
           return makeNode({
             type: "AssignmentExpression",
@@ -2400,10 +2343,10 @@ var Civet = (() => {
       } else {
         wrapIterationReturningResults(statement2, { children: blockStatement }, function() {
         });
-        ref = initializer.exp = initializer.children[2] = statement2.resultsRef;
+        ref = initializer.expression = initializer.children[2] = statement2.resultsRef;
       }
     } else {
-      ref = initializer.exp = initializer.children[2] = makeRef();
+      ref = initializer.expression = initializer.children[2] = makeRef();
       assignResults(blockStatement, (resultNode) => {
         return makeNode({
           type: "AssignmentExpression",
@@ -2602,7 +2545,7 @@ var Civet = (() => {
       }
     })();
     const c = "const";
-    const exp = [
+    const expression = [
       justDefault ? "(" : void 0,
       { type: "Await", children: ["await"] },
       " ",
@@ -2613,8 +2556,8 @@ var Civet = (() => {
     ];
     const initializer = {
       type: "Initializer",
-      exp,
-      children: [" ", "= ", exp]
+      expression,
+      children: [" ", "= ", expression]
     };
     const bindings = [{
       type: "Binding",
@@ -2631,7 +2574,7 @@ var Civet = (() => {
       ];
       const initializer2 = {
         type: "Initializer",
-        exp,
+        expression,
         children: [" ", "= ", exp2]
       };
       bindings.push({
@@ -2644,7 +2587,7 @@ var Civet = (() => {
       const pattern3 = convertNamedImportsToObject(imports.children.at(-1), true);
       const initializer3 = {
         type: "Initializer",
-        exp: pattern,
+        expression: pattern,
         children: [" ", "= ", pattern]
       };
       bindings.push({
@@ -2702,6 +2645,97 @@ var Civet = (() => {
     }
   });
 
+  // source/parser/unary.civet
+  function processUnaryExpression(pre, exp, post) {
+    if (!(pre.length || post))
+      return exp;
+    if (post?.token === "?") {
+      post = {
+        $loc: post.$loc,
+        token: " != null"
+      };
+      if (pre.length) {
+        const lastPre = pre.at(-1);
+        if (lastPre.token === "!") {
+          post.token = " == null";
+          pre = pre.slice(0, -1);
+        } else if (lastPre.length === 2 && lastPre[0].token === "!") {
+          post.token = " == null";
+          pre = pre.slice(0, -1);
+        }
+      }
+      const existence = {
+        type: "Existence",
+        expression: exp,
+        children: [exp, post],
+        parent: void 0
+      };
+      exp = makeLeftHandSideExpression(existence);
+      if (pre.length) {
+        return {
+          type: "UnaryExpression",
+          children: [...pre, exp]
+        };
+      }
+      return exp;
+    }
+    if (exp.type === "Literal") {
+      if (pre.length === 1) {
+        const { token } = pre[0];
+        if (token === "-" || token === "+") {
+          const children = [pre[0], ...exp.children];
+          const literal = {
+            type: "Literal",
+            children,
+            raw: `${token}${exp.raw}`
+          };
+          if (post) {
+            return {
+              type: "UnaryExpression",
+              children: [literal, post]
+            };
+          }
+          return literal;
+        }
+      }
+    }
+    let ref;
+    while (ref = pre.length) {
+      const l = ref;
+      const last = pre[l - 1];
+      if (last.type === "Await") {
+        if (last.op) {
+          if (exp.type !== "ParenthesizedExpression") {
+            exp = ["(", exp, ")"];
+          }
+          exp = {
+            type: "CallExpression",
+            children: [...last.children, "Promise", last.op, exp]
+          };
+          pre = pre.slice(0, -1);
+        } else {
+          exp = {
+            type: "AwaitExpression",
+            children: [...last.children, exp]
+          };
+          pre = pre.slice(0, -1);
+        }
+      } else {
+        break;
+      }
+    }
+    return {
+      type: "UnaryExpression",
+      children: [...pre, exp, post]
+    };
+  }
+  var init_unary = __esm({
+    "source/parser/unary.civet"() {
+      "use strict";
+      init_util();
+    }
+  });
+
   // source/parser/pipe.civet
   function constructInvocation(fn, arg) {
     const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
@@ -2828,7 +2862,7 @@ var Civet = (() => {
               names: null,
               lhs,
               assigned: arg,
-              exp: children
+              expression: children
             });
             arg = clone(arg);
             removeHoistDecs(arg);
@@ -3204,7 +3238,7 @@ var Civet = (() => {
     scopes.pop();
     statements.splice(0, statements.length, ...targetStatements);
   }
-  function createVarDecs(statements, scopes, pushVar) {
+  function createVarDecs(block, scopes, pushVar) {
     function hasDec(name) {
       return scopes.some((s) => s.has(name));
     }
@@ -3223,6 +3257,7 @@ var Civet = (() => {
         return decs.add(name);
       };
     }
+    const { expressions: statements } = block;
     const decs = findDecs(statements);
     scopes.push(decs);
     const varIds = [];
@@ -3236,19 +3271,19 @@ var Civet = (() => {
     const fnNodes = gatherNodes(statements, isFunction);
     const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
     const blockNodes = new Set(gatherNodes(statements, (s) => s.type === "BlockStatement"));
-    fnNodes.forEach(({ block }) => blockNodes.delete(block));
-    forNodes.forEach(({ block }) => blockNodes.delete(block));
-    blockNodes.forEach((block) => {
-      return createVarDecs(block.expressions, scopes, pushVar);
+    fnNodes.forEach(({ block: block2 }) => blockNodes.delete(block2));
+    forNodes.forEach(({ block: block2 }) => blockNodes.delete(block2));
+    blockNodes.forEach((block2) => {
+      return createVarDecs(block2, scopes, pushVar);
     });
-    forNodes.forEach(({ block, declaration }) => {
+    forNodes.forEach(({ block: block2, declaration }) => {
       scopes.push(new Set(declaration.names));
-      createVarDecs(block.expressions, scopes, pushVar);
+      createVarDecs(block2, scopes, pushVar);
       return scopes.pop();
     });
-    fnNodes.forEach(({ block, parameters }) => {
+    fnNodes.forEach(({ block: block2, parameters }) => {
       scopes.push(new Set(parameters.names));
-      createVarDecs(block.expressions, scopes);
+      createVarDecs(block2, scopes);
       return scopes.pop();
     });
     if (varIds.length) {
@@ -3257,6 +3292,7 @@ var Civet = (() => {
       if (statements[0][1]?.parent?.root) {
         delimiter = ";\n";
       }
+      braceBlock(block);
       statements.unshift([indent, {
         type: "Declaration",
         children: ["var ", varIds.join(", ")]
@@ -3680,7 +3716,7 @@ var Civet = (() => {
           2,
           commaCount ? {
             type: "ParenthesizedExpression",
-            children: ["(", call, ")"]
+            children: ["(", ...call.children, ")"]
           } : { ...call, type: "ParenthesizedExpression" }
         );
       }
@@ -4100,13 +4136,13 @@ var Civet = (() => {
       statements,
       (n) => n.type === "AssignmentExpression" && n.names === null,
       (exp) => {
-        let { lhs: $1, exp: $2 } = exp, tail = [], i = 0, len = $1.length;
+        let { lhs: $1, expression: $2 } = exp, tail = [], i = 0, len = $1.length;
         let block;
         if (exp.parent?.type === "BlockStatement" && !$1.at(-1)?.at(-1)?.special) {
           block = makeBlockFragment();
           let ref4;
           if (ref4 = prependStatementExpressionBlock(
-            { type: "Initializer", exp: $2, children: [void 0, void 0, $2] },
+            { type: "Initializer", expression: $2, children: [void 0, void 0, $2] },
             block
           )) {
             const ref = ref4;
@@ -4132,7 +4168,7 @@ var Civet = (() => {
           exp.children.splice(
             index2,
             1,
-            exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
+            exp.expression = $2 = [call, "(", lhs, ", ", $2, ")"]
           );
           if (omitLhs) {
             return $2;
@@ -4449,7 +4485,7 @@ var Civet = (() => {
     } else if (config.autoConst) {
       createConstLetDecs(statements, [], "const");
     } else if (config.autoVar) {
-      createVarDecs(statements, []);
+      createVarDecs(root, []);
     }
     processBlocks(statements);
     populateRefs(statements);
@@ -4500,7 +4536,7 @@ var Civet = (() => {
           const { type } = ancestor2;
           return type === "Call" || type === "BlockStatement" || type === "PipelineExpression" || // Declaration
           type === "Initializer" || // Right-hand side of assignment
-          type === "AssignmentExpression" && ancestor2.exp === child2;
+          type === "AssignmentExpression" && ancestor2.expression === child2 || type === "ReturnStatement" || type === "YieldExpression";
         }));
         switch (ancestor?.type) {
           case "Call": {
@@ -4540,11 +4576,13 @@ var Civet = (() => {
             break;
           }
           case "AssignmentExpression":
-          case "Initializer": {
+          case "Initializer":
+          case "ReturnStatement":
+          case "YieldExpression": {
             const i = findChildIndex(ancestor, child);
-            if (i >= 0 && ancestor.exp === ancestor.children[i]) {
-              ancestor.exp = ancestor.children[i] = maybeWrap(ancestor.exp, ancestor);
-              ancestor = ancestor.exp;
+            if (i >= 0 && ancestor.expression === ancestor.children[i]) {
+              ancestor.expression = ancestor.children[i] = maybeWrap(ancestor.expression, ancestor);
+              ancestor = ancestor.expression;
             } else {
               ancestor = void 0;
             }
@@ -4595,8 +4633,10 @@ var Civet = (() => {
           break;
         }
         case "AssignmentExpression":
-        case "Initializer": {
-          outer = ancestor === parent.exp;
+        case "Initializer":
+        case "ReturnStatement":
+        case "YieldExpression": {
+          outer = ancestor === parent.expression;
           break;
         }
       }
@@ -5344,7 +5384,6 @@ ${input.slice(result.pos)}
         ActualAssignment,
         NonPipelineActualAssignment,
         YieldExpression,
-        YieldTail,
         ArrowFunction,
         FatArrow,
         TrailingDeclaration,
@@ -6956,7 +6995,7 @@ ${input.slice(result.pos)}
           names: null,
           lhs: $1,
           assigned: $1[0][1],
-          exp: $2
+          expression: $2
         };
       });
       function ActualAssignment(ctx, state) {
@@ -6973,22 +7012,30 @@ ${input.slice(result.pos)}
           names: null,
           lhs: $1,
           assigned: $1[0][1],
-          exp: $2
+          expression: $2
         };
       });
       function NonPipelineActualAssignment(ctx, state) {
         return $EVENT(ctx, state, "NonPipelineActualAssignment", NonPipelineActualAssignment$0);
       }
-      var YieldExpression$0 = $S(Yield, YieldTail);
+      var YieldExpression$0 = $TS($S(Yield, $E($S($E($S($E(_), Star)), MaybeNestedExpression))), function($skip, $loc, $0, $1, $2) {
+        if ($2) {
+          const [star, expression] = $2;
+          return {
+            type: "YieldExpression",
+            star,
+            expression,
+            children: [$1, star, expression]
+          };
+        }
+        return {
+          type: "YieldExpression",
+          children: [$1]
+        };
+      });
       function YieldExpression(ctx, state) {
         return $EVENT(ctx, state, "YieldExpression", YieldExpression$0);
       }
-      var YieldTail$0 = $Y(EOS);
-      var YieldTail$1 = $S($E($S($E(_), Star)), AssignmentExpression);
-      var YieldTail$$ = [YieldTail$0, YieldTail$1];
-      function YieldTail(ctx, state) {
-        return $EVENT_C(ctx, state, "YieldTail", YieldTail$$);
-      }
       var ArrowFunction$0 = ThinArrowFunction;
       var ArrowFunction$1 = $TS($S($E($S(Async, _)), ArrowParameters, $E(ReturnTypeSuffix), FatArrow, FatArrowBody), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var async = $1;
@@ -8708,66 +8755,66 @@ ${input.slice(result.pos)}
         var op = $4;
         var ws2 = $5;
         var close = $6;
-        const refB = makeRef("b"), body = processBinaryOpExpression([lhs, [
-          [ws1, op, ws2, refB]
-          // BinaryOpRHS
-        ]]);
-        const parameters = {
-          type: "Parameters",
-          children: ["(", refB, ")"],
-          names: []
-        };
-        const block = {
-          expressions: [body]
-        };
+        const refB = makeRef("b");
+        const fn = makeAmpersandFunction({
+          ref: refB,
+          body: processBinaryOpExpression([lhs, [
+            [ws1, op, ws2, refB]
+            // BinaryOpRHS
+          ]])
+        });
         return {
-          type: "ArrowFunction",
-          signature: {
-            modifier: {}
-          },
-          children: [open, parameters, " => ", body, close],
-          body,
-          parenthesized: true,
-          ampersandBlock: true,
+          type: "ParenthesizedExpression",
+          children: [open, fn, close],
+          expression: fn
+        };
+      });
+      var FunctionExpression$3 = $TS($S(OpenParen, $P($S(NotDedented, UpdateExpression, WAssignmentOp)), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var open = $1;
+        var lhs = $2;
+        var ws2 = $3;
+        var close = $4;
+        lhs = lhs.map((x) => [x[0], x[1], ...x[2]]);
+        const refB = makeRef("b");
+        const fn = makeAmpersandFunction({
           ref: refB,
-          block,
-          parameters
+          body: {
+            type: "AssignmentExpression",
+            children: [lhs, ws2, refB],
+            names: null,
+            lhs,
+            assigned: lhs[0][1],
+            expression: refB
+          }
+        });
+        return {
+          type: "ParenthesizedExpression",
+          children: [open, fn, close],
+          expression: fn
         };
       });
-      var FunctionExpression$3 = $TS($S(OpenParen, __, $N($EXPECT($R13, "FunctionExpression /\\+\\+|--|[\\+\\-&]\\S/")), BinaryOp, __, NonPipelineAssignmentExpression, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+      var FunctionExpression$4 = $TS($S(OpenParen, __, $N($EXPECT($R13, "FunctionExpression /\\+\\+|--|[\\+\\-&]\\S/")), BinaryOp, __, NonPipelineAssignmentExpression, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
         var open = $1;
         var ws1 = $2;
         var op = $4;
         var ws2 = $5;
         var rhs = $6;
         var close = $7;
-        const refA = makeRef("a"), body = processBinaryOpExpression([refA, [
-          [ws1, op, ws2, rhs]
-          // BinaryOpRHS
-        ]]);
-        const parameters = {
-          type: "Parameters",
-          children: ["(", refA, ")"],
-          names: []
-        };
-        const block = {
-          expressions: [body]
-        };
-        return {
-          type: "ArrowFunction",
-          signature: {
-            modifier: {}
-          },
-          children: [open, parameters, " => ", body, close],
-          body,
-          parenthesized: true,
-          ampersandBlock: true,
+        const refA = makeRef("a");
+        const fn = makeAmpersandFunction({
           ref: refA,
-          block,
-          parameters
+          body: processBinaryOpExpression([refA, [
+            [ws1, op, ws2, rhs]
+            // BinaryOpRHS
+          ]])
+        });
+        return {
+          type: "ParenthesizedExpression",
+          children: [open, fn, close],
+          expression: fn
         };
       });
-      var FunctionExpression$$ = [FunctionExpression$0, FunctionExpression$1, FunctionExpression$2, FunctionExpression$3];
+      var FunctionExpression$$ = [FunctionExpression$0, FunctionExpression$1, FunctionExpression$2, FunctionExpression$3, FunctionExpression$4];
       function FunctionExpression(ctx, state) {
         return $EVENT_C(ctx, state, "FunctionExpression", FunctionExpression$$);
       }
@@ -12339,8 +12386,8 @@ ${input.slice(result.pos)}
         return $EVENT_C(ctx, state, "LexicalBinding", LexicalBinding$$);
       }
       var Initializer$0 = $T($S(__, Equals, ExtendedExpression), function(value) {
-        var exp = value[2];
-        return { "type": "Initializer", "exp": exp, "children": value };
+        var expression = value[2];
+        return { "type": "Initializer", "expression": expression, "children": value };
       });
       function Initializer(ctx, state) {
         return $EVENT(ctx, state, "Initializer", Initializer$0);
@@ -15812,7 +15859,6 @@ ${input.slice(result.pos)}
       exports.ActualAssignment = ActualAssignment;
       exports.NonPipelineActualAssignment = NonPipelineActualAssignment;
       exports.YieldExpression = YieldExpression;
-      exports.YieldTail = YieldTail;
       exports.ArrowFunction = ArrowFunction;
       exports.FatArrow = FatArrow;
       exports.TrailingDeclaration = TrailingDeclaration;