@danielx/civet 0.6.82 → 0.6.84

package/dist/main.mjs

@@ -268,27 +268,25 @@ function makeLeftHandSideExpression(expression) {
     return expression;
   }
   switch (expression.type) {
-    case "Ref":
     case "AmpersandRef":
+    case "CallExpression":
     case "Identifier":
+    case "JSXElement":
+    case "JSXFragment":
     case "Literal":
-    case "IterationExpression":
-    case "CallExpression":
     case "MemberExpression":
     case "NewExpression":
     case "ParenthesizedExpression":
-    case "IfExpression":
-    case "DebuggerExpression":
-    case "SwitchExpression":
-    case "ThrowExpression":
-    case "TryExpression":
+    case "Ref":
+    case "StatementExpression":
       return expression;
   }
   return makeNode({
     type: "ParenthesizedExpression",
     children: ["(", expression, ")"],
     expression,
-    implicit: true
+    implicit: true,
+    parent: void 0
   });
 }
 function updateParentPointers(node, parent, depth = 1) {
@@ -403,7 +401,9 @@ function wrapIIFE(expressions, async) {
     type: "BlockStatement",
     expressions,
     children: ["{", expressions, "}"],
-    bare: false
+    bare: false,
+    root: false,
+    parent: void 0
   });
   const parameters = {
     type: "Parameters",
@@ -442,11 +442,18 @@ function wrapWithReturn(expression) {
     children
   });
 }
-var typeNeedsNoParens;
+var assert, typeNeedsNoParens;
 var init_util = __esm({
   "source/parser/util.civet"() {
     "use strict";
     init_traversal();
+    assert = {
+      equal(a, b, msg) {
+        if (a !== b) {
+          throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`);
+        }
+      }
+    };
     typeNeedsNoParens = /* @__PURE__ */ new Set([
       "IdentifierType",
       "ImportType",
@@ -606,6 +613,17 @@ function makeEmptyBlock() {
     empty: true
   };
 }
+function makeBlockFragment() {
+  const expressions = [];
+  return {
+    type: "BlockStatement",
+    children: expressions,
+    parent: void 0,
+    expressions,
+    bare: false,
+    root: false
+  };
+}
 function replaceBlockExpression(node, child, replacement) {
   let found = false;
   const { expressions } = node;
@@ -737,816 +755,1092 @@ var init_block = __esm({
   }
 });
 
-// source/parser/pipe.civet
-function constructInvocation(fn, arg) {
-  const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
-  let expr = fn.expr;
-  while (expr.type === "ParenthesizedExpression") {
-    expr = expr.expression;
-  }
-  if (expr.ampersandBlock) {
-    const { ref, body } = expr;
-    ref.type = "PipedExpression";
-    ref.children = [makeLeftHandSideExpression(arg)];
-    updateParentPointers(ref);
-    return makeNode({
-      type: "UnwrappedExpression",
-      children: [skipIfOnlyWS(fn.leadingComment), body, skipIfOnlyWS(fn.trailingComment)]
-    });
-  }
-  expr = fn.expr;
-  const lhs = makeLeftHandSideExpression(expr);
-  let comment = skipIfOnlyWS(fn.trailingComment);
-  if (comment)
-    lhs.children.splice(2, 0, comment);
-  comment = skipIfOnlyWS(fn.leadingComment);
-  if (comment)
-    lhs.children.splice(1, 0, comment);
-  switch (arg.type) {
-    case "CommaExpression":
-      arg = makeLeftHandSideExpression(arg);
-      break;
+// 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, ": ");
+    }
+    ;
+    return;
+  });
+}
+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;
+  });
+  if (restCount === 0) {
+    return {
+      children: elements,
+      names,
+      blockPrefix,
+      length
+    };
+  } 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 {
+      names,
+      children: [...elements.slice(0, restIndex), {
+        ...rest,
+        children: rest.children.slice(0, -1)
+        // remove trailing comma
+      }],
+      blockPrefix,
+      length
+    };
   }
+  const err = {
+    type: "Error",
+    children: ["Multiple rest elements in array pattern"]
+  };
   return {
-    type: "CallExpression",
-    children: [lhs, "(", arg, ")"]
+    names,
+    children: [...elements, err],
+    blockPrefix,
+    length
   };
 }
-function constructPipeStep(fn, arg, returning) {
-  const children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(skipIfOnlyWS), " ", arg];
-  switch (fn.expr.token) {
-    case "yield":
-    case "await":
-      if (returning) {
-        return [
-          children,
-          returning
-        ];
+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 [
-        children,
-        null
-      ];
-    case "return":
-      return [{
-        type: "ReturnStatement",
-        children
-      }, null];
+      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);
+    });
   }
-  if (returning) {
-    return [
-      constructInvocation(fn, arg),
-      returning
-    ];
+  insertRestSplices(statements, splices, thisAssignments);
+  return [splices, thisAssignments];
+}
+function arrayElementHasTrailingComma(elementNode) {
+  const lastChild = elementNode.children.at(-1);
+  return lastChild && lastChild[lastChild.length - 1]?.token === ",";
+}
+var init_binding = __esm({
+  "source/parser/binding.civet"() {
+    "use strict";
+    init_traversal();
+    init_util();
+  }
+});
+
+// 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);
   }
-  return [constructInvocation(fn, arg), null];
 }
-function processPipelineExpressions(statements) {
-  gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
-    const [ws, , body] = s.children;
-    let [, arg] = s.children;
-    let i = 0, l = body.length;
-    const children = [ws];
-    let usingRef = null;
-    for (i = 0; i < l; i++) {
-      const step = body[i];
-      const [leadingComment, pipe, trailingComment, expr] = step;
-      const returns = pipe.token === "||>";
-      let ref, result, returning = returns ? arg : null;
-      if (pipe.token === "|>=") {
-        let initRef;
-        if (i === 0) {
-          outer:
-            switch (arg.type) {
-              case "MemberExpression":
-                if (arg.children.length <= 2)
-                  break;
-              case "CallExpression":
-                const access = arg.children.pop();
-                switch (access.type) {
-                  case "PropertyAccess":
-                  case "SliceExpression":
-                    break;
-                  default:
-                    children.unshift({
-                      type: "Error",
-                      $loc: pipe.token.$loc,
-                      message: `Can't assign to ${access.type}`
-                    });
-                    arg.children.push(access);
-                    break outer;
-                }
-                usingRef = makeRef();
-                initRef = {
-                  type: "AssignmentExpression",
-                  children: [usingRef, " = ", arg, ","]
-                };
-                arg = {
-                  type: "MemberExpression",
-                  children: [usingRef, access]
-                };
-                break;
+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;
             }
-          const lhs = [[
-            [initRef],
-            arg,
-            [],
-            { token: "=", children: [" = "] }
-          ]];
-          Object.assign(s, {
-            type: "AssignmentExpression",
-            children: [lhs, children],
-            names: null,
-            lhs,
-            assigned: arg,
-            exp: children
-          });
-          arg = clone(arg);
-          if (arg.children[0].type === "Ref") {
-            arg.children[0] = usingRef;
+            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 {
-          children.unshift({
-            type: "Error",
-            $loc: pipe.token.$loc,
-            message: "Can't use |>= in the middle of a pipeline"
-          });
+          b = recurse(b);
         }
-      } else {
-        if (i === 0)
-          s.children = children;
-      }
-      if (returns && (ref = needsRef(arg))) {
-        usingRef = usingRef || ref;
-        arg = {
-          type: "ParenthesizedExpression",
-          children: ["(", {
-            type: "AssignmentExpression",
-            children: [usingRef, " = ", arg]
-          }, ")"]
-        };
-        returning = usingRef;
-      }
-      ;
-      [result, returning] = constructPipeStep(
-        {
-          leadingComment: skipIfOnlyWS(leadingComment),
-          trailingComment: skipIfOnlyWS(trailingComment),
-          expr
-        },
-        arg,
-        returning
-      );
-      if (result.type === "ReturnStatement") {
-        if (i < l - 1) {
-          result.children.push({
-            type: "Error",
-            message: "Can't continue a pipeline after returning"
-          });
+        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: "===" };
+          }
         }
-        arg = result;
-        if (children[children.length - 1] === ",") {
-          children.pop();
-          children.push(";");
+        if (op.asConst) {
+          a = makeAsConst(a);
+          b = makeAsConst(b);
         }
-        break;
-      }
-      if (returning) {
-        arg = returning;
-        children.push(result, ",");
+        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 {
-        arg = result;
+        i += 4;
       }
     }
-    if (usingRef) {
-      s.hoistDec = {
-        type: "Declaration",
-        children: ["let ", usingRef],
-        names: []
-      };
-    }
-    children.push(arg);
-    if (!children.some(($) => $?.type === "ReturnStatement") && children.some(($1) => $1 === ",")) {
-      const { parent } = s;
-      const parenthesizedExpression = makeLeftHandSideExpression({ ...s });
-      Object.assign(s, parenthesizedExpression, {
-        parent,
-        hoistDec: void 0
-      });
-    }
-    return addParentPointers(s, s.parent);
-  });
+    return expandedOps;
+  }
+  ;
+  return recurse;
 }
-var init_pipe = __esm({
-  "source/parser/pipe.civet"() {
-    "use strict";
-    init_traversal();
-    init_util();
+function dotNumericLiteral(literal) {
+  if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
+    literal.children.push(".");
+    literal.raw += ".";
   }
-});
-
-// source/parser/for.civet
-function forRange(open, forDeclaration, range, stepExp, close) {
-  const { start, end, inclusive } = range;
-  const counterRef = makeRef("i");
-  let stepRef;
-  if (stepExp) {
-    stepExp = insertTrimmingSpace(stepExp, "");
-    stepRef = maybeRef(stepExp, "step");
+  return literal;
+}
+function makeAsConst(node) {
+  if (Array.isArray(node) && node.length === 1) {
+    node = node[0];
   }
-  const startRef = maybeRef(start, "start");
-  const endRef = maybeRef(end, "end");
-  const startRefDec = startRef !== start ? [startRef, " = ", start, ", "] : [];
-  const endRefDec = endRef !== end ? [endRef, " = ", end, ", "] : [];
-  let ascDec = [], ascRef, asc;
-  if (stepRef) {
-    if (stepRef !== stepExp) {
-      ascDec = [", ", stepRef, " = ", stepExp];
-    }
-  } else if (start.type === "Literal" && end.type === "Literal") {
-    asc = literalValue(start) <= literalValue(end);
+  if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
+    return { ...node, children: [...node.children, asConst] };
   } else {
-    ascRef = makeRef("asc");
-    ascDec = [", ", ascRef, " = ", startRef, " <= ", endRef];
-  }
-  let varAssign = [], varLetAssign = varAssign, varLet = varAssign, blockPrefix;
-  if (forDeclaration?.declare) {
-    if (forDeclaration.declare.token === "let") {
-      const varName = forDeclaration.children.splice(1);
-      varAssign = [...insertTrimmingSpace(varName, ""), " = "];
-      varLet = [",", ...varName, " = ", counterRef];
-    } else {
-      blockPrefix = [
-        ["", forDeclaration, " = ", counterRef, ";"]
-      ];
-    }
-  } else if (forDeclaration) {
-    varAssign = varLetAssign = [forDeclaration, " = "];
+    return node;
   }
-  const declaration = {
-    type: "Declaration",
-    children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", ...varLetAssign, startRef, ...varLet, ...ascDec],
-    names: forDeclaration?.names
-  };
-  const counterPart = inclusive ? [counterRef, " <= ", endRef, " : ", counterRef, " >= ", endRef] : [counterRef, " < ", endRef, " : ", counterRef, " > ", endRef];
-  const condition = stepRef ? [stepRef, " !== 0 && (", stepRef, " > 0 ? ", ...counterPart, ")"] : ascRef ? [ascRef, " ? ", ...counterPart] : asc ? counterPart.slice(0, 3) : counterPart.slice(4);
-  const increment = stepRef ? [...varAssign, counterRef, " += ", stepRef] : ascRef ? [...varAssign, ascRef, " ? ++", counterRef, " : --", counterRef] : [...varAssign, asc ? "++" : "--", counterRef];
-  return {
-    declaration,
-    children: [open, declaration, "; ", ...condition, "; ", ...increment, close],
-    blockPrefix
-  };
 }
-function processForInOf($0, getRef) {
-  let [awaits, eachOwn, open, declaration, declaration2, ws, inOf, exp, step, close] = $0;
-  if (exp.type === "RangeExpression" && inOf.token === "of" && !declaration2) {
-    return forRange(open, declaration, exp, step, close);
-  } else if (step) {
-    throw new Error("for..of/in cannot use 'by' except with range literals");
+function isExistence(exp) {
+  if (exp.type === "ParenthesizedExpression" && exp.implicit) {
+    exp = exp.expression;
   }
-  let eachOwnError;
-  let hoistDec, blockPrefix = [];
-  if (eachOwn && eachOwn[0].token === "each") {
-    if (inOf.token === "of") {
-      const counterRef = makeRef("i");
-      const lenRef = makeRef("len");
-      const expRef2 = maybeRef(exp);
-      const increment = "++";
-      let assignmentNames = [...declaration.names];
-      if (declaration2) {
-        const [, , ws22, decl22] = declaration2;
-        blockPrefix.push(["", [
-          insertTrimmingSpace(ws22, ""),
-          decl22,
-          " = ",
-          counterRef
-        ], ";"]);
-        assignmentNames.push(...decl22.names);
-      }
-      const expRefDec = expRef2 !== exp ? [insertTrimmingSpace(expRef2, " "), " = ", insertTrimmingSpace(exp, ""), ", "] : [];
-      blockPrefix.push(["", {
-        type: "Declaration",
-        children: [declaration, " = ", insertTrimmingSpace(expRef2, ""), "[", counterRef, "]"],
-        names: assignmentNames
-      }, ";"]);
-      declaration = {
-        type: "Declaration",
-        children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", insertTrimmingSpace(expRef2, ""), ".length"],
-        names: []
-      };
-      const condition = [counterRef, " < ", lenRef, "; "];
-      const children = [open, declaration, "; ", condition, counterRef, increment, close];
-      return { declaration, children, blockPrefix };
-    } else {
-      eachOwnError = {
-        type: "Error",
-        message: "'each' is only meaningful in for..of loops"
-      };
-    }
+  if (exp.type === "Existence") {
+    return exp;
   }
-  let own = eachOwn && eachOwn[0].token === "own";
-  let expRef;
-  if (own && inOf.token !== "in") {
-    own = false;
-    eachOwnError = {
-      type: "Error",
-      message: "'own' is only meaningful in for..in loops"
-    };
+  ;
+  return;
+}
+function isRelationalOp(op) {
+  return op.relational || getPrecedence(op) === precedenceRelational;
+}
+function expandChainedComparisons([first, binops]) {
+  const results = [];
+  let i = 0;
+  const l = binops.length;
+  let start = 0;
+  let chains = [];
+  let op;
+  while (i < l) {
+    [, op] = binops[i];
+    if (isRelationalOp(op)) {
+      chains.push(i);
+    } else if (getPrecedence(op) < precedenceRelational) {
+      processChains(op);
+      first = void 0;
+    }
+    i++;
   }
-  if (!declaration2 && !own) {
-    return {
-      declaration,
-      blockPrefix,
-      children: [awaits, eachOwnError, open, declaration, ws, inOf, expRef ?? exp, step, close]
-      // omit declaration2, replace eachOwn with eachOwnError, replace exp with expRef
-    };
+  if (op != null) {
+    processChains(op);
   }
-  let ws2, decl2;
-  if (declaration2)
-    [, , ws2, decl2] = declaration2;
-  switch (inOf.token) {
-    case "of": {
-      const counterRef = makeRef("i");
-      hoistDec = {
-        type: "Declaration",
-        children: ["let ", counterRef, " = 0"],
-        names: []
-      };
-      blockPrefix.push(["", {
-        type: "Declaration",
-        children: [insertTrimmingSpace(ws2, ""), decl2, " = ", counterRef, "++"],
-        names: decl2.names
-      }, ";"]);
-      break;
+  return results;
+  function processChains(op2) {
+    if (first && isRelationalOp(op2)) {
+      first = expandExistence(first);
     }
-    case "in": {
-      const expRef2 = maybeRef(exp);
-      if (expRef2 !== exp) {
-        hoistDec = {
-          type: "Declaration",
-          children: ["let ", expRef2],
-          names: []
-        };
-        exp = {
-          type: "AssignmentExpression",
-          children: [" ", expRef2, " =", exp]
-        };
-      }
-      let { binding } = declaration;
-      if (binding?.type !== "Identifier") {
-        const keyRef = makeRef("key");
-        blockPrefix.push(["", [
-          declaration,
-          " = ",
-          keyRef
-        ], ";"]);
-        declaration = {
-          type: "ForDeclaration",
-          binding: binding = keyRef,
-          children: ["const ", keyRef],
-          names: []
-        };
-      }
-      if (own) {
-        const hasPropRef = getRef("hasProp");
-        blockPrefix.push(["", ["if (!", hasPropRef, "(", insertTrimmingSpace(expRef2, ""), ", ", insertTrimmingSpace(binding, ""), ")) continue"], ";"]);
-      }
-      if (decl2) {
-        blockPrefix.push(["", {
-          type: "Declaration",
-          children: [insertTrimmingSpace(ws2, ""), decl2, " = ", insertTrimmingSpace(expRef2, ""), "[", insertTrimmingSpace(binding, ""), "]"],
-          names: decl2.names
-        }, ";"]);
+    if (chains.length > 1) {
+      chains.forEach((index, k) => {
+        if (k > 0) {
+          results.push(" ", "&&", " ");
+        }
+        const binop = binops[index];
+        let [, , , exp] = binop;
+        exp = binop[3] = expandExistence(exp);
+        let endIndex;
+        if (k < chains.length - 1) {
+          endIndex = chains[k + 1];
+        } else {
+          endIndex = i + 1;
+        }
+        results.push(first, ...binops.slice(start, endIndex).flat());
+        first = [exp].concat(binops.slice(index + 1, endIndex));
+        return start = endIndex;
+      });
+    } else {
+      if (first) {
+        results.push(first);
       }
-      break;
+      results.push(...binops.slice(start, i + 1).flat());
+      start = i + 1;
     }
-    default:
-      (() => {
-        throw new Error(`for item, index must use 'of' or 'in' instead of '${inOf.token}'`);
-      })();
+    chains.length = 0;
   }
-  return {
-    declaration,
-    children: [awaits, eachOwnError, open, declaration, ws, inOf, exp, step, close],
-    // omit declaration2, replace each with eachOwnError
-    blockPrefix,
-    hoistDec
-  };
+  function expandExistence(exp) {
+    const existence = isExistence(exp);
+    if (existence) {
+      results.push(existence, " ", "&&", " ");
+      return existence.expression;
+    }
+    return exp;
+  }
+  ;
 }
-var init_for = __esm({
-  "source/parser/for.civet"() {
+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/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;
+// 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) {
+        const last = c.block?.expressions?.at(-1)?.[1];
+        if (isExit(last)) {
+          c.children.splice(c.children.indexOf(c.break), 1);
+          c.break = void 0;
+        }
+      }
     }
-    if (ref.names[0] !== ref.base) {
-      return binding.children.unshift(ref.base, ": ");
+    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;
-  });
-}
-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++;
+    if (errors || !isPattern) {
+      return;
     }
-    ;
-    return;
-  });
-  if (restCount === 0) {
-    return {
-      children: elements,
-      names,
-      blockPrefix,
-      length
-    };
-  } 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)
+    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]
+      }, ","];
     }
-    return {
-      names,
-      children: [...elements.slice(0, restIndex), {
-        ...rest,
-        children: rest.children.slice(0, -1)
-        // remove trailing comma
-      }],
-      blockPrefix,
-      length
-    };
-  }
-  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]);
+    let prev = [], root = prev;
+    const l = clauses.length;
+    clauses.forEach((c, i) => {
+      if (c.type === "DefaultClause") {
+        prev.push(c.block);
         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;
+      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;
+        }
       }
-      const { blockPrefix } = n;
-      p.push(blockPrefix);
-      return insertRestSplices(blockPrefix, p, thisAssignments2);
+      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;
     });
-  }
-  insertRestSplices(statements, splices, thisAssignments);
-  return [splices, thisAssignments];
-}
-function arrayElementHasTrailingComma(elementNode) {
-  const lastChild = elementNode.children.at(-1);
-  return lastChild && lastChild[lastChild.length - 1]?.token === ",";
-}
-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 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]);
+    s.type = "PatternMatchingStatement";
+    s.children = [root];
+    return addParentPointers(s, s.parent);
+  });
 }
-function implicitFunctionBlock(f) {
-  if (f.abstract || f.block || f.signature?.optional)
-    return;
-  const { name, parent } = f;
-  if (parent?.type === "ExportDeclaration")
+function getPatternConditions(pattern, ref, conditions, getRef) {
+  if (pattern.rest)
     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;
-  } else {
-    const block = makeEmptyBlock();
-    block.parent = f;
-    f.block = block;
-    f.children.push(block);
-    f.ts = false;
-  }
-}
-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;
-        }
-      } else {
-        if (!block.implicitlyReturned) {
-          insertReturn(block);
+  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;
+    }
+    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;
   }
 }
-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;
+function elideMatchersFromArrayBindings(elements) {
+  return elements.map((el) => {
+    if (el.type === "BindingRestElement") {
+      return ["", el, void 0];
     }
-  }
-  if (declaration) {
-    if (!(declaration.suffix != null)) {
-      declaration.children[1] = declaration.suffix = returnType;
+    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];
     }
-  } 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")) {
-    block.expressions.push([
-      [getIndent(block.expressions.at(-1))],
-      {
-        type: "ReturnStatement",
-        expression: ref,
-        children: ["return ", ref]
+}
+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]
+            };
+        }
       }
-    ]);
-  }
-  return true;
+      case "PinProperty":
+      case "BindingRestProperty":
+      default:
+        return p;
+    }
+  });
 }
-function patternAsValue(pattern) {
+function nonMatcherBindings(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 };
+      const elements = elideMatchersFromArrayBindings(pattern.elements);
+      const children = ["[", elements, "]"];
+      return {
+        ...pattern,
+        children,
+        elements
+      };
     }
-    case "Identifier":
-    case "BindingProperty": {
-      const children = [pattern.name, pattern.delim];
-      if (isWhitespaceOrEmpty(pattern.children[0])) {
-        children.unshift(pattern.children[0]);
-      }
-      return { ...pattern, children };
+    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;
   }
 }
-function insertPush(node, ref) {
-  if (!node)
-    return;
-  switch (node.type) {
-    case "BlockStatement":
-      if (node.expressions.length) {
-        insertPush(node.expressions.at(-1), ref);
-      } else {
-        node.expressions.push([ref, ".push(void 0);"]);
-      }
-      return;
-    case "CaseBlock":
-      node.clauses.forEach((clause) => {
-        return insertPush(clause, ref);
-      });
-      return;
-    case "WhenClause":
-      insertPush(node.block, ref);
-      return;
-    case "DefaultClause":
-      insertPush(node.block, ref);
-      return;
-  }
-  if (!Array.isArray(node))
-    return;
-  let [, exp] = node;
-  if (!exp) {
-    return;
-  }
-  const indent = getIndent(node);
-  const outer = exp;
-  let { type } = exp;
-  if (type === "LabelledStatement") {
-    exp = exp.statement;
-    ({ type } = exp);
-  }
-  switch (exp.type) {
-    case "BreakStatement":
-    case "ContinueStatement":
-    case "DebuggerStatement":
-    case "EmptyStatement":
-    case "ReturnStatement":
-    case "ThrowStatement":
-      return;
-    case "Declaration":
-      exp.children.push(["", [
-        ";",
-        ref,
-        ".push(",
-        patternAsValue(exp.bindings.at(-1).pattern),
-        ")"
-      ]]);
-      return;
-    case "ForStatement":
-    case "IterationStatement":
-    case "DoStatement":
-      wrapIterationReturningResults(exp, outer, ref);
-      return;
-    case "BlockStatement":
-      insertPush(exp.expressions[exp.expressions.length - 1], ref);
-      return;
-    case "IfStatement":
-      insertPush(exp.then, ref);
-      if (exp.then.bare && !exp.then.semicolon) {
-        exp.then.children.push(exp.then.semicolon = ";");
+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;
       }
-      if (exp.else)
-        insertPush(exp.else[2], ref);
-      else
-        exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
+      ;
       return;
-    case "PatternMatchingStatement":
-      insertPush(exp.children[0][0], ref);
+    });
+  });
+  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]);
+    }
+  }
+  propsGroupedByName.forEach((shared, key) => {
+    if (!key) {
       return;
-    case "SwitchStatement":
-      insertPush(exp.children[2], ref);
+    }
+    if (ReservedWord({ fail() {
+    } }, {
+      pos: 0,
+      input: key
+    })) {
+      shared.forEach((p) => {
+        return aliasBinding(p, makeRef(`_${key}`, key));
+      });
       return;
-    case "TryStatement":
-      exp.blocks.forEach((block) => insertPush(block, ref));
+    }
+    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;
+}
+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);
   }
-  if (node[node.length - 1]?.type === "SemicolonDelimiter")
-    return;
-  node.splice(1, 0, ref, ".push(");
-  node.push(")");
 }
-function insertReturn(node, outerNode = node) {
-  if (!node)
+var init_pattern_matching = __esm({
+  "source/parser/pattern-matching.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;
-  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"]);
+  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;
+  } else {
+    const block = makeEmptyBlock();
+    block.parent = f;
+    f.block = block;
+    f.children.push(block);
+    f.ts = false;
+  }
+}
+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;
         }
-      }
-      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());
+        if (!block.implicitlyReturned) {
+          insertReturn(block);
+        }
       }
-      return;
-    case "DefaultClause":
-      insertReturn(node.block);
-      return;
+    }
   }
-  if (!Array.isArray(node))
-    return;
-  let [, exp, semi] = node;
-  if (semi?.type === "SemicolonDelimiter") {
-    return;
+}
+function processReturnValue(func) {
+  const { block } = func;
+  const values = gatherRecursiveWithinFunction(
+    block,
+    ({ type }) => type === "ReturnValue"
+  );
+  if (!values.length) {
+    return false;
   }
-  if (!exp) {
+  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;
+    }
   }
-  const outer = exp;
-  let { type } = exp;
-  if (type === "LabelledStatement") {
-    exp = exp.statement;
-    ({ type } = exp);
+  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: []
+      },
+      ";"
+    ]);
   }
-  switch (type) {
-    case "BreakStatement":
+  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 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 "BindingProperty": {
+      const children = [pattern.name, pattern.delim];
+      if (isWhitespaceOrEmpty(pattern.children[0])) {
+        children.unshift(pattern.children[0]);
+      }
+      return { ...pattern, children };
+    }
+    default:
+      return pattern;
+  }
+}
+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;
+  }
+  let [, exp] = node;
+  if (!exp) {
+    return;
+  }
+  const outer = exp;
+  let { type } = exp;
+  if (type === "LabelledStatement") {
+    exp = exp.statement;
+    ({ type } = exp);
+  }
+  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;
+  }
+  if (node.at(-1)?.type === "SemicolonDelimiter") {
+    return;
+  }
+  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"]);
+        }
+      }
+      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;
+  }
+  if (!Array.isArray(node))
+    return;
+  let [, exp, semi] = node;
+  if (semi?.type === "SemicolonDelimiter") {
+    return;
+  }
+  if (!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":
@@ -1613,24 +1907,31 @@ function insertSwitchReturns(exp) {
     return insertReturn(clause);
   });
 }
-function wrapIterationReturningResults(statement, outer, outerRef) {
+function wrapIterationReturningResults(statement, outer, collect) {
   if (statement.type === "DoStatement") {
-    if (outerRef) {
-      insertPush(statement.block, outerRef);
+    if (collect) {
+      assignResults(statement.block, collect);
     } else {
       insertReturn(statement.block, outer);
     }
     return;
   }
-  const resultsRef = makeRef("results");
+  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, "=[];"]
+    children: ["const ", resultsRef, "=[]"]
   };
-  insertPush(statement.block, resultsRef);
-  outer.children.unshift(declaration);
-  if (outerRef) {
-    statement.children.push(";", outerRef, ".push(", 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, ";");
   }
@@ -1713,8 +2014,11 @@ function expressionizeIteration(exp) {
     updateParentPointers(exp);
     return;
   }
-  const resultsRef = makeRef("results");
-  insertPush(block, resultsRef);
+  exp.resultsRef ??= makeRef("results");
+  const { resultsRef } = exp;
+  assignResults(block, (node) => {
+    return [resultsRef, ".push(", node, ")"];
+  });
   braceBlock(block);
   children.splice(
     i,
@@ -1727,6 +2031,19 @@ function expressionizeIteration(exp) {
   );
   updateParentPointers(exp);
 }
+function skipImplicitArguments(args) {
+  if (args.length === 1) {
+    let arg0 = args[0];
+    if (Array.isArray(arg0)) {
+      arg0 = arg0[1];
+    }
+    if (arg0.type === "StatementExpression") {
+      arg0 = arg0.statement;
+    }
+    return arg0.type === "IterationExpression" && arg0.subtype !== "DoStatement" && !arg0.async && isEmptyBareBlock(arg0.block);
+  }
+  return false;
+}
 var init_function = __esm({
   "source/parser/function.civet"() {
     "use strict";
@@ -1737,864 +2054,764 @@ var init_function = __esm({
   }
 });
 
-// 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;
+// source/parser/declaration.civet
+function processAssignmentDeclaration(decl, pattern, suffix, ws, assign, e) {
+  decl = {
+    ...decl,
+    $loc: {
+      pos: assign.$loc.pos - 1,
+      length: assign.$loc.length + 1
+    }
+  };
+  let [splices, assignments] = gatherBindingCode(pattern);
+  splices = splices.map((s) => [", ", s]);
+  const thisAssignments = assignments.map((a) => ["", a, ";"]);
+  const initializer = [ws, assign, e];
+  const binding = makeNode({
+    type: "Binding",
+    pattern,
+    initializer,
+    splices,
+    suffix,
+    thisAssignments,
+    children: [pattern, suffix, initializer]
+  });
+  const children = [decl, binding];
+  return makeNode({
+    type: "Declaration",
+    names: pattern.names,
+    decl,
+    bindings: [binding],
+    splices,
+    thisAssignments,
+    children
+  });
+}
+function processDeclarations(statements) {
+  gatherRecursiveAll(statements, ($) => $.type === "Declaration").forEach((statement) => {
+    const { bindings } = statement;
+    return bindings?.forEach((binding) => {
+      const suffix = binding.suffix;
+      if (suffix && suffix.optional && suffix.t) {
+        convertOptionalType(suffix);
+      }
+      const { initializer } = binding;
+      if (initializer) {
+        return prependStatementExpressionBlock(initializer, statement);
+      }
+      ;
+      return;
+    });
+  });
+}
+function prependStatementExpressionBlock(initializer, statement) {
+  let exp = initializer[2];
+  let ws;
+  if (Array.isArray(exp)) {
+    ws = exp[0];
+    exp = exp[1];
+  }
+  if (!(exp.type === "StatementExpression")) {
+    return;
+  }
+  const pre = [];
+  const statementExp = exp.statement;
+  const blockStatement = ["", statementExp];
+  let ref;
+  if (statementExp.type === "IterationExpression") {
+    if (statementExp.async) {
+      return;
+    }
+    const statement2 = statementExp.statement;
+    blockStatement[1] = statement2;
+    if (statement2.type === "DoStatement") {
+      ref = initializer[2] = makeRef();
+      assignResults(blockStatement, (resultNode) => {
+        return makeNode({
+          type: "AssignmentExpression",
+          children: [ref, " = ", resultNode]
+        });
+      });
+      const refDec = {
+        type: "Declaration",
+        children: ["let ", ref, ";"]
+      };
+      pre.unshift(refDec);
+    } else {
+      wrapIterationReturningResults(statement2, { children: blockStatement }, function() {
+      });
+      ref = initializer[2] = statement2.resultsRef;
+    }
   } else {
-    return precedenceMap.get(op.prec ?? op.token) ?? (op.relational ? precedenceRelational : precedenceCustomDefault);
+    ref = initializer[2] = makeRef();
+    assignResults(blockStatement, (resultNode) => {
+      return makeNode({
+        type: "AssignmentExpression",
+        children: [ref, " = ", resultNode]
+      });
+    });
+    const refDec = {
+      type: "Declaration",
+      children: ["let ", ref, ";"]
+    };
+    pre.unshift(refDec);
+    if (ws) {
+      pre.push(ws);
+    }
   }
+  statement.children.unshift(pre, blockStatement, ";");
+  updateParentPointers(blockStatement, statement);
+  return ref;
 }
-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];
+function processDeclarationCondition(condition, rootCondition, parent) {
+  if (!(condition.type === "DeclarationCondition")) {
+    return;
   }
-  if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
-    return { ...node, children: [...node.children, asConst] };
+  const { decl, bindings } = condition.declaration;
+  const binding = bindings[0];
+  const { pattern, suffix, initializer, splices, thisAssignments } = binding;
+  let ref = prependStatementExpressionBlock(initializer, parent);
+  if (ref) {
+    Object.assign(condition, {
+      type: "AssignmentExpression",
+      children: [ref],
+      pattern,
+      ref,
+      statementDeclaration: true
+    });
   } else {
-    return node;
-  }
-}
-function isExistence(exp) {
-  if (exp.type === "ParenthesizedExpression" && exp.implicit) {
-    exp = exp.expression;
-  }
-  if (exp.type === "Existence") {
-    return exp;
+    ref = makeRef();
+    const grandparent = condition.parent?.parent;
+    const children = (
+      // Check that the declaration is a plain assignment (no pattern-matching) and the immediate grandchild of an `if` or `while`
+      // More complex conditions (triggered by pattern matching or `until`/`unless`) don't need double parens
+      // @ts-ignore Just because pattern might not have a type at runtime doesn't mean it's unsafe
+      pattern.type === "Identifier" && (grandparent?.type === "IfStatement" || grandparent?.type === "WhileStatement") ? ["(", ref, initializer, ")"] : [ref, initializer]
+    );
+    Object.assign(condition, {
+      type: "AssignmentExpression",
+      children,
+      hoistDec: {
+        type: "Declaration",
+        children: ["let ", ref, suffix],
+        names: []
+      },
+      pattern,
+      ref
+    });
   }
-  ;
-  return;
+  addParentPointers(condition, parent);
+  Object.assign(rootCondition, {
+    blockPrefix: [
+      ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
+      ...thisAssignments
+    ]
+  });
 }
-function isRelationalOp(op) {
-  return op.relational || getPrecedence(op) === precedenceRelational;
+function processDeclarationConditions(node, getRef) {
+  gatherRecursiveAll(node, (n) => {
+    return n.type === "IfStatement" || n.type === "IterationStatement" || n.type === "SwitchStatement";
+  }).forEach((s) => {
+    return processDeclarationConditionStatement(s, getRef);
+  });
 }
-function expandChainedComparisons([first, binops]) {
-  const results = [];
-  let i = 0;
-  const l = binops.length;
-  let start = 0;
-  let chains = [];
-  let op;
-  while (i < l) {
-    [, op] = binops[i];
-    if (isRelationalOp(op)) {
-      chains.push(i);
-    } else if (getPrecedence(op) < precedenceRelational) {
-      processChains(op);
-      first = void 0;
-    }
-    i++;
+function processDeclarationConditionStatement(s, getRef) {
+  const { condition } = s;
+  if (!condition?.expression) {
+    return;
   }
-  if (op != null) {
-    processChains(op);
+  let { expression } = condition;
+  if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "UnaryExpression" && "children" in expression && Array.isArray(expression.children) && expression.children.length === 2 && expression.children[0] === "!" && typeof expression.children[1] === "object" && expression.children[1] != null && "type" in expression.children[1] && expression.children[1].type === "ParenthesizedExpression" && "expression" in expression.children[1]) {
+    const { type: type1, children: [, { type: type2, expression: expression2 }] } = expression;
+    const type = [type1, type2];
+    expression = expression2;
   }
-  return results;
-  function processChains(op2) {
-    if (first && isRelationalOp(op2)) {
-      first = expandExistence(first);
+  processDeclarationCondition(expression, condition.expression, s);
+  const { ref, pattern } = expression;
+  if (pattern) {
+    let conditions = [];
+    getPatternConditions(pattern, ref, conditions, getRef);
+    conditions = conditions.filter((c) => {
+      return !(c.length === 3 && c[0] === "typeof " && c[1] === ref && c[2] === " === 'object'") && !(c.length === 2 && c[0] === ref && c[1] === " != null");
+    });
+    if (conditions.length) {
+      condition.children.unshift("(");
+      conditions.forEach(function(c) {
+        return condition.children.push(" && ", c);
+      });
+      condition.children.push(")");
     }
-    if (chains.length > 1) {
-      chains.forEach((index, k) => {
-        if (k > 0) {
-          results.push(" ", "&&", " ");
-        }
-        const binop = binops[index];
-        let [, , , exp] = binop;
-        exp = binop[3] = expandExistence(exp);
-        let endIndex;
-        if (k < chains.length - 1) {
-          endIndex = chains[k + 1];
+  }
+  switch (s.type) {
+    case "IfStatement": {
+      const { else: e } = s;
+      const block = blockWithPrefix(condition.expression.blockPrefix, s.then);
+      if (block.bare && e && !block.semicolon) {
+        block.children.push(block.semicolon = ";");
+      }
+      s.children = s.children.map((c) => {
+        if (c === s.then) {
+          return block;
         } else {
-          endIndex = i + 1;
+          return c;
         }
-        results.push(first, ...binops.slice(start, endIndex).flat());
-        first = [exp].concat(binops.slice(index + 1, endIndex));
-        return start = endIndex;
       });
-    } else {
-      if (first) {
-        results.push(first);
-      }
-      results.push(...binops.slice(start, i + 1).flat());
-      start = i + 1;
-    }
-    chains.length = 0;
-  }
-  function expandExistence(exp) {
-    const existence = isExistence(exp);
-    if (existence) {
-      results.push(existence, " ", "&&", " ");
-      return existence.expression;
+      s.then = block;
+      updateParentPointers(block, s);
+      break;
+    }
+    case "IterationStatement": {
+      const { children, block } = s;
+      const newBlock = blockWithPrefix(condition.expression.blockPrefix, block);
+      s.children = children.map((c) => c?.type === "BlockStatement" ? newBlock : c);
+      updateParentPointers(newBlock, s);
+      break;
+    }
+    case "SwitchStatement": {
+      const { blockPrefix, ref: ref2, statementDeclaration } = condition.expression;
+      if (!blockPrefix) {
+        return;
+      }
+      const newCondition = {
+        type: "ParenthesizedExpression",
+        children: ["(", ref2, ")"],
+        expression: ref2,
+        parent: s
+      };
+      s.children = s.children.map(function(c) {
+        if (c === s.condition) {
+          return newCondition;
+        } else {
+          return c;
+        }
+      });
+      s.condition = newCondition;
+      updateParentPointers(s);
+      if (statementDeclaration) {
+        const block = makeEmptyBlock();
+        replaceBlockExpression(s.parent, s, block);
+        block.expressions.push(["", s]);
+        s.children.splice(s.children.findIndex(($1) => $1.token === "switch"), 0, blockPrefix);
+        s.parent = block;
+      } else {
+        const block = blockWithPrefix([["", [{
+          type: "Declaration",
+          children: ["let ", ...condition.expression.children]
+        }], ";"], ...blockPrefix], makeEmptyBlock());
+        updateParentPointers(block, s.parent);
+        replaceBlockExpression(s.parent, s, block);
+        block.expressions.push(["", s]);
+        s.parent = block;
+      }
+      ;
+      break;
     }
-    return exp;
   }
-  ;
 }
-var precedenceOrder, precedenceMap, precedenceStep, precedenceRelational, precedenceCustomDefault, asConst;
-var init_op = __esm({
-  "source/parser/op.civet"() {
+var init_declaration = __esm({
+  "source/parser/declaration.civet"() {
     "use strict";
+    init_block();
+    init_traversal();
+    init_pattern_matching();
     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"]
-    };
+    init_function();
+    init_binding();
   }
 });
 
-// source/parser/pattern-matching.civet
-function processPatternMatching(statements, ReservedWord) {
-  gatherRecursiveAll(statements, ($) => $.type === "SwitchStatement").forEach((s) => {
-    const { caseBlock } = s;
-    const { clauses } = caseBlock;
-    for (const c of clauses) {
-      if (c.type === "WhenClause" && c.break) {
-        const last = c.block?.expressions?.at(-1)?.[1];
-        if (isExit(last)) {
-          c.children.splice(c.children.indexOf(c.break), 1);
-          c.break = void 0;
-        }
+// 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[pre.length - 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);
       }
     }
-    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;
-    }
-    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: []
+    const existence = {
+      type: "Existence",
+      expression: exp,
+      children: [exp, post]
+    };
+    exp = makeLeftHandSideExpression(existence);
+    if (pre.length) {
+      return {
+        type: "UnaryExpression",
+        children: [...pre, exp]
       };
-      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;
+    return exp;
+  }
+  if (exp.type === "Literal") {
+    if (pre.length === 1) {
+      const { token } = pre[0];
+      if (token === "-" || token === "+") {
+        const children = [pre[0], ...exp.children];
+        if (post)
+          exp.children.push(post);
+        return {
+          type: "Literal",
+          children,
+          raw: `${token}${exp.raw}`
+        };
       }
-      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);
-        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;
+    }
+  }
+  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);
       }
-      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);
-  });
-}
-function getPatternConditions(pattern, ref, conditions) {
-  if (pattern.rest)
-    return;
-  switch (pattern.type) {
-    case "ArrayBindingPattern": {
-      const { elements, length } = pattern, hasRest = elements.some((e) => e.rest), comparator = hasRest ? " >= " : " === ", l = [comparator, (length - hasRest).toString()];
-      conditions.push(
-        ["Array.isArray(", ref, ")"],
-        [ref, ".length", l]
-      );
-      elements.forEach(({ children: [, e] }, i) => {
-        const subRef = [ref, "[", i.toString(), "]"];
-        return getPatternConditions(e, subRef, conditions);
-      });
-      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);
-        });
-      }
-      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);
-            }
-            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;
-    }
-    case "RegularExpressionLiteral": {
-      conditions.push(
-        ["typeof ", ref, " === 'string'"],
-        [pattern, ".test(", ref, ")"]
-      );
+    } else {
       break;
     }
-    case "PinPattern":
-      conditions.push([
-        ref,
-        " === ",
-        pattern.expression
-      ]);
-      break;
-    case "Literal":
-      conditions.push([
-        ref,
-        " === ",
-        pattern
-      ]);
-      break;
-    default:
-      break;
   }
+  return {
+    type: "UnaryExpression",
+    children: [...pre, exp, post]
+  };
 }
-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];
-    }
-  });
+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];
+  let expr = fn.expr;
+  while (expr.type === "ParenthesizedExpression") {
+    expr = expr.expression;
+  }
+  if (expr.ampersandBlock) {
+    const { ref, body } = expr;
+    ref.type = "PipedExpression";
+    ref.children = [makeLeftHandSideExpression(arg)];
+    updateParentPointers(ref);
+    return makeNode({
+      type: "UnwrappedExpression",
+      children: [skipIfOnlyWS(fn.leadingComment), body, skipIfOnlyWS(fn.trailingComment)]
+    });
+  }
+  expr = fn.expr;
+  const lhs = makeLeftHandSideExpression(expr);
+  let comment = skipIfOnlyWS(fn.trailingComment);
+  if (comment)
+    lhs.children.splice(2, 0, comment);
+  comment = skipIfOnlyWS(fn.leadingComment);
+  if (comment)
+    lhs.children.splice(1, 0, comment);
+  switch (arg.type) {
+    case "CommaExpression":
+      arg = makeLeftHandSideExpression(arg);
+      break;
+  }
+  return {
+    type: "CallExpression",
+    children: [lhs, "(", arg, ")"]
+  };
 }
-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]
-            };
-        }
+function constructPipeStep(fn, arg, returning) {
+  let children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(skipIfOnlyWS), " ", arg];
+  switch (fn.expr.token) {
+    case "yield":
+    case "await":
+      if (fn.expr.op) {
+        children = processUnaryExpression([fn.expr], arg, void 0);
       }
-      case "PinProperty":
-      case "BindingRestProperty":
-      default:
-        return p;
-    }
-  });
-}
-function nonMatcherBindings(pattern) {
-  switch (pattern.type) {
-    case "ArrayBindingPattern": {
-      const elements = elideMatchersFromArrayBindings(pattern.elements);
-      const children = ["[", elements, "]"];
-      return {
-        ...pattern,
+      if (returning) {
+        return [
+          children,
+          returning
+        ];
+      }
+      return [
         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;
+        null
+      ];
+    case "return":
+      return [{
+        type: "ReturnStatement",
+        children
+      }, null];
+  }
+  if (returning) {
+    return [
+      constructInvocation(fn, arg),
+      returning
+    ];
   }
+  return [constructInvocation(fn, arg), null];
 }
-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);
+function processPipelineExpressions(statements) {
+  gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
+    const [ws, , body] = s.children;
+    let [, arg] = s.children;
+    let i = 0, l = body.length;
+    const children = [ws];
+    let usingRef = null;
+    for (i = 0; i < l; i++) {
+      const step = body[i];
+      const [leadingComment, pipe, trailingComment, expr] = step;
+      const returns = pipe.token === "||>";
+      let ref, result, returning = returns ? arg : null;
+      if (pipe.token === "|>=") {
+        let initRef;
+        if (i === 0) {
+          outer:
+            switch (arg.type) {
+              case "MemberExpression":
+                if (arg.children.length <= 2)
+                  break;
+              case "CallExpression":
+                const access = arg.children.pop();
+                switch (access.type) {
+                  case "PropertyAccess":
+                  case "SliceExpression":
+                    break;
+                  default:
+                    children.unshift({
+                      type: "Error",
+                      $loc: pipe.token.$loc,
+                      message: `Can't assign to ${access.type}`
+                    });
+                    arg.children.push(access);
+                    break outer;
+                }
+                usingRef = makeRef();
+                initRef = {
+                  type: "AssignmentExpression",
+                  children: [usingRef, " = ", arg, ","]
+                };
+                arg = {
+                  type: "MemberExpression",
+                  children: [usingRef, access]
+                };
+                break;
+            }
+          const lhs = [[
+            [initRef],
+            arg,
+            [],
+            { token: "=", children: [" = "] }
+          ]];
+          Object.assign(s, {
+            type: "AssignmentExpression",
+            children: [lhs, children],
+            names: null,
+            lhs,
+            assigned: arg,
+            exp: children
+          });
+          arg = clone(arg);
+          if (arg.children[0].type === "Ref") {
+            arg.children[0] = usingRef;
+          }
+        } else {
+          children.unshift({
+            type: "Error",
+            $loc: pipe.token.$loc,
+            message: "Can't use |>= in the middle of a pipeline"
+          });
         }
-        ;
-        return;
+      } else {
+        if (i === 0)
+          s.children = children;
+      }
+      if (returns && (ref = needsRef(arg))) {
+        usingRef = usingRef || ref;
+        arg = {
+          type: "ParenthesizedExpression",
+          children: ["(", {
+            type: "AssignmentExpression",
+            children: [usingRef, " = ", arg]
+          }, ")"]
+        };
+        returning = usingRef;
       }
       ;
-      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]);
-    }
-  }
-  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];
-    }), "]"]);
-  });
-  return declarations;
-}
-function processDeclarationCondition(condition, rootCondition, parent) {
-  if (!(condition.type === "DeclarationCondition")) {
-    return;
-  }
-  const ref = makeRef();
-  const { decl, bindings } = condition.declaration;
-  const binding = bindings[0];
-  const { pattern, suffix, initializer, splices, thisAssignments } = binding;
-  const grandparent = condition.parent?.parent;
-  const children = (
-    // Check that the declaration is a plain assignment (no pattern-matching) and the immediate grandchild of an `if` or `while`
-    // More complex conditions (triggered by pattern matching or `until`/`unless`) don't need double parens
-    // @ts-ignore Just because pattern might not have a type at runtime doesn't mean it's unsafe
-    pattern.type === "Identifier" && (grandparent?.type === "IfStatement" || grandparent?.type === "WhileStatement") ? ["(", ref, initializer, ")"] : [ref, initializer]
-  );
-  Object.assign(condition, {
-    type: "AssignmentExpression",
-    children,
-    hoistDec: {
-      type: "Declaration",
-      children: ["let ", ref, suffix],
-      names: []
-    },
-    pattern,
-    ref
-  });
-  addParentPointers(condition, parent);
-  Object.assign(rootCondition, {
-    blockPrefix: [
-      ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
-      ...thisAssignments
-    ]
-  });
-}
-function processDeclarationConditions(node) {
-  gatherRecursiveAll(node, (n) => {
-    return n.type === "IfStatement" || n.type === "IterationStatement" || n.type === "SwitchStatement";
-  }).forEach(processDeclarationConditionStatement);
-}
-function processDeclarationConditionStatement(s) {
-  const { condition } = s;
-  if (!condition?.expression) {
-    return;
-  }
-  let { expression } = condition;
-  if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "UnaryExpression" && "children" in expression && Array.isArray(expression.children) && expression.children.length === 2 && expression.children[0] === "!" && typeof expression.children[1] === "object" && expression.children[1] != null && "type" in expression.children[1] && expression.children[1].type === "ParenthesizedExpression" && "expression" in expression.children[1]) {
-    const { type: type1, children: [, { type: type2, expression: expression2 }] } = expression;
-    const type = [type1, type2];
-    expression = expression2;
-  }
-  processDeclarationCondition(expression, condition.expression, s);
-  const { ref, pattern } = expression;
-  if (pattern) {
-    let conditions = [];
-    getPatternConditions(pattern, ref, conditions);
-    conditions = conditions.filter((c) => {
-      return !(c.length === 3 && c[0] === "typeof " && c[1] === ref && c[2] === " === 'object'") && !(c.length === 2 && c[0] === ref && c[1] === " != null");
-    });
-    if (conditions.length) {
-      condition.children.unshift("(");
-      conditions.forEach(function(c) {
-        return condition.children.push(" && ", c);
-      });
-      condition.children.push(")");
-    }
-  }
-  switch (s.type) {
-    case "IfStatement": {
-      const { else: e } = s;
-      const block = blockWithPrefix(condition.expression.blockPrefix, s.then);
-      s.then = block;
-      if (block.bare && e && !block.semicolon) {
-        block.children.push(block.semicolon = ";");
+      [result, returning] = constructPipeStep(
+        {
+          leadingComment: skipIfOnlyWS(leadingComment),
+          trailingComment: skipIfOnlyWS(trailingComment),
+          expr
+        },
+        arg,
+        returning
+      );
+      if (result.type === "ReturnStatement") {
+        if (i < l - 1) {
+          result.children.push({
+            type: "Error",
+            message: "Can't continue a pipeline after returning"
+          });
+        }
+        arg = result;
+        if (children[children.length - 1] === ",") {
+          children.pop();
+          children.push(";");
+        }
+        break;
+      }
+      if (returning) {
+        arg = returning;
+        children.push(result, ",");
+      } else {
+        arg = result;
       }
-      s.children.splice(2, 1, block);
-      updateParentPointers(block, s);
-      break;
-    }
-    case "IterationStatement": {
-      const { children, block } = s;
-      const newBlock = blockWithPrefix(condition.expression.blockPrefix, block);
-      s.children = children.map((c) => c?.type === "BlockStatement" ? newBlock : c);
-      updateParentPointers(newBlock, s);
-      break;
     }
-    case "SwitchStatement": {
-      const { blockPrefix, ref: ref2 } = condition.expression;
-      if (!blockPrefix) {
-        return;
-      }
-      s.condition = {
-        type: "ParenthesizedExpression",
-        children: ["(", ref2, ")"],
-        expression: ref2,
-        parent: s
-      };
-      s.children[1] = s.condition;
-      updateParentPointers(s);
-      const block = blockWithPrefix([["", [{
+    if (usingRef) {
+      s.hoistDec = {
         type: "Declaration",
-        children: ["let ", ...condition.expression.children]
-      }], ";"], ...blockPrefix], makeEmptyBlock());
-      updateParentPointers(block, s.parent);
-      replaceBlockExpression(s.parent, s, block);
-      block.expressions.push(["", s]);
-      s.parent = block;
-      break;
+        children: ["let ", usingRef],
+        names: []
+      };
     }
-  }
-}
-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);
-  }
+    children.push(arg);
+    if (!children.some(($) => $?.type === "ReturnStatement") && children.some(($1) => $1 === ",")) {
+      const { parent } = s;
+      const parenthesizedExpression = makeLeftHandSideExpression({ ...s });
+      Object.assign(s, parenthesizedExpression, {
+        parent,
+        hoistDec: void 0
+      });
+    }
+    return addParentPointers(s, s.parent);
+  });
 }
-var init_pattern_matching = __esm({
-  "source/parser/pattern-matching.civet"() {
+var init_pipe = __esm({
+  "source/parser/pipe.civet"() {
     "use strict";
     init_traversal();
     init_util();
-    init_block();
-    init_binding();
-    init_op();
+    init_unary();
   }
 });
 
-// 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[pre.length - 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);
+// source/parser/for.civet
+function forRange(open, forDeclaration, range, stepExp, close) {
+  const { start, end, inclusive } = range;
+  const counterRef = makeRef("i");
+  let stepRef;
+  if (stepExp) {
+    stepExp = insertTrimmingSpace(stepExp, "");
+    stepRef = maybeRef(stepExp, "step");
+  }
+  let startRef = maybeRef(start, "start");
+  let endRef = maybeRef(end, "end");
+  const startRefDec = startRef !== start ? [startRef, " = ", start, ", "] : [];
+  const endRefDec = endRef !== end ? [endRef, " = ", end, ", "] : [];
+  let ascDec = [], ascRef, asc;
+  if (stepRef) {
+    if (!(stepRef === stepExp)) {
+      ascDec = [", ", stepRef, " = ", stepExp];
+    }
+  } else if ("Literal" === start.type && start.type === end.type) {
+    asc = literalValue(start) <= literalValue(end);
+    if ("StringLiteral" === start.subtype && start.subtype === end.subtype) {
+      startRef = literalValue(start).charCodeAt(0).toString();
+      endRef = literalValue(end).charCodeAt(0).toString();
+    }
+  } else {
+    ascRef = makeRef("asc");
+    ascDec = [", ", ascRef, " = ", startRef, " <= ", endRef];
+  }
+  let varAssign = [], varLetAssign = varAssign, varLet = varAssign, blockPrefix;
+  if (forDeclaration?.declare) {
+    if (forDeclaration.declare.token === "let") {
+      const varName = forDeclaration.children.splice(1);
+      varAssign = [...insertTrimmingSpace(varName, ""), " = "];
+      varLet = [",", ...varName, " = ", counterRef];
+    } else {
+      const value = "StringLiteral" === start.subtype ? ["String.fromCharCode(", counterRef, ")"] : counterRef;
+      blockPrefix = [
+        ["", forDeclaration, " = ", value, ";"]
+      ];
+    }
+  } else if (forDeclaration) {
+    varAssign = varLetAssign = [forDeclaration, " = "];
+  }
+  const declaration = {
+    type: "Declaration",
+    children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", ...varLetAssign, startRef, ...varLet, ...ascDec],
+    names: forDeclaration?.names
+  };
+  const counterPart = inclusive ? [counterRef, " <= ", endRef, " : ", counterRef, " >= ", endRef] : [counterRef, " < ", endRef, " : ", counterRef, " > ", endRef];
+  const condition = stepRef ? [stepRef, " !== 0 && (", stepRef, " > 0 ? ", ...counterPart, ")"] : ascRef ? [ascRef, " ? ", ...counterPart] : asc ? counterPart.slice(0, 3) : counterPart.slice(4);
+  const increment = stepRef ? [...varAssign, counterRef, " += ", stepRef] : ascRef ? [...varAssign, ascRef, " ? ++", counterRef, " : --", counterRef] : [...varAssign, asc ? "++" : "--", counterRef];
+  return {
+    declaration,
+    children: [open, declaration, "; ", ...condition, "; ", ...increment, close],
+    blockPrefix
+  };
+}
+function processForInOf($0, getRef) {
+  let [awaits, eachOwn, open, declaration, declaration2, ws, inOf, exp, step, close] = $0;
+  if (exp.type === "RangeExpression" && inOf.token === "of" && !declaration2) {
+    return forRange(open, declaration, exp, step, close);
+  } else if (step) {
+    throw new Error("for..of/in cannot use 'by' except with range literals");
+  }
+  let eachOwnError;
+  let hoistDec, blockPrefix = [];
+  if (eachOwn && eachOwn[0].token === "each") {
+    if (inOf.token === "of") {
+      const counterRef = makeRef("i");
+      const lenRef = makeRef("len");
+      const expRef2 = maybeRef(exp);
+      const increment = "++";
+      let assignmentNames = [...declaration.names];
+      if (declaration2) {
+        const [, , ws22, decl22] = declaration2;
+        blockPrefix.push(["", [
+          insertTrimmingSpace(ws22, ""),
+          decl22,
+          " = ",
+          counterRef
+        ], ";"]);
+        assignmentNames.push(...decl22.names);
       }
+      const expRefDec = expRef2 !== exp ? [insertTrimmingSpace(expRef2, " "), " = ", insertTrimmingSpace(exp, ""), ", "] : [];
+      blockPrefix.push(["", {
+        type: "Declaration",
+        children: [declaration, " = ", insertTrimmingSpace(expRef2, ""), "[", counterRef, "]"],
+        names: assignmentNames
+      }, ";"]);
+      declaration = {
+        type: "Declaration",
+        children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", insertTrimmingSpace(expRef2, ""), ".length"],
+        names: []
+      };
+      const condition = [counterRef, " < ", lenRef, "; "];
+      const children = [open, declaration, "; ", condition, counterRef, increment, close];
+      return { declaration, children, blockPrefix };
+    } else {
+      eachOwnError = {
+        type: "Error",
+        message: "'each' is only meaningful in for..of loops"
+      };
     }
-    const existence = {
-      type: "Existence",
-      expression: exp,
-      children: [exp, post]
+  }
+  let own = eachOwn && eachOwn[0].token === "own";
+  let expRef;
+  if (own && inOf.token !== "in") {
+    own = false;
+    eachOwnError = {
+      type: "Error",
+      message: "'own' is only meaningful in for..in loops"
     };
-    exp = makeLeftHandSideExpression(existence);
-    if (pre.length) {
-      return {
-        type: "UnaryExpression",
-        children: [...pre, exp]
+  }
+  if (!declaration2 && !own) {
+    return {
+      declaration,
+      blockPrefix,
+      children: [awaits, eachOwnError, open, declaration, ws, inOf, expRef ?? exp, step, close]
+      // omit declaration2, replace eachOwn with eachOwnError, replace exp with expRef
+    };
+  }
+  let ws2, decl2;
+  if (declaration2)
+    [, , ws2, decl2] = declaration2;
+  switch (inOf.token) {
+    case "of": {
+      const counterRef = makeRef("i");
+      hoistDec = {
+        type: "Declaration",
+        children: ["let ", counterRef, " = 0"],
+        names: []
       };
+      blockPrefix.push(["", {
+        type: "Declaration",
+        children: [insertTrimmingSpace(ws2, ""), decl2, " = ", counterRef, "++"],
+        names: decl2.names
+      }, ";"]);
+      break;
     }
-    return exp;
-  }
-  if (exp.type === "Literal") {
-    if (pre.length === 1) {
-      const { token } = pre[0];
-      if (token === "-" || token === "+") {
-        const children = [pre[0], ...exp.children];
-        if (post)
-          exp.children.push(post);
-        return {
-          type: "Literal",
-          children,
-          raw: `${token}${exp.raw}`
+    case "in": {
+      const expRef2 = maybeRef(exp);
+      if (expRef2 !== exp) {
+        hoistDec = {
+          type: "Declaration",
+          children: ["let ", expRef2],
+          names: []
+        };
+        exp = {
+          type: "AssignmentExpression",
+          children: [" ", expRef2, " =", exp]
+        };
+      }
+      let { binding } = declaration;
+      if (binding?.type !== "Identifier") {
+        const keyRef = makeRef("key");
+        blockPrefix.push(["", [
+          declaration,
+          " = ",
+          keyRef
+        ], ";"]);
+        declaration = {
+          type: "ForDeclaration",
+          binding: binding = keyRef,
+          children: ["const ", keyRef],
+          names: []
         };
       }
-    }
-  }
-  const l = pre.length;
-  if (l) {
-    const last = pre[l - 1];
-    if (last.type === "Await" && last.op) {
-      if (exp.type !== "ParenthesizedExpression") {
-        exp = ["(", exp, ")"];
+      if (own) {
+        const hasPropRef = getRef("hasProp");
+        blockPrefix.push(["", ["if (!", hasPropRef, "(", insertTrimmingSpace(expRef2, ""), ", ", insertTrimmingSpace(binding, ""), ")) continue"], ";"]);
+      }
+      if (decl2) {
+        blockPrefix.push(["", {
+          type: "Declaration",
+          children: [insertTrimmingSpace(ws2, ""), decl2, " = ", insertTrimmingSpace(expRef2, ""), "[", insertTrimmingSpace(binding, ""), "]"],
+          names: decl2.names
+        }, ";"]);
       }
-      exp = {
-        type: "CallExpression",
-        children: [" Promise", last.op, exp]
-      };
+      break;
     }
+    default:
+      (() => {
+        throw new Error(`for item, index must use 'of' or 'in' instead of '${inOf.token}'`);
+      })();
   }
   return {
-    type: "UnaryExpression",
-    children: [...pre, exp, post]
+    declaration,
+    children: [awaits, eachOwnError, open, declaration, ws, inOf, exp, step, close],
+    // omit declaration2, replace each with eachOwnError
+    blockPrefix,
+    hoistDec
   };
 }
-var init_unary = __esm({
-  "source/parser/unary.civet"() {
+var init_for = __esm({
+  "source/parser/for.civet"() {
     "use strict";
     init_util();
   }
@@ -2919,7 +3136,6 @@ __export(lib_exports, {
   dedentBlockString: () => dedentBlockString,
   dedentBlockSubstitutions: () => dedentBlockSubstitutions,
   deepCopy: () => deepCopy,
-  expressionizeIfClause: () => expressionizeIfClause,
   expressionizeTypeIf: () => expressionizeTypeIf,
   forRange: () => forRange,
   gatherBindingCode: () => gatherBindingCode,
@@ -2954,6 +3170,7 @@ __export(lib_exports, {
   quoteString: () => quoteString,
   reorderBindingRestProperty: () => reorderBindingRestProperty,
   replaceNodes: () => replaceNodes,
+  skipImplicitArguments: () => skipImplicitArguments,
   typeOfJSX: () => typeOfJSX,
   wrapIIFE: () => wrapIIFE
 });
@@ -2992,16 +3209,71 @@ function negateCondition(condition) {
   };
   return { ...condition, expression, children };
 }
-function expressionizeIfClause(clause, b, e) {
-  const { condition } = clause;
+function isExpression(node) {
+  if (Array.isArray(node)) {
+    return node.every(isExpression);
+  }
+  if (typeof node === "string") {
+    return true;
+  }
+  switch (node?.type) {
+    case "BlockStatement":
+    case "DebuggerStatement":
+    case "Declaration":
+    case "IfStatement":
+    case "IterationStatement":
+    case "ReturnStatement":
+    case "SwitchStatement":
+    case "ThrowStatement":
+    case "TryStatement":
+      return false;
+  }
+  return true;
+}
+function expressionizeBlock(blockOrExpression) {
+  let ref1;
+  if ((ref1 = blockOrExpression) && "expressions" in ref1) {
+    const { expressions } = ref1;
+    const l = expressions.length;
+    const results = [];
+    let i1 = 0;
+    for (const [ws, s, _delim] of expressions) {
+      const i = i1++;
+      if (!isExpression(s))
+        return;
+      const wrapped = makeLeftHandSideExpression(s);
+      if (i === l - 1) {
+        results.push([ws, wrapped]);
+      } else {
+        results.push([ws, wrapped, ","]);
+      }
+    }
+    if (results.length > 1) {
+      return makeLeftHandSideExpression(results);
+    }
+    return results;
+  } else {
+    return blockOrExpression;
+  }
+}
+function expressionizeIfStatement(statement) {
+  const { condition, then: b, else: e } = statement;
   const [...condRest] = condition.children, [closeParen] = condRest.splice(-1);
+  const expressionizedBlock = expressionizeBlock(b);
+  if (!expressionizedBlock) {
+    return wrapIIFE([["", statement]]);
+  }
   const children = [
     ...condRest,
     "?",
-    b
+    expressionizedBlock
   ];
   if (e) {
-    children.push(e[0], ":", ...e.slice(2));
+    const e2 = expressionizeBlock(e[2]);
+    if (!e2) {
+      return wrapIIFE([["", statement]]);
+    }
+    children.push(e[0], ":", e2, ...e.slice(3));
   } else {
     children.push(":void 0");
   }
@@ -3065,17 +3337,17 @@ function processCallMemberExpression(node) {
     let call = children[1];
     const args = [...call.args];
     call = { ...call, args };
-    let ref1;
-    if (ref1 = isComma(args.at(-1))) {
-      const comma = ref1;
+    let ref2;
+    if (ref2 = isComma(args.at(-1))) {
+      const comma = ref2;
       comma.token = "";
     }
     let commaCount = 0;
-    for (let i1 = 0, len1 = args.length; i1 < len1; i1++) {
-      const arg = args[i1];
-      let ref2;
-      if (ref2 = isComma(arg)) {
-        const comma = ref2;
+    for (let i2 = 0, len1 = args.length; i2 < len1; i2++) {
+      const arg = args[i2];
+      let ref3;
+      if (ref3 = isComma(arg)) {
+        const comma = ref3;
         comma.token = `)${op.token}(`;
         commaCount++;
       }
@@ -3212,9 +3484,9 @@ function replaceNode(node, newNode) {
     throw new Error("replaceNode failed: node has no parent");
   }
   function recurse(children) {
-    for (let i2 = 0, len2 = children.length; i2 < len2; i2++) {
-      const i = i2;
-      const child = children[i2];
+    for (let i3 = 0, len2 = children.length; i3 < len2; i3++) {
+      const i = i3;
+      const child = children[i3];
       if (child === node) {
         children[i] = newNode;
         return true;
@@ -3381,55 +3653,6 @@ function makeGetterMethod(name, ws, value, returnType, block, kind = { token: "g
     parameters
   };
 }
-function processAssignmentDeclaration(decl, pattern, suffix, ws, assign, e) {
-  decl = {
-    ...decl,
-    $loc: {
-      pos: assign.$loc.pos - 1,
-      length: assign.$loc.length + 1
-    }
-  };
-  let [splices, assignments] = gatherBindingCode(pattern);
-  splices = splices.map((s) => [", ", s]);
-  const thisAssignments = assignments.map((a) => ["", a, ";"]);
-  const initializer = [ws, assign, e];
-  const binding = makeNode({
-    type: "Binding",
-    pattern,
-    initializer,
-    splices,
-    suffix,
-    thisAssignments,
-    children: [pattern, suffix, initializer]
-  });
-  const children = [decl, binding];
-  return makeNode({
-    type: "Declaration",
-    names: pattern.names,
-    decl,
-    bindings: [binding],
-    splices,
-    thisAssignments,
-    children
-  });
-}
-function processDeclarations(statements) {
-  gatherRecursiveAll(statements, ($) => $.type === "Declaration").forEach(({ bindings }) => {
-    return bindings?.forEach((binding) => {
-      const suffix = binding.suffix;
-      if (suffix && suffix.optional && suffix.t) {
-        convertOptionalType(suffix);
-      }
-      const { initializer } = binding;
-      if (initializer) {
-        const exp = initializer[2];
-        return exp;
-      }
-      ;
-      return;
-    });
-  });
-}
 function processBindingPatternLHS(lhs, tail) {
   adjustAtBindings(lhs, true);
   const [splices, thisAssignments] = gatherBindingCode(lhs);
@@ -3483,8 +3706,25 @@ function processAssignments(statements) {
       return exp.children.push(...post);
     return;
   });
-  gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
+  replaceNodesRecursive(statements, (n) => n.type === "AssignmentExpression" && n.names === null, (exp) => {
     let { lhs: $1, exp: $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([null, null, $2], block)) {
+        const ref = ref4;
+        exp.children = exp.children.map(function(c) {
+          if (c === $2)
+            return ref;
+          else
+            return c;
+        });
+        $2 = ref;
+      } else {
+        block = void 0;
+      }
+    }
     if ($1.some((left) => left[left.length - 1].special)) {
       if ($1.length !== 1)
         throw new Error("Only one assignment with id= is allowed");
@@ -3499,7 +3739,7 @@ function processAssignments(statements) {
         exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
       );
       if (omitLhs) {
-        replaceNode(exp, $2);
+        return $2;
       }
     }
     let wrapped = false;
@@ -3544,7 +3784,7 @@ function processAssignments(statements) {
             }
             exp.children = [$1];
             exp.names = [];
-            return;
+            return exp;
           }
         } else if (lhs.type === "ObjectBindingPattern" || lhs.type === "ArrayBindingPattern") {
           processBindingPatternLHS(lhs, tail);
@@ -3556,11 +3796,19 @@ function processAssignments(statements) {
     const index = exp.children.indexOf($2);
     if (index < 0)
       throw new Error("Assertion error: exp not in AssignmentExpression");
-    return exp.children.splice(index + 1, 0, ...tail);
+    exp.children.splice(index + 1, 0, ...tail);
+    if (block) {
+      block.parent = exp.parent;
+      block.expressions.push(["", exp]);
+      exp.parent = block;
+      return block;
+    }
+    return exp;
   });
 }
 function attachPostfixStatementAsExpression(exp, post) {
-  switch (post[1].type) {
+  const postfixStatement = post[1];
+  switch (postfixStatement.type) {
     case "ForStatement":
     case "IterationStatement":
     case "DoStatement": {
@@ -3573,9 +3821,9 @@ function attachPostfixStatementAsExpression(exp, post) {
       };
     }
     case "IfStatement":
-      return expressionizeIfClause(post[1], exp);
+      return expressionizeIfStatement({ ...postfixStatement, then: exp });
     default:
-      (() => {
+      return (() => {
         throw new Error("Unknown postfix statement");
       })();
   }
@@ -3614,6 +3862,42 @@ function processTypes(node) {
     }
   });
 }
+function processStatementExpressions(statements) {
+  gatherRecursiveAll(statements, ($) => $.type === "StatementExpression").forEach((_exp) => {
+    const exp = _exp;
+    const { statement } = exp;
+    let ws;
+    if (!(exp.children[0] === exp.statement)) {
+      ws = exp.children[0];
+    }
+    let ref5;
+    switch (statement.type) {
+      case "IfStatement": {
+        if (ref5 = expressionizeIfStatement(statement)) {
+          const expression = ref5;
+          exp.statement = expression;
+          exp.children = [exp.statement];
+        } else {
+          exp.children = wrapIIFE([["", statement]]);
+        }
+        ;
+        break;
+      }
+      case "IterationExpression": {
+        ;
+        break;
+      }
+      default: {
+        exp.children = wrapIIFE([["", statement]]);
+      }
+    }
+    if (ws) {
+      return exp.children.unshift(ws);
+    }
+    ;
+    return;
+  });
+}
 function processProgram(root, config, m, ReservedWord) {
   assert.equal(m.forbidBracedApplication.length, 1, "forbidBracedApplication");
   assert.equal(m.forbidClassImplicitCall.length, 1, "forbidClassImplicitCall");
@@ -3624,11 +3908,12 @@ function processProgram(root, config, m, ReservedWord) {
   addParentPointers(root);
   const { expressions: statements } = root;
   processTypes(statements);
-  processDeclarationConditions(statements);
+  processDeclarationConditions(statements, m.getRef);
   processPipelineExpressions(statements);
   processDeclarations(statements);
   processAssignments(statements);
-  processPatternMatching(statements, ReservedWord);
+  processStatementExpressions(statements);
+  processPatternMatching(statements, ReservedWord, m.getRef);
   gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
   hoistRefDecs(statements);
   processFunctions(statements, config);
@@ -3732,9 +4017,9 @@ function replaceNodes(root, predicate, replacer) {
       return root;
     }
   }
-  for (let i3 = 0, len3 = array.length; i3 < len3; i3++) {
-    const i = i3;
-    const node = array[i3];
+  for (let i4 = 0, len3 = array.length; i4 < len3; i4++) {
+    const i = i4;
+    const node = array[i4];
     if (!(node != null)) {
       return;
     }
@@ -3746,6 +4031,34 @@ function replaceNodes(root, predicate, replacer) {
   }
   return root;
 }
+function replaceNodesRecursive(root, predicate, replacer) {
+  if (!(root != null)) {
+    return root;
+  }
+  const array = Array.isArray(root) ? root : root.children;
+  if (!array) {
+    if (predicate(root)) {
+      return replacer(root, root);
+    } else {
+      return root;
+    }
+  }
+  for (let i5 = 0, len4 = array.length; i5 < len4; i5++) {
+    const i = i5;
+    const node = array[i5];
+    if (!(node != null)) {
+      continue;
+    }
+    if (predicate(node)) {
+      const ret = replacer(node, root);
+      replaceNodesRecursive(ret, predicate, replacer);
+      array[i] = ret;
+    } else {
+      replaceNodesRecursive(node, predicate, replacer);
+    }
+  }
+  return root;
+}
 function typeOfJSX(node, config, getRef) {
   switch (node.type) {
     case "JSXElement":
@@ -3810,13 +4123,14 @@ function typeOfJSXFragment(node, config, getRef) {
   ;
   return;
 }
-var xor, assert;
+var xor;
 var init_lib = __esm({
   "source/parser/lib.civet"() {
     "use strict";
     init_traversal();
     init_util();
     init_block();
+    init_declaration();
     init_pipe();
     init_for();
     init_function();
@@ -3827,19 +4141,12 @@ var init_lib = __esm({
     init_auto_dec();
     init_string();
     xor = (a, b) => a ? !b && a : b;
-    assert = {
-      equal(a, b, msg) {
-        if (a !== b) {
-          throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`);
-        }
-      }
-    };
   }
 });
 
-// node_modules/@danielx/hera/dist/machine.js
+// ../Hera/dist/machine.js
 var require_machine = __commonJS({
-  "node_modules/@danielx/hera/dist/machine.js"(exports, module) {
+  "../Hera/dist/machine.js"(exports, module) {
     "use strict";
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -4310,8 +4617,6 @@ var require_parser = __commonJS({
       $TV,
       $Y,
       Parser,
-      ParserContext,
-      ParserOptions,
       Validator
     } = require_machine();
     var grammar = {
@@ -4328,7 +4633,7 @@ var require_parser = __commonJS({
       NestedNonAssignmentExtendedExpression,
       ExpressionizedStatementWithTrailingCallExpressions,
       ExpressionizedStatement,
-      _ExpressionizedStatement,
+      StatementExpression,
       CommaExpression,
       Arguments,
       ImplicitArguments,
@@ -4590,14 +4895,6 @@ var require_parser = __commonJS({
       ElseClause,
       IfClause,
       UnlessClause,
-      IfExpression,
-      UnlessExpression,
-      ElseExpressionClause,
-      ExpressionBlock,
-      ElseExpressionBlock,
-      NestedBlockExpressions,
-      NestedBlockExpression,
-      BlockExpressionPart,
       IterationStatement,
       _IterationStatement,
       IterationExpression,
@@ -4621,7 +4918,6 @@ var require_parser = __commonJS({
       ForBinding,
       SwitchStatement,
       EmptyCondition,
-      SwitchExpression,
       CaseBlock,
       NestedCaseClauses,
       NestedCaseClause,
@@ -4633,7 +4929,6 @@ var require_parser = __commonJS({
       ImpliedColon,
       IgnoreColon,
       TryStatement,
-      TryExpression,
       CatchClause,
       CatchBind,
       FinallyClause,
@@ -4674,8 +4969,6 @@ var require_parser = __commonJS({
       Break,
       Continue,
       Debugger,
-      DebuggerExpression,
-      ThrowExpression,
       MaybeNestedExpression,
       ImportDeclaration,
       ImpliedImport,
@@ -5505,22 +5798,26 @@ var require_parser = __commonJS({
     function ExpressionizedStatementWithTrailingCallExpressions(ctx, state) {
       return $EVENT(ctx, state, "ExpressionizedStatementWithTrailingCallExpressions", ExpressionizedStatementWithTrailingCallExpressions$0);
     }
-    var ExpressionizedStatement$0 = $T($S($EXPECT($R0, "ExpressionizedStatement /(?=async|debugger|if|unless|do|for|loop|until|while|switch|throw|try)/"), _ExpressionizedStatement), function(value) {
-      return value[1];
+    var ExpressionizedStatement$0 = $TS($S($EXPECT($R0, "ExpressionizedStatement /(?=async|debugger|if|unless|do|for|loop|until|while|switch|throw|try)/"), StatementExpression), function($skip, $loc, $0, $1, $2) {
+      var statement = $2;
+      return {
+        type: "StatementExpression",
+        statement,
+        children: [statement]
+      };
     });
     function ExpressionizedStatement(ctx, state) {
       return $EVENT(ctx, state, "ExpressionizedStatement", ExpressionizedStatement$0);
     }
-    var _ExpressionizedStatement$0 = DebuggerExpression;
-    var _ExpressionizedStatement$1 = IfExpression;
-    var _ExpressionizedStatement$2 = UnlessExpression;
-    var _ExpressionizedStatement$3 = IterationExpression;
-    var _ExpressionizedStatement$4 = SwitchExpression;
-    var _ExpressionizedStatement$5 = ThrowExpression;
-    var _ExpressionizedStatement$6 = TryExpression;
-    var _ExpressionizedStatement$$ = [_ExpressionizedStatement$0, _ExpressionizedStatement$1, _ExpressionizedStatement$2, _ExpressionizedStatement$3, _ExpressionizedStatement$4, _ExpressionizedStatement$5, _ExpressionizedStatement$6];
-    function _ExpressionizedStatement(ctx, state) {
-      return $EVENT_C(ctx, state, "_ExpressionizedStatement", _ExpressionizedStatement$$);
+    var StatementExpression$0 = DebuggerStatement;
+    var StatementExpression$1 = IfStatement;
+    var StatementExpression$2 = IterationExpression;
+    var StatementExpression$3 = SwitchStatement;
+    var StatementExpression$4 = ThrowStatement;
+    var StatementExpression$5 = TryStatement;
+    var StatementExpression$$ = [StatementExpression$0, StatementExpression$1, StatementExpression$2, StatementExpression$3, StatementExpression$4, StatementExpression$5];
+    function StatementExpression(ctx, state) {
+      return $EVENT_C(ctx, state, "StatementExpression", StatementExpression$$);
     }
     var CommaExpression$0 = $TS($S(AssignmentExpression, $Q($S(CommaDelimiter, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
       if ($2.length == 0)
@@ -5546,14 +5843,8 @@ var require_parser = __commonJS({
       var ws = $3;
       var args = $4;
       var close = $5;
-      if (args.length === 1) {
-        let arg0 = args[0];
-        if (Array.isArray(arg0))
-          arg0 = arg0[1];
-        if (arg0.type === "IterationExpression" && arg0.subtype !== "DoStatement" && !arg0.async && isEmptyBareBlock(arg0.block)) {
-          return $skip;
-        }
-      }
+      if (skipImplicitArguments(args))
+        return $skip;
       return {
         type: "Call",
         args,
@@ -6111,8 +6402,12 @@ var require_parser = __commonJS({
     function PipelineHeadItem(ctx, state) {
       return $EVENT_C(ctx, state, "PipelineHeadItem", PipelineHeadItem$$);
     }
-    var PipelineTailItem$0 = Await;
-    var PipelineTailItem$1 = Yield;
+    var PipelineTailItem$0 = $T($S(AwaitOp, $N(AccessStart)), function(value) {
+      return value[0];
+    });
+    var PipelineTailItem$1 = $T($S(Yield, $N(AccessStart)), function(value) {
+      return value[0];
+    });
     var PipelineTailItem$2 = $T($S(Return, $N(AccessStart)), function(value) {
       return value[0];
     });
@@ -6148,6 +6443,9 @@ var require_parser = __commonJS({
         return $skip;
       const [exp, ws, close] = $3;
       switch (exp.type) {
+        case "StatementExpression":
+          if (exp.statement.type !== "IterationExpression")
+            break;
         case "IterationExpression":
           return exp;
         case "ParenthesizedExpression":
@@ -7675,7 +7973,7 @@ var require_parser = __commonJS({
       if (prefix.length) {
         body = {
           type: "UnaryExpression",
-          children: [prefix, body, void 0]
+          children: [processUnaryExpression(prefix, body, void 0)]
         };
       }
       const parameters = {
@@ -9192,8 +9490,9 @@ var require_parser = __commonJS({
       return $EVENT_C(ctx, state, "MethodSignature", MethodSignature$$);
     }
     var ClassElementName$0 = PropertyName;
-    var ClassElementName$1 = PrivateIdentifier;
-    var ClassElementName$$ = [ClassElementName$0, ClassElementName$1];
+    var ClassElementName$1 = LengthShorthand;
+    var ClassElementName$2 = PrivateIdentifier;
+    var ClassElementName$$ = [ClassElementName$0, ClassElementName$1, ClassElementName$2];
     function ClassElementName(ctx, state) {
       return $EVENT_C(ctx, state, "ClassElementName", ClassElementName$$);
     }
@@ -9632,7 +9931,13 @@ var require_parser = __commonJS({
       return { $loc, token: $0 };
     });
     var UnaryOp$1 = AwaitOp;
-    var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($R$0($EXPECT($R21, "UnaryOp /[:.]/"))), $E(_));
+    var UnaryOp$2 = $TS($S($C(Delete, Void, Typeof), $N($EXPECT($R21, "UnaryOp /[:.]/")), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
+      var op = $1;
+      var ws = $3;
+      if (!ws)
+        return [op, [" "]];
+      return [op, ws];
+    });
     var UnaryOp$3 = $T($S(Not, $N($EXPECT($R21, "UnaryOp /[:.]/")), $E($EXPECT($L16, 'UnaryOp " "')), $E(_)), function(value) {
       return [value[0], value[3]];
     });
@@ -9640,18 +9945,15 @@ var require_parser = __commonJS({
     function UnaryOp(ctx, state) {
       return $EVENT_C(ctx, state, "UnaryOp", UnaryOp$$);
     }
-    var AwaitOp$0 = $TS($S(Await, $E($S(Dot, IdentifierName)), $C($Y(OpenParen), _, $Y(EOS))), function($skip, $loc, $0, $1, $2, $3) {
+    var AwaitOp$0 = $TS($S(Await, $E($S(Dot, IdentifierName)), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
       var a = $1;
       var op = $2;
       var ws = $3;
-      if (op) {
-        return {
-          ...a,
-          op,
-          children: [a, ...ws || []]
-        };
-      }
-      return [a, ...ws || []];
+      return {
+        ...a,
+        op,
+        children: [a, ...ws || [" "]]
+      };
     });
     function AwaitOp(ctx, state) {
       return $EVENT(ctx, state, "AwaitOp", AwaitOp$0);
@@ -9864,120 +10166,6 @@ var require_parser = __commonJS({
     function UnlessClause(ctx, state) {
       return $EVENT(ctx, state, "UnlessClause", UnlessClause$0);
     }
-    var IfExpression$0 = $TS($S(IfClause, ExpressionBlock, $E(ElseExpressionClause)), function($skip, $loc, $0, $1, $2, $3) {
-      var clause = $1;
-      var b = $2;
-      var e = $3;
-      return expressionizeIfClause(clause, b, e);
-    });
-    function IfExpression(ctx, state) {
-      return $EVENT(ctx, state, "IfExpression", IfExpression$0);
-    }
-    var UnlessExpression$0 = $TS($S(UnlessClause, ExpressionBlock, $E(ElseExpressionClause)), function($skip, $loc, $0, $1, $2, $3) {
-      var clause = $1;
-      var b = $2;
-      var e = $3;
-      return expressionizeIfClause(clause, b, e);
-    });
-    function UnlessExpression(ctx, state) {
-      return $EVENT(ctx, state, "UnlessExpression", UnlessExpression$0);
-    }
-    var ElseExpressionClause$0 = $TS($S($C($S(Nested, Else), $S($E(_), Else)), ElseExpressionBlock), function($skip, $loc, $0, $1, $2) {
-      return [...$1, $2];
-    });
-    function ElseExpressionClause(ctx, state) {
-      return $EVENT(ctx, state, "ElseExpressionClause", ElseExpressionClause$0);
-    }
-    var ExpressionBlock$0 = $TS($S(InsertOpenParen, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-      var exps = $2;
-      exps = exps.flat();
-      if (exps.length === 1) {
-        let [ws, exp] = exps[0];
-        switch (exp.type) {
-          case "Identifier":
-          case "Literal":
-            return [ws, exp];
-        }
-      }
-      exps = exps.map((e, i) => {
-        if (i === exps.length - 1) {
-          return e.slice(0, -1);
-        }
-        return e;
-      });
-      return {
-        type: "BlockExpressions",
-        expressions: exps,
-        children: [$1, exps, $3, $4, $5]
-      };
-    });
-    var ExpressionBlock$1 = $S(Then, ExtendedExpression);
-    var ExpressionBlock$$ = [ExpressionBlock$0, ExpressionBlock$1];
-    function ExpressionBlock(ctx, state) {
-      return $EVENT_C(ctx, state, "ExpressionBlock", ExpressionBlock$$);
-    }
-    var ElseExpressionBlock$0 = $TS($S(InsertOpenParen, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-      var exps = $2;
-      exps = exps.flat();
-      if (exps.length === 1) {
-        let [ws, exp] = exps[0];
-        switch (exp.type) {
-          case "Identifier":
-          case "Literal":
-            return [ws, exp];
-        }
-      }
-      exps = exps.map((e, i) => {
-        if (i === exps.length - 1) {
-          return e.slice(0, -1);
-        }
-        return e;
-      });
-      return {
-        type: "BlockExpressions",
-        expressions: exps,
-        children: [$1, exps, $3, $4, $5]
-      };
-    });
-    var ElseExpressionBlock$1 = $T($S($N(EOS), ExpressionWithObjectApplicationForbidden), function(value) {
-      return value[1];
-    });
-    var ElseExpressionBlock$$ = [ElseExpressionBlock$0, ElseExpressionBlock$1];
-    function ElseExpressionBlock(ctx, state) {
-      return $EVENT_C(ctx, state, "ElseExpressionBlock", ElseExpressionBlock$$);
-    }
-    var NestedBlockExpressions$0 = $TS($S(PushIndent, $Q(NestedBlockExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-      var exps = $2;
-      if (!exps.length)
-        return $skip;
-      return exps;
-    });
-    function NestedBlockExpressions(ctx, state) {
-      return $EVENT(ctx, state, "NestedBlockExpressions", NestedBlockExpressions$0);
-    }
-    var NestedBlockExpression$0 = $TS($S(Nested, $P(BlockExpressionPart)), function($skip, $loc, $0, $1, $2) {
-      var nested = $1;
-      var expressions = $2;
-      return [
-        [nested, ...expressions[0]],
-        ...expressions.slice(1).map((s) => ["", ...s])
-      ];
-    });
-    function NestedBlockExpression(ctx, state) {
-      return $EVENT(ctx, state, "NestedBlockExpression", NestedBlockExpression$0);
-    }
-    var BlockExpressionPart$0 = $TS($S($N(EOS), $E(_), PostfixedExpression, ExpressionDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
-      var ws = $2;
-      var exp = $3;
-      var delimiter = $4;
-      if (ws) {
-        exp = { ...exp, children: [ws, ...exp.children] };
-      }
-      return [exp, delimiter];
-    });
-    function BlockExpressionPart(ctx, state) {
-      return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
-    }
     var IterationStatement$0 = $T($S($EXPECT($R23, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
       return value[1];
     });
@@ -10394,18 +10582,6 @@ var require_parser = __commonJS({
     function EmptyCondition(ctx, state) {
       return $EVENT(ctx, state, "EmptyCondition", EmptyCondition$0);
     }
-    var SwitchExpression$0 = $TV(SwitchStatement, function($skip, $loc, $0, $1) {
-      var s = $0;
-      return {
-        type: "SwitchExpression",
-        // wrap with IIFE
-        children: wrapIIFE([["", s]]),
-        statement: s
-      };
-    });
-    function SwitchExpression(ctx, state) {
-      return $EVENT(ctx, state, "SwitchExpression", SwitchExpression$0);
-    }
     var CaseBlock$0 = $TS($S($E($C(Nested, _)), OpenBrace, NestedCaseClauses, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var clauses = $3;
       return {
@@ -10587,17 +10763,6 @@ var require_parser = __commonJS({
     function TryStatement(ctx, state) {
       return $EVENT(ctx, state, "TryStatement", TryStatement$0);
     }
-    var TryExpression$0 = $TV(TryStatement, function($skip, $loc, $0, $1) {
-      var t = $0;
-      return {
-        type: "TryExpression",
-        blocks: t.blocks,
-        children: wrapIIFE([["", t]])
-      };
-    });
-    function TryExpression(ctx, state) {
-      return $EVENT(ctx, state, "TryExpression", TryExpression$0);
-    }
     var CatchClause$0 = $TS($S($C(Nested, _), Catch, $E(CatchBind), $C(BracedThenClause, BracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4) {
       var block = $4;
       return {
@@ -10932,26 +11097,6 @@ var require_parser = __commonJS({
     function Debugger(ctx, state) {
       return $EVENT(ctx, state, "Debugger", Debugger$0);
     }
-    var DebuggerExpression$0 = $TV(DebuggerStatement, function($skip, $loc, $0, $1) {
-      var s = $0;
-      return {
-        type: "DebuggerExpression",
-        children: wrapIIFE([["", s]])
-      };
-    });
-    function DebuggerExpression(ctx, state) {
-      return $EVENT(ctx, state, "DebuggerExpression", DebuggerExpression$0);
-    }
-    var ThrowExpression$0 = $TV(ThrowStatement, function($skip, $loc, $0, $1) {
-      var s = $0;
-      return {
-        type: "ThrowExpression",
-        children: wrapIIFE([["", s]])
-      };
-    });
-    function ThrowExpression(ctx, state) {
-      return $EVENT(ctx, state, "ThrowExpression", ThrowExpression$0);
-    }
     var MaybeNestedExpression$0 = $TS($S($N(EOS), ExtendedExpression), function($skip, $loc, $0, $1, $2) {
       return $2;
     });
@@ -10973,27 +11118,26 @@ var require_parser = __commonJS({
         children: [imp, $0.slice(1)]
       };
     });
-    var ImportDeclaration$1 = $T($S(Import, __, TypeKeyword, __, ImportClause, __, FromClause, $E(ImportAssertion)), function(value) {
+    var ImportDeclaration$1 = $T($S(Import, __, TypeKeyword, __, ImportClause, __, FromClause), function(value) {
       return { "type": "ImportDeclaration", "ts": true, "children": value };
     });
-    var ImportDeclaration$2 = $T($S(Import, __, ImportClause, __, FromClause, $E(ImportAssertion)), function(value) {
+    var ImportDeclaration$2 = $T($S(Import, __, ImportClause, __, FromClause), function(value) {
       return { "type": "ImportDeclaration", "children": value };
     });
-    var ImportDeclaration$3 = $T($S(Import, __, ModuleSpecifier, $E(ImportAssertion)), function(value) {
+    var ImportDeclaration$3 = $T($S(Import, __, ModuleSpecifier), function(value) {
       return { "type": "ImportDeclaration", "children": value };
     });
-    var ImportDeclaration$4 = $TS($S(ImpliedImport, $E($S(TypeKeyword, __)), ImportClause, __, FromClause, $E(ImportAssertion)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+    var ImportDeclaration$4 = $TS($S(ImpliedImport, $E($S(TypeKeyword, __)), ImportClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var i = $1;
       var t = $2;
       var c = $3;
       var w = $4;
       var f = $5;
-      var a = $6;
       i.$loc = {
         pos: f[0].$loc.pos - 1,
         length: f[0].$loc.length + 1
       };
-      const children = [i, t, c, w, f, a];
+      const children = [i, t, c, w, f];
       if (!t)
         return children;
       return { type: "ImportDeclaration", ts: true, children };
@@ -11152,7 +11296,8 @@ var require_parser = __commonJS({
     function ModuleExportName(ctx, state) {
       return $EVENT_C(ctx, state, "ModuleExportName", ModuleExportName$$);
     }
-    var ModuleSpecifier$0 = $TS($S(UnprocessedModuleSpecifier), function($skip, $loc, $0, $1) {
+    var ModuleSpecifier$0 = $TS($S(UnprocessedModuleSpecifier, $E(ImportAssertion)), function($skip, $loc, $0, $1, $2) {
+      var a = $2;
       let { token } = $1;
       if (module.config.rewriteTsImports) {
         token = token.replace(/\.([mc])?ts(['"])$/, ".$1js$2");
@@ -11163,6 +11308,8 @@ var require_parser = __commonJS({
           `${module.config.rewriteCivetImports.replace(/\$/g, "$$")}$1`
         );
       }
+      if (a)
+        return [{ ...$1, token }, a];
       return { ...$1, token };
     });
     function ModuleSpecifier(ctx, state) {
@@ -11527,7 +11674,11 @@ var require_parser = __commonJS({
     function TripleSingleStringCharacters(ctx, state) {
       return $EVENT(ctx, state, "TripleSingleStringCharacters", TripleSingleStringCharacters$0);
     }
-    var CoffeeStringSubstitution$0 = $S(CoffeeSubstitutionStart, PostfixedExpression, __, CloseBrace);
+    var CoffeeStringSubstitution$0 = $TS($S(CoffeeSubstitutionStart, AllowAll, $E($S(PostfixedExpression, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
+      if (!$3)
+        return $skip;
+      return [$1, ...$3];
+    });
     function CoffeeStringSubstitution(ctx, state) {
       return $EVENT(ctx, state, "CoffeeStringSubstitution", CoffeeStringSubstitution$0);
     }
@@ -11704,7 +11855,11 @@ var require_parser = __commonJS({
     function _TemplateLiteral(ctx, state) {
       return $EVENT_C(ctx, state, "_TemplateLiteral", _TemplateLiteral$$);
     }
-    var TemplateSubstitution$0 = $S(SubstitutionStart, PostfixedExpression, __, CloseBrace);
+    var TemplateSubstitution$0 = $TS($S(SubstitutionStart, AllowAll, $E($S(PostfixedExpression, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
+      if (!$3)
+        return $skip;
+      return [$1, ...$3];
+    });
     function TemplateSubstitution(ctx, state) {
       return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
     }
@@ -14069,7 +14224,9 @@ var require_parser = __commonJS({
     function TripleSlashDirective(ctx, state) {
       return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
     }
-    var DirectivePrologue$0 = PrologueString;
+    var DirectivePrologue$0 = $T($S(PrologueString, $N($S(__, $C(AccessStart, Pipe)))), function(value) {
+      return value[0];
+    });
     function DirectivePrologue(ctx, state) {
       return $EVENT(ctx, state, "DirectivePrologue", DirectivePrologue$0);
     }
@@ -14453,6 +14610,19 @@ var require_parser = __commonJS({
           };
           module.prelude.push(["", [preludeVar, isRef, typeSuffix, " = Object.is", asAny, ";\n"]]);
         },
+        /**
+         * Array length check with type guard.
+         * From tlgreg https://discord.com/channels/933472021310996512/1012166187196629113/1157386582546976873
+         */
+        len(lenRef) {
+          module.prelude.push(["", [{
+            ts: true,
+            children: ["function ", lenRef, "<T extends readonly unknown[], N extends number>(arr: T, length: N): arr is T & { length: N } { return arr.length === length }"]
+          }, {
+            js: true,
+            children: ["function ", lenRef, "(arr, length) { return arr.length === length }"]
+          }], "\n"]);
+        },
         modulo(moduloRef) {
           const typeSuffix = {
             ts: true,
@@ -14604,9 +14774,9 @@ var require_parser = __commonJS({
           }
         }
       });
-      if (typeof parse !== "undefined") {
-        Object.assign(module.config, parse.config);
-        parse.config = module.config;
+      if (typeof parse2 !== "undefined") {
+        Object.assign(module.config, parse2.config);
+        parse2.config = module.config;
       } else {
         Object.assign(module.config, exports.parse.config);
         exports.parse.config = module.config;
@@ -14757,7 +14927,7 @@ var require_parser = __commonJS({
       };
     }();
     exports.default = parser;
-    exports.parse = parser.parse;
+    var parse2 = exports.parse = parser.parse;
     exports.Program = Program;
     exports.TopLevelStatements = TopLevelStatements;
     exports.NestedTopLevelStatements = NestedTopLevelStatements;
@@ -14771,7 +14941,7 @@ var require_parser = __commonJS({
     exports.NestedNonAssignmentExtendedExpression = NestedNonAssignmentExtendedExpression;
     exports.ExpressionizedStatementWithTrailingCallExpressions = ExpressionizedStatementWithTrailingCallExpressions;
     exports.ExpressionizedStatement = ExpressionizedStatement;
-    exports._ExpressionizedStatement = _ExpressionizedStatement;
+    exports.StatementExpression = StatementExpression;
     exports.CommaExpression = CommaExpression;
     exports.Arguments = Arguments;
     exports.ImplicitArguments = ImplicitArguments;
@@ -15033,14 +15203,6 @@ var require_parser = __commonJS({
     exports.ElseClause = ElseClause;
     exports.IfClause = IfClause;
     exports.UnlessClause = UnlessClause;
-    exports.IfExpression = IfExpression;
-    exports.UnlessExpression = UnlessExpression;
-    exports.ElseExpressionClause = ElseExpressionClause;
-    exports.ExpressionBlock = ExpressionBlock;
-    exports.ElseExpressionBlock = ElseExpressionBlock;
-    exports.NestedBlockExpressions = NestedBlockExpressions;
-    exports.NestedBlockExpression = NestedBlockExpression;
-    exports.BlockExpressionPart = BlockExpressionPart;
     exports.IterationStatement = IterationStatement;
     exports._IterationStatement = _IterationStatement;
     exports.IterationExpression = IterationExpression;
@@ -15064,7 +15226,6 @@ var require_parser = __commonJS({
     exports.ForBinding = ForBinding;
     exports.SwitchStatement = SwitchStatement;
     exports.EmptyCondition = EmptyCondition;
-    exports.SwitchExpression = SwitchExpression;
     exports.CaseBlock = CaseBlock;
     exports.NestedCaseClauses = NestedCaseClauses;
     exports.NestedCaseClause = NestedCaseClause;
@@ -15076,7 +15237,6 @@ var require_parser = __commonJS({
     exports.ImpliedColon = ImpliedColon;
     exports.IgnoreColon = IgnoreColon;
     exports.TryStatement = TryStatement;
-    exports.TryExpression = TryExpression;
     exports.CatchClause = CatchClause;
     exports.CatchBind = CatchBind;
     exports.FinallyClause = FinallyClause;
@@ -15117,8 +15277,6 @@ var require_parser = __commonJS({
     exports.Break = Break;
     exports.Continue = Continue;
     exports.Debugger = Debugger;
-    exports.DebuggerExpression = DebuggerExpression;
-    exports.ThrowExpression = ThrowExpression;
     exports.MaybeNestedExpression = MaybeNestedExpression;
     exports.ImportDeclaration = ImportDeclaration;
     exports.ImpliedImport = ImpliedImport;