@danielx/civet 0.6.82 → 0.6.83

package/dist/browser.js

@@ -278,27 +278,25 @@ var Civet = (() => {
       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) {
@@ -413,7 +411,9 @@ var Civet = (() => {
       type: "BlockStatement",
       expressions,
       children: ["{", expressions, "}"],
-      bare: false
+      bare: false,
+      root: false,
+      parent: void 0
     });
     const parameters = {
       type: "Parameters",
@@ -452,11 +452,18 @@ var Civet = (() => {
       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",
@@ -616,6 +623,17 @@ var Civet = (() => {
       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;
@@ -747,523 +765,800 @@ var Civet = (() => {
     }
   });
 
-  // 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];
+      return node;
     }
-    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, " = "];
+  }
+  function isExistence(exp) {
+    if (exp.type === "ParenthesizedExpression" && exp.implicit) {
+      exp = exp.expression;
     }
-    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
-    };
+    if (exp.type === "Existence") {
+      return exp;
+    }
+    ;
+    return;
   }
-  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 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++;
     }
-    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 };
+    if (op != null) {
+      processChains(op);
+    }
+    return results;
+    function processChains(op2) {
+      if (first && isRelationalOp(op2)) {
+        first = expandExistence(first);
+      }
+      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 {
-        eachOwnError = {
-          type: "Error",
-          message: "'each' is only meaningful in for..of loops"
-        };
+        if (first) {
+          results.push(first);
+        }
+        results.push(...binops.slice(start, i + 1).flat());
+        start = i + 1;
       }
+      chains.length = 0;
     }
-    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"
-      };
+    function expandExistence(exp) {
+      const existence = isExistence(exp);
+      if (existence) {
+        results.push(existence, " ", "&&", " ");
+        return existence.expression;
+      }
+      return 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
+    ;
+  }
+  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"]
       };
     }
-    let ws2, decl2;
-    if (declaration2)
-      [, , ws2, decl2] = declaration2;
-    switch (inOf.token) {
-      case "of": {
-        const counterRef = makeRef("i");
+  });
+
+  // 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;
+          }
+        }
+      }
+      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 ", counterRef, " = 0"],
+          children: ["let ", ref],
           names: []
         };
-        blockPrefix.push(["", {
-          type: "Declaration",
-          children: [insertTrimmingSpace(ws2, ""), decl2, " = ", counterRef, "++"],
-          names: decl2.names
-        }, ";"]);
-        break;
+        refAssignment = [{
+          type: "AssignmentExpression",
+          children: [ref, " = ", condition]
+        }, ","];
       }
-      case "in": {
-        const expRef2 = maybeRef(exp);
-        if (expRef2 !== exp) {
-          hoistDec = {
-            type: "Declaration",
-            children: ["let ", expRef2],
-            names: []
-          };
-          exp = {
-            type: "AssignmentExpression",
-            children: [" ", expRef2, " =", exp]
-          };
+      let prev = [], root = prev;
+      const l = clauses.length;
+      clauses.forEach((c, i) => {
+        if (c.type === "DefaultClause") {
+          prev.push(c.block);
+          return;
         }
-        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: []
-          };
+        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;
+          }
         }
-        if (own) {
-          const hasPropRef = getRef("hasProp");
-          blockPrefix.push(["", ["if (!", hasPropRef, "(", insertTrimmingSpace(expRef2, ""), ", ", insertTrimmingSpace(binding, ""), ")) continue"], ";"]);
+        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);
+          });
         }
-        if (decl2) {
-          blockPrefix.push(["", {
-            type: "Declaration",
-            children: [insertTrimmingSpace(ws2, ""), decl2, " = ", insertTrimmingSpace(expRef2, ""), "[", insertTrimmingSpace(binding, ""), "]"],
-            names: decl2.names
-          }, ";"]);
+        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, ")"]
+        );
         break;
       }
+      case "PinPattern":
+        conditions.push([
+          ref,
+          " === ",
+          pattern.expression
+        ]);
+        break;
+      case "Literal":
+        conditions.push([
+          ref,
+          " === ",
+          pattern
+        ]);
+        break;
       default:
-        (() => {
-          throw new Error(`for item, index must use 'of' or 'in' instead of '${inOf.token}'`);
-        })();
+        break;
     }
-    return {
-      declaration,
-      children: [awaits, eachOwnError, open, declaration, ws, inOf, exp, step, close],
-      // omit declaration2, replace each with eachOwnError
-      blockPrefix,
-      hoistDec
-    };
   }
-  var init_for = __esm({
-    "source/parser/for.civet"() {
-      "use strict";
-      init_util();
-    }
-  });
-
-  // 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;
+  function elideMatchersFromArrayBindings(elements) {
+    return elements.map((el) => {
+      if (el.type === "BindingRestElement") {
+        return ["", el, void 0];
       }
-      if (ref.names[0] !== ref.base) {
-        return binding.children.unshift(ref.base, ": ");
+      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];
       }
-      ;
-      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)
+  function elideMatchersFromPropertyBindings(properties) {
+    return properties.map((p) => {
+      switch (p.type) {
+        case "BindingProperty": {
+          const { children, name, value } = p;
+          const [ws] = children;
+          switch (value && value.type) {
+            case "ArrayBindingPattern":
+            case "ObjectBindingPattern":
+              return {
+                ...p,
+                children: [ws, name, ": ", nonMatcherBindings(value), p.delim]
+              };
+            case "Identifier":
+              return p;
+            case "Literal":
+            case "RegularExpressionLiteral":
+            case "StringLiteral":
+            default:
+              return {
+                ...p,
+                children: [ws, name, p.delim]
+              };
+          }
+        }
+        case "PinProperty":
+        case "BindingRestProperty":
+        default:
+          return p;
+      }
+    });
+  }
+  function nonMatcherBindings(pattern) {
+    switch (pattern.type) {
+      case "ArrayBindingPattern": {
+        const elements = elideMatchersFromArrayBindings(pattern.elements);
+        const children = ["[", elements, "]"];
+        return {
+          ...pattern,
+          children,
+          elements
         };
       }
-      return {
-        names,
-        children: [...elements.slice(0, restIndex), {
-          ...rest,
-          children: rest.children.slice(0, -1)
-          // remove trailing comma
-        }],
-        blockPrefix,
-        length
-      };
+      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;
     }
-    const err = {
-      type: "Error",
-      children: ["Multiple rest elements in array pattern"]
-    };
-    return {
-      names,
-      children: [...elements, err],
-      blockPrefix,
-      length
-    };
   }
-  function gatherBindingCode(statements, opts) {
-    const thisAssignments = [];
-    const splices = [];
-    function insertRestSplices(s, p, thisAssignments2) {
-      gatherRecursiveAll(s, (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding").forEach((n) => {
-        if (n.type === "AtBinding") {
-          const { ref } = n;
-          const { id } = ref;
-          thisAssignments2.push([`this.${id} = `, ref]);
-          return;
-        }
-        if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-          n.names.forEach((id) => ({
-            push: thisAssignments2.push({
-              type: "AssignmentExpression",
-              children: [`this.${id} = `, id],
-              js: true
-            })
-          }));
+  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;
         }
-        const { blockPrefix } = n;
-        p.push(blockPrefix);
-        return insertRestSplices(blockPrefix, p, thisAssignments2);
+        ;
+        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]);
+      }
     }
-    insertRestSplices(statements, splices, thisAssignments);
-    return [splices, thisAssignments];
+    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 arrayElementHasTrailingComma(elementNode) {
-    const lastChild = elementNode.children.at(-1);
-    return lastChild && lastChild[lastChild.length - 1]?.token === ",";
+  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);
+    }
   }
-  var init_binding = __esm({
-    "source/parser/binding.civet"() {
+  var init_pattern_matching = __esm({
+    "source/parser/pattern-matching.civet"() {
       "use strict";
       init_traversal();
       init_util();
+      init_block();
+      init_binding();
+      init_op();
     }
   });
 
@@ -1382,8 +1677,9 @@ var Civet = (() => {
       return r.children.splice(-1, 1, " ", ref);
     });
     if (!(block.children.at(-2)?.type === "ReturnStatement")) {
+      const indent = getIndent(block.expressions.at(-1)) || ";";
       block.expressions.push([
-        [getIndent(block.expressions.at(-1))],
+        [indent],
         {
           type: "ReturnStatement",
           expression: ref,
@@ -1426,36 +1722,36 @@ var Civet = (() => {
         return pattern;
     }
   }
-  function insertPush(node, ref) {
+  function assignResults(node, collect) {
     if (!node)
       return;
     switch (node.type) {
       case "BlockStatement":
         if (node.expressions.length) {
-          insertPush(node.expressions.at(-1), ref);
+          assignResults(node.expressions.at(-1), collect);
         } else {
-          node.expressions.push([ref, ".push(void 0);"]);
+          node.expressions.push(["", collect("void 0"), ";"]);
         }
         return;
       case "CaseBlock":
         node.clauses.forEach((clause) => {
-          return insertPush(clause, ref);
+          return assignResults(clause, collect);
         });
         return;
       case "WhenClause":
-        insertPush(node.block, ref);
-        return;
       case "DefaultClause":
-        insertPush(node.block, ref);
+      case "PatternClause": {
+        assignResults(node.block, collect);
         return;
+      }
     }
-    if (!Array.isArray(node))
+    if (!Array.isArray(node)) {
       return;
+    }
     let [, exp] = node;
     if (!exp) {
       return;
     }
-    const indent = getIndent(node);
     const outer = exp;
     let { type } = exp;
     if (type === "LabelledStatement") {
@@ -1471,46 +1767,44 @@ var Civet = (() => {
       case "ThrowStatement":
         return;
       case "Declaration":
-        exp.children.push(["", [
-          ";",
-          ref,
-          ".push(",
-          patternAsValue(exp.bindings.at(-1).pattern),
-          ")"
-        ]]);
+        exp.children.push([
+          "",
+          [";", collect(patternAsValue(exp.bindings.at(-1).pattern))]
+        ]);
         return;
       case "ForStatement":
       case "IterationStatement":
       case "DoStatement":
-        wrapIterationReturningResults(exp, outer, ref);
+        wrapIterationReturningResults(exp, outer, collect);
         return;
       case "BlockStatement":
-        insertPush(exp.expressions[exp.expressions.length - 1], ref);
+        assignResults(exp.expressions[exp.expressions.length - 1], collect);
         return;
       case "IfStatement":
-        insertPush(exp.then, ref);
+        assignResults(exp.then, collect);
         if (exp.then.bare && !exp.then.semicolon) {
           exp.then.children.push(exp.then.semicolon = ";");
         }
-        if (exp.else)
-          insertPush(exp.else[2], ref);
-        else
-          exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
+        if (exp.else) {
+          assignResults(exp.else[2], collect);
+        } else {
+          exp.children.push([" else {", collect("undefined"), "}"]);
+        }
         return;
       case "PatternMatchingStatement":
-        insertPush(exp.children[0][0], ref);
+        assignResults(exp.children[0][0], collect);
         return;
       case "SwitchStatement":
-        insertPush(exp.children[2], ref);
+        assignResults(exp.children[2], collect);
         return;
       case "TryStatement":
-        exp.blocks.forEach((block) => insertPush(block, ref));
+        exp.blocks.forEach((block) => assignResults(block, collect));
         return;
     }
-    if (node[node.length - 1]?.type === "SemicolonDelimiter")
+    if (node.at(-1)?.type === "SemicolonDelimiter") {
       return;
-    node.splice(1, 0, ref, ".push(");
-    node.push(")");
+    }
+    node[1] = collect(node[1]);
   }
   function insertReturn(node, outerNode = node) {
     if (!node)
@@ -1623,24 +1917,31 @@ var Civet = (() => {
       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, ";");
     }
@@ -1723,8 +2024,11 @@ var Civet = (() => {
       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,
@@ -1737,6 +2041,19 @@ var Civet = (() => {
     );
     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";
@@ -1747,864 +2064,757 @@ var Civet = (() => {
     }
   });
 
-  // 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);
-    }
+  // 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 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;
+  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);
         }
-      }
-      return expandedOps;
-    }
-    ;
-    return recurse;
+        const { initializer } = binding;
+        if (initializer) {
+          return prependStatementExpressionBlock(initializer, statement);
+        }
+        ;
+        return;
+      });
+    });
   }
-  function dotNumericLiteral(literal) {
-    if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
-      literal.children.push(".");
-      literal.raw += ".";
+  function prependStatementExpressionBlock(initializer, statement) {
+    let exp = initializer[2];
+    let ws;
+    if (Array.isArray(exp)) {
+      ws = exp[0];
+      exp = exp[1];
     }
-    return literal;
-  }
-  function makeAsConst(node) {
-    if (Array.isArray(node) && node.length === 1) {
-      node = node[0];
+    if (!(exp.type === "StatementExpression")) {
+      return;
     }
-    if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
-      return { ...node, children: [...node.children, asConst] };
+    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 node;
+      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 isExistence(exp) {
-    if (exp.type === "ParenthesizedExpression" && exp.implicit) {
-      exp = exp.expression;
+  function processDeclarationCondition(condition, rootCondition, parent) {
+    if (!(condition.type === "DeclarationCondition")) {
+      return;
     }
-    if (exp.type === "Existence") {
-      return exp;
+    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 {
+      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) {
+    gatherRecursiveAll(node, (n) => {
+      return n.type === "IfStatement" || n.type === "IterationStatement" || n.type === "SwitchStatement";
+    }).forEach(processDeclarationConditionStatement);
   }
-  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) {
+    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);
-      }
-      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;
+    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);
         });
-      } 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;
-      }
-      return exp;
-    }
-    ;
-  }
-  var precedenceOrder, precedenceMap, precedenceStep, precedenceRelational, precedenceCustomDefault, asConst;
-  var init_op = __esm({
-    "source/parser/op.civet"() {
-      "use strict";
-      init_util();
-      precedenceOrder = [
-        ["||", "??"],
-        ["^^"],
-        ["&&"],
-        ["|"],
-        ["^"],
-        ["&"],
-        // NOTE: Equality and inequality merged because of relational chaining
-        [
-          "==",
-          "!=",
-          "===",
-          "!==",
-          "<",
-          "<=",
-          ">",
-          ">=",
-          "in",
-          "instanceof"
-        ],
-        // NOTE: Extra in-between level for default custom operators
-        ["custom"],
-        ["<<", ">>", ">>>"],
-        ["+", "-"],
-        ["*", "/", "%"],
-        ["**"]
-      ];
-      precedenceMap = /* @__PURE__ */ new Map();
-      for (let i1 = 0, len = precedenceOrder.length; i1 < len; i1++) {
-        const prec = i1;
-        const ops = precedenceOrder[i1];
-        for (let i2 = 0, len1 = ops.length; i2 < len1; i2++) {
-          const op = ops[i2];
-          precedenceMap.set(op, prec);
-        }
+        condition.children.push(")");
       }
-      precedenceStep = 1 / 64;
-      precedenceRelational = precedenceMap.get("==");
-      precedenceCustomDefault = precedenceMap.get("custom");
-      asConst = {
-        ts: true,
-        children: [" as const"]
-      };
     }
-  });
-
-  // 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;
-          }
+    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 = ";");
         }
-      }
-      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"
-            });
+        s.children = s.children.map((c) => {
+          if (c === s.then) {
+            return block;
+          } else {
+            return c;
           }
-          ;
-          return;
         });
+        s.then = block;
+        updateParentPointers(block, s);
+        break;
       }
-      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: []
-        };
-        refAssignment = [{
-          type: "AssignmentExpression",
-          children: [ref, " = ", condition]
-        }, ","];
+      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;
       }
-      let prev = [], root = prev;
-      const l = clauses.length;
-      clauses.forEach((c, i) => {
-        if (c.type === "DefaultClause") {
-          prev.push(c.block);
+      case "SwitchStatement": {
+        const { blockPrefix, ref: ref2, statementDeclaration } = condition.expression;
+        if (!blockPrefix) {
           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);
-          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 = {
+        const newCondition = {
           type: "ParenthesizedExpression",
-          children: ["(", ...refAssignment, conditionExpression, ")"],
-          expression: conditionExpression
+          children: ["(", ref2, ")"],
+          expression: ref2,
+          parent: s
         };
-        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;
+        s.children = s.children.map(function(c) {
+          if (c === s.condition) {
+            return newCondition;
+          } else {
+            return c;
           }
-        }
-        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);
-          });
+        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;
       }
-      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, ")"]
-        );
-        break;
-      }
-      case "PinPattern":
-        conditions.push([
-          ref,
-          " === ",
-          pattern.expression
-        ]);
-        break;
-      case "Literal":
-        conditions.push([
-          ref,
-          " === ",
-          pattern
-        ]);
-        break;
-      default:
-        break;
     }
   }
-  function elideMatchersFromArrayBindings(elements) {
-    return elements.map((el) => {
-      if (el.type === "BindingRestElement") {
-        return ["", el, void 0];
-      }
-      const { children: [ws, e, delim] } = el;
-      switch (e.type) {
-        case "Literal":
-        case "RegularExpressionLiteral":
-        case "StringLiteral":
-        case "PinPattern":
-          return delim;
-        default:
-          return [ws, nonMatcherBindings(e), delim];
-      }
-    });
-  }
-  function elideMatchersFromPropertyBindings(properties) {
-    return properties.map((p) => {
-      switch (p.type) {
-        case "BindingProperty": {
-          const { children, name, value } = p;
-          const [ws] = children;
-          switch (value && value.type) {
-            case "ArrayBindingPattern":
-            case "ObjectBindingPattern":
-              return {
-                ...p,
-                children: [ws, name, ": ", nonMatcherBindings(value), p.delim]
-              };
-            case "Identifier":
-              return p;
-            case "Literal":
-            case "RegularExpressionLiteral":
-            case "StringLiteral":
-            default:
-              return {
-                ...p,
-                children: [ws, name, p.delim]
-              };
-          }
+  var init_declaration = __esm({
+    "source/parser/declaration.civet"() {
+      "use strict";
+      init_block();
+      init_traversal();
+      init_pattern_matching();
+      init_util();
+      init_function();
+      init_binding();
+    }
+  });
+
+  // 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);
         }
-        case "PinProperty":
-        case "BindingRestProperty":
-        default:
-          return p;
       }
-    });
-  }
-  function nonMatcherBindings(pattern) {
-    switch (pattern.type) {
-      case "ArrayBindingPattern": {
-        const elements = elideMatchersFromArrayBindings(pattern.elements);
-        const children = ["[", elements, "]"];
+      const existence = {
+        type: "Existence",
+        expression: exp,
+        children: [exp, post]
+      };
+      exp = makeLeftHandSideExpression(existence);
+      if (pre.length) {
         return {
-          ...pattern,
-          children,
-          elements
+          type: "UnaryExpression",
+          children: [...pre, exp]
         };
       }
-      case "PostRestBindingElements": {
-        const els = elideMatchersFromArrayBindings(pattern.children[1]);
-        return {
-          ...pattern,
-          children: [
-            pattern.children[0],
-            els,
-            ...pattern.children.slice(2)
-          ]
-        };
+      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 "ObjectBindingPattern":
-        return ["{", elideMatchersFromPropertyBindings(pattern.properties), "}"];
-      default:
-        return pattern;
     }
-  }
-  function aggregateDuplicateBindings(bindings, ReservedWord) {
-    const props = gatherRecursiveAll(bindings, ($2) => $2.type === "BindingProperty");
-    const arrayBindings = gatherRecursiveAll(bindings, ($3) => $3.type === "ArrayBindingPattern");
-    arrayBindings.forEach((a) => {
-      const { elements } = a;
-      return elements.forEach((element) => {
-        if (Array.isArray(element)) {
-          const [, e] = element;
-          if (e.type === "Identifier") {
-            return props.push(e);
-          } else if (e.type === "BindingRestElement") {
-            return props.push(e);
+    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, ")"];
           }
-          ;
-          return;
+          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);
         }
-        ;
-        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]);
+        break;
       }
     }
-    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);
+    return {
+      type: "UnaryExpression",
+      children: [...pre, exp, post]
+    };
   }
-  function processDeclarationConditionStatement(s) {
-    const { condition } = s;
-    if (!condition?.expression) {
-      return;
+  var init_unary = __esm({
+    "source/parser/unary.civet"() {
+      "use strict";
+      init_util();
     }
-    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;
+  });
+
+  // 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;
     }
-    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 (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)]
       });
-      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 = ";");
+    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 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);
+        }
+        if (returning) {
+          return [
+            children,
+            returning
+          ];
+        }
+        return [
+          children,
+          null
+        ];
+      case "return":
+        return [{
+          type: "ReturnStatement",
+          children
+        }, null];
+    }
+    if (returning) {
+      return [
+        constructInvocation(fn, arg),
+        returning
+      ];
+    }
+    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;
+              }
+            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"
+            });
+          }
+        } 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"
+            });
+          }
+          arg = result;
+          if (children[children.length - 1] === ",") {
+            children.pop();
+            children.push(";");
+          }
+          break;
         }
-        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;
+        if (returning) {
+          arg = returning;
+          children.push(result, ",");
+        } else {
+          arg = result;
         }
-        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");
+    }
+    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);
+    } 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, " = "];
+    }
+    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"], ";"]);
         }
-        exp = {
-          type: "CallExpression",
-          children: [" Promise", last.op, exp]
-        };
+        if (decl2) {
+          blockPrefix.push(["", {
+            type: "Declaration",
+            children: [insertTrimmingSpace(ws2, ""), decl2, " = ", insertTrimmingSpace(expRef2, ""), "[", insertTrimmingSpace(binding, ""), "]"],
+            names: decl2.names
+          }, ";"]);
+        }
+        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();
     }
@@ -2929,7 +3139,6 @@ var Civet = (() => {
     dedentBlockString: () => dedentBlockString,
     dedentBlockSubstitutions: () => dedentBlockSubstitutions,
     deepCopy: () => deepCopy,
-    expressionizeIfClause: () => expressionizeIfClause,
     expressionizeTypeIf: () => expressionizeTypeIf,
     forRange: () => forRange,
     gatherBindingCode: () => gatherBindingCode,
@@ -2964,6 +3173,7 @@ var Civet = (() => {
     quoteString: () => quoteString,
     reorderBindingRestProperty: () => reorderBindingRestProperty,
     replaceNodes: () => replaceNodes,
+    skipImplicitArguments: () => skipImplicitArguments,
     typeOfJSX: () => typeOfJSX,
     wrapIIFE: () => wrapIIFE
   });
@@ -3002,16 +3212,71 @@ var Civet = (() => {
     };
     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");
     }
@@ -3075,17 +3340,17 @@ var Civet = (() => {
       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++;
         }
@@ -3222,9 +3487,9 @@ var Civet = (() => {
       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;
@@ -3391,55 +3656,6 @@ var Civet = (() => {
       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);
@@ -3493,8 +3709,25 @@ var Civet = (() => {
         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");
@@ -3509,7 +3742,7 @@ var Civet = (() => {
           exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
         );
         if (omitLhs) {
-          replaceNode(exp, $2);
+          return $2;
         }
       }
       let wrapped = false;
@@ -3554,7 +3787,7 @@ var Civet = (() => {
               }
               exp.children = [$1];
               exp.names = [];
-              return;
+              return exp;
             }
           } else if (lhs.type === "ObjectBindingPattern" || lhs.type === "ArrayBindingPattern") {
             processBindingPatternLHS(lhs, tail);
@@ -3566,11 +3799,19 @@ var Civet = (() => {
       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": {
@@ -3583,9 +3824,9 @@ var Civet = (() => {
         };
       }
       case "IfStatement":
-        return expressionizeIfClause(post[1], exp);
+        return expressionizeIfStatement({ ...postfixStatement, then: exp });
       default:
-        (() => {
+        return (() => {
           throw new Error("Unknown postfix statement");
         })();
     }
@@ -3624,6 +3865,42 @@ var Civet = (() => {
       }
     });
   }
+  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");
@@ -3638,6 +3915,7 @@ var Civet = (() => {
     processPipelineExpressions(statements);
     processDeclarations(statements);
     processAssignments(statements);
+    processStatementExpressions(statements);
     processPatternMatching(statements, ReservedWord);
     gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
     hoistRefDecs(statements);
@@ -3742,9 +4020,9 @@ var Civet = (() => {
         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;
       }
@@ -3756,6 +4034,34 @@ var Civet = (() => {
     }
     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":
@@ -3820,13 +4126,14 @@ var Civet = (() => {
     ;
     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();
@@ -3837,19 +4144,12 @@ var Civet = (() => {
       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;
@@ -4320,8 +4620,6 @@ ${input.slice(result.pos)}
         $TV,
         $Y,
         Parser,
-        ParserContext,
-        ParserOptions,
         Validator
       } = require_machine();
       var grammar = {
@@ -4338,7 +4636,7 @@ ${input.slice(result.pos)}
         NestedNonAssignmentExtendedExpression,
         ExpressionizedStatementWithTrailingCallExpressions,
         ExpressionizedStatement,
-        _ExpressionizedStatement,
+        StatementExpression,
         CommaExpression,
         Arguments,
         ImplicitArguments,
@@ -4600,14 +4898,6 @@ ${input.slice(result.pos)}
         ElseClause,
         IfClause,
         UnlessClause,
-        IfExpression,
-        UnlessExpression,
-        ElseExpressionClause,
-        ExpressionBlock,
-        ElseExpressionBlock,
-        NestedBlockExpressions,
-        NestedBlockExpression,
-        BlockExpressionPart,
         IterationStatement,
         _IterationStatement,
         IterationExpression,
@@ -4631,7 +4921,6 @@ ${input.slice(result.pos)}
         ForBinding,
         SwitchStatement,
         EmptyCondition,
-        SwitchExpression,
         CaseBlock,
         NestedCaseClauses,
         NestedCaseClause,
@@ -4643,7 +4932,6 @@ ${input.slice(result.pos)}
         ImpliedColon,
         IgnoreColon,
         TryStatement,
-        TryExpression,
         CatchClause,
         CatchBind,
         FinallyClause,
@@ -4684,8 +4972,6 @@ ${input.slice(result.pos)}
         Break,
         Continue,
         Debugger,
-        DebuggerExpression,
-        ThrowExpression,
         MaybeNestedExpression,
         ImportDeclaration,
         ImpliedImport,
@@ -5515,22 +5801,26 @@ ${input.slice(result.pos)}
       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)
@@ -5556,14 +5846,8 @@ ${input.slice(result.pos)}
         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,
@@ -6121,8 +6405,12 @@ ${input.slice(result.pos)}
       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];
       });
@@ -6158,6 +6446,9 @@ ${input.slice(result.pos)}
           return $skip;
         const [exp, ws, close] = $3;
         switch (exp.type) {
+          case "StatementExpression":
+            if (exp.statement.type !== "IterationExpression")
+              break;
           case "IterationExpression":
             return exp;
           case "ParenthesizedExpression":
@@ -7685,7 +7976,7 @@ ${input.slice(result.pos)}
         if (prefix.length) {
           body = {
             type: "UnaryExpression",
-            children: [prefix, body, void 0]
+            children: [processUnaryExpression(prefix, body, void 0)]
           };
         }
         const parameters = {
@@ -9642,7 +9933,13 @@ ${input.slice(result.pos)}
         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]];
       });
@@ -9650,18 +9947,15 @@ ${input.slice(result.pos)}
       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);
@@ -9874,120 +10168,6 @@ ${input.slice(result.pos)}
       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];
       });
@@ -10404,18 +10584,6 @@ ${input.slice(result.pos)}
       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 {
@@ -10597,17 +10765,6 @@ ${input.slice(result.pos)}
       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 {
@@ -10942,26 +11099,6 @@ ${input.slice(result.pos)}
       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;
       });
@@ -14079,7 +14216,9 @@ ${input.slice(result.pos)}
       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);
       }
@@ -14614,9 +14753,9 @@ ${input.slice(result.pos)}
             }
           }
         });
-        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;
@@ -14767,7 +14906,7 @@ ${input.slice(result.pos)}
         };
       }();
       exports.default = parser;
-      exports.parse = parser.parse;
+      var parse2 = exports.parse = parser.parse;
       exports.Program = Program;
       exports.TopLevelStatements = TopLevelStatements;
       exports.NestedTopLevelStatements = NestedTopLevelStatements;
@@ -14781,7 +14920,7 @@ ${input.slice(result.pos)}
       exports.NestedNonAssignmentExtendedExpression = NestedNonAssignmentExtendedExpression;
       exports.ExpressionizedStatementWithTrailingCallExpressions = ExpressionizedStatementWithTrailingCallExpressions;
       exports.ExpressionizedStatement = ExpressionizedStatement;
-      exports._ExpressionizedStatement = _ExpressionizedStatement;
+      exports.StatementExpression = StatementExpression;
       exports.CommaExpression = CommaExpression;
       exports.Arguments = Arguments;
       exports.ImplicitArguments = ImplicitArguments;
@@ -15043,14 +15182,6 @@ ${input.slice(result.pos)}
       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;
@@ -15074,7 +15205,6 @@ ${input.slice(result.pos)}
       exports.ForBinding = ForBinding;
       exports.SwitchStatement = SwitchStatement;
       exports.EmptyCondition = EmptyCondition;
-      exports.SwitchExpression = SwitchExpression;
       exports.CaseBlock = CaseBlock;
       exports.NestedCaseClauses = NestedCaseClauses;
       exports.NestedCaseClause = NestedCaseClause;
@@ -15086,7 +15216,6 @@ ${input.slice(result.pos)}
       exports.ImpliedColon = ImpliedColon;
       exports.IgnoreColon = IgnoreColon;
       exports.TryStatement = TryStatement;
-      exports.TryExpression = TryExpression;
       exports.CatchClause = CatchClause;
       exports.CatchBind = CatchBind;
       exports.FinallyClause = FinallyClause;
@@ -15127,8 +15256,6 @@ ${input.slice(result.pos)}
       exports.Break = Break;
       exports.Continue = Continue;
       exports.Debugger = Debugger;
-      exports.DebuggerExpression = DebuggerExpression;
-      exports.ThrowExpression = ThrowExpression;
       exports.MaybeNestedExpression = MaybeNestedExpression;
       exports.ImportDeclaration = ImportDeclaration;
       exports.ImpliedImport = ImpliedImport;