@danielx/civet 0.7.0 → 0.7.1

package/dist/main.js

@@ -33,1061 +33,629 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 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();
   }
 });
@@ -1120,7 +688,13 @@ function braceBlock(block) {
     }
     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;
@@ -1294,1010 +868,1379 @@ var init_block = __esm({
     "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();
   }
 });
 
@@ -2315,7 +2258,7 @@ function processAssignmentDeclaration(decl, pattern, suffix, ws, assign, e) {
   const thisAssignments = assignments.map((a) => ["", a, ";"]);
   const initializer = makeNode({
     type: "Initializer",
-    exp: e,
+    expression: e,
     children: [ws, assign, e]
   });
   const binding = makeNode({
@@ -2356,7 +2299,7 @@ function processDeclarations(statements) {
   });
 }
 function prependStatementExpressionBlock(initializer, statement) {
-  let { exp } = initializer;
+  let { expression: exp } = initializer;
   let ws;
   if (Array.isArray(exp)) {
     ws = exp[0];
@@ -2376,7 +2319,7 @@ function prependStatementExpressionBlock(initializer, statement) {
     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",
@@ -2392,10 +2335,10 @@ function prependStatementExpressionBlock(initializer, statement) {
     } 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",
@@ -2594,7 +2537,7 @@ function dynamizeImportDeclaration(decl) {
     }
   })();
   const c = "const";
-  const exp = [
+  const expression = [
     justDefault ? "(" : void 0,
     { type: "Await", children: ["await"] },
     " ",
@@ -2605,8 +2548,8 @@ function dynamizeImportDeclaration(decl) {
   ];
   const initializer = {
     type: "Initializer",
-    exp,
-    children: [" ", "= ", exp]
+    expression,
+    children: [" ", "= ", expression]
   };
   const bindings = [{
     type: "Binding",
@@ -2623,7 +2566,7 @@ function dynamizeImportDeclaration(decl) {
     ];
     const initializer2 = {
       type: "Initializer",
-      exp,
+      expression,
       children: [" ", "= ", exp2]
     };
     bindings.push({
@@ -2636,7 +2579,7 @@ function dynamizeImportDeclaration(decl) {
     const pattern3 = convertNamedImportsToObject(imports.children.at(-1), true);
     const initializer3 = {
       type: "Initializer",
-      exp: pattern,
+      expression: pattern,
       children: [" ", "= ", pattern]
     };
     bindings.push({
@@ -2694,6 +2637,97 @@ var init_declaration = __esm({
   }
 });
 
+// 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];
@@ -2820,7 +2854,7 @@ function processPipelineExpressions(statements) {
             names: null,
             lhs,
             assigned: arg,
-            exp: children
+            expression: children
           });
           arg = clone(arg);
           removeHoistDecs(arg);
@@ -3196,7 +3230,7 @@ function createConstLetDecs(statements, scopes, letOrConst) {
   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));
   }
@@ -3215,6 +3249,7 @@ function createVarDecs(statements, scopes, pushVar) {
       return decs.add(name);
     };
   }
+  const { expressions: statements } = block;
   const decs = findDecs(statements);
   scopes.push(decs);
   const varIds = [];
@@ -3228,19 +3263,19 @@ function createVarDecs(statements, scopes, pushVar) {
   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) {
@@ -3249,6 +3284,7 @@ function createVarDecs(statements, scopes, pushVar) {
     if (statements[0][1]?.parent?.root) {
       delimiter = ";\n";
     }
+    braceBlock(block);
     statements.unshift([indent, {
       type: "Declaration",
       children: ["var ", varIds.join(", ")]
@@ -3672,7 +3708,7 @@ function processCallMemberExpression(node) {
         2,
         commaCount ? {
           type: "ParenthesizedExpression",
-          children: ["(", call, ")"]
+          children: ["(", ...call.children, ")"]
         } : { ...call, type: "ParenthesizedExpression" }
       );
     }
@@ -4092,13 +4128,13 @@ function processAssignments(statements) {
     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;
@@ -4124,7 +4160,7 @@ function processAssignments(statements) {
         exp.children.splice(
           index2,
           1,
-          exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
+          exp.expression = $2 = [call, "(", lhs, ", ", $2, ")"]
         );
         if (omitLhs) {
           return $2;
@@ -4441,7 +4477,7 @@ function processProgram(root, config, m, ReservedWord) {
   } else if (config.autoConst) {
     createConstLetDecs(statements, [], "const");
   } else if (config.autoVar) {
-    createVarDecs(statements, []);
+    createVarDecs(root, []);
   }
   processBlocks(statements);
   populateRefs(statements);
@@ -4492,7 +4528,7 @@ function processPlaceholders(statements) {
         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": {
@@ -4532,11 +4568,13 @@ function processPlaceholders(statements) {
           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;
           }
@@ -4587,8 +4625,10 @@ function processPlaceholders(statements) {
         break;
       }
       case "AssignmentExpression":
-      case "Initializer": {
-        outer = ancestor === parent.exp;
+      case "Initializer":
+      case "ReturnStatement":
+      case "YieldExpression": {
+        outer = ancestor === parent.expression;
         break;
       }
     }
@@ -5336,7 +5376,6 @@ var require_parser = __commonJS({
       ActualAssignment,
       NonPipelineActualAssignment,
       YieldExpression,
-      YieldTail,
       ArrowFunction,
       FatArrow,
       TrailingDeclaration,
@@ -6948,7 +6987,7 @@ var require_parser = __commonJS({
         names: null,
         lhs: $1,
         assigned: $1[0][1],
-        exp: $2
+        expression: $2
       };
     });
     function ActualAssignment(ctx, state) {
@@ -6965,22 +7004,30 @@ var require_parser = __commonJS({
         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;
@@ -8700,66 +8747,66 @@ var require_parser = __commonJS({
       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$$);
     }
@@ -12331,8 +12378,8 @@ var require_parser = __commonJS({
       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);
@@ -15804,7 +15851,6 @@ var require_parser = __commonJS({
     exports2.ActualAssignment = ActualAssignment;
     exports2.NonPipelineActualAssignment = NonPipelineActualAssignment;
     exports2.YieldExpression = YieldExpression;
-    exports2.YieldTail = YieldTail;
     exports2.ArrowFunction = ArrowFunction;
     exports2.FatArrow = FatArrow;
     exports2.TrailingDeclaration = TrailingDeclaration;