@danielx/civet 0.9.4 → 0.9.6

package/dist/main.mjs

@@ -536,6 +536,7 @@ __export(lib_civet_exports, {
   maybeRefAssignment: () => maybeRefAssignment,
   modifyString: () => modifyString,
   negateCondition: () => negateCondition,
+  precedenceCustomDefault: () => precedenceCustomDefault,
   precedenceStep: () => precedenceStep,
   prepend: () => prepend,
   processAssignmentDeclaration: () => processAssignmentDeclaration,
@@ -1631,6 +1632,15 @@ function gatherRecursiveAll(node, predicate) {
 }
 
 // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\ref.civet.jsx
+var range = (start, end) => {
+  const length = end - start;
+  if (length <= 0) return [];
+  const arr = Array(length);
+  for (let i = 0; i < length; ++i) {
+    arr[i] = i + start;
+  }
+  return arr;
+};
 function makeRef(base = "ref", id = base) {
   return {
     type: "Ref",
@@ -1643,7 +1653,7 @@ function needsRef(expression, base = "ref") {
     return;
   }
   if (Array.isArray(expression)) {
-    const nonempty = ((s) => Array.from({ length: expression.length - s }, (_2, i) => s + i))(0).filter((i) => !isWhitespaceOrEmpty(expression[i]));
+    const nonempty = range(0, expression.length).filter((i) => !isWhitespaceOrEmpty(expression[i]));
     if (nonempty.length === 1) {
       let ref1;
       if (ref1 = needsRef(expression[nonempty[0]], base)) {
@@ -1659,8 +1669,9 @@ function needsRef(expression, base = "ref") {
     case "Ref":
     case "Identifier":
     case "Literal":
-    case "Placeholder":
+    case "Placeholder": {
       return;
+    }
   }
   return makeRef(base);
 }
@@ -1690,10 +1701,34 @@ function maybeRefAssignment(exp, base = "ref") {
     return { ref, ...makeRefAssignment(ref, exp) };
   }
 }
+function populateRefs(statements) {
+  const refNodes = gatherRecursive(statements, ($) => $.type === "Ref");
+  if (!refNodes.length) {
+    return;
+  }
+  const ids = gatherRecursive(statements, ($1) => $1.type === "Identifier");
+  const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
+  for (let i1 = 0, len3 = refNodes.length; i1 < len3; i1++) {
+    const ref = refNodes[i1];
+    if (!(ref.type === "Ref")) {
+      continue;
+    }
+    const { base } = ref;
+    ref.type = "Identifier";
+    let n = 0;
+    let name = base;
+    while (names.has(name)) {
+      n++;
+      name = `${base}${n}`;
+    }
+    names.add(name);
+    ref.children = ref.names = [name];
+  }
+}
 
 // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\binding.civet.jsx
 function adjustAtBindings(statements, asThis = false) {
-  for (let ref1 = gatherRecursiveAll(statements, ($) => $.type === "AtBindingProperty"), i1 = 0, len3 = ref1.length; i1 < len3; i1++) {
+  for (let ref1 = gatherRecursiveAll(statements, ($1) => $1.type === "AtBindingProperty"), i1 = 0, len3 = ref1.length; i1 < len3; i1++) {
     const binding = ref1[i1];
     const { ref } = binding;
     if (asThis) {
@@ -1711,7 +1746,7 @@ function adjustAtBindings(statements, asThis = false) {
   }
 }
 function adjustBindingElements(elements) {
-  const names = elements.flatMap(($1) => $1.names || []);
+  const names = elements.flatMap(($2) => $2.names || []);
   const { length } = elements;
   let blockPrefix, restIndex = -1, restCount = 0;
   for (let i2 = 0, len1 = elements.length; i2 < len1; i2++) {
@@ -1769,16 +1804,40 @@ function adjustBindingElements(elements) {
     length
   };
 }
+function gatherSubbindings(node, subbindings = []) {
+  for (let ref2 = gatherRecursiveAll(node, ($) => $.subbinding != null), i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
+    const p = ref2[i3];
+    const { subbinding } = p;
+    subbindings.push(", ", subbinding);
+    gatherSubbindings(subbinding, subbindings);
+  }
+  return subbindings;
+}
+function simplifyBindingProperties(node) {
+  const results = [];
+  for (let ref3 = gatherRecursiveAll(node, ($3) => $3.type === "BindingProperty"), i4 = 0, len3 = ref3.length; i4 < len3; i4++) {
+    const p = ref3[i4];
+    const { name, value } = p;
+    if (value?.type === "NamedBindingPattern" && value.binding === name) {
+      const [ws] = p.children;
+      results.push(p.children = [ws, name, p.delim]);
+    } else {
+      results.push(void 0);
+    }
+  }
+  ;
+  return results;
+}
 function gatherBindingCode(statements, opts) {
   const thisAssignments = [];
   const splices = [];
   function insertRestSplices(s, p, thisAssignments2) {
     let m;
-    for (let ref2 = gatherRecursiveAll(
+    for (let ref4 = gatherRecursiveAll(
       s,
       (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding" || opts?.assignPins && (m = n.type, m === "PinPattern" || m === "PinProperty")
-    ), i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
-      let n = ref2[i3];
+    ), i5 = 0, len4 = ref4.length; i5 < len4; i5++) {
+      let n = ref4[i5];
       if (n.type === "AtBinding") {
         const { ref } = n;
         const { id } = ref;
@@ -1787,7 +1846,7 @@ function gatherBindingCode(statements, opts) {
       }
       if (opts?.assignPins) {
         if (n.type === "PinProperty") {
-          n.children = n.children.flatMap(($2) => $2 === n.name ? [n.name, ": ", n.value] : $2);
+          n.children = n.children.flatMap(($4) => $4 === n.name ? [n.name, ": ", n.value] : $4);
           updateParentPointers(n);
           n = n.value;
         }
@@ -1809,8 +1868,8 @@ function gatherBindingCode(statements, opts) {
         }
       }
       if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-        for (let ref3 = n.names, i4 = 0, len3 = ref3.length; i4 < len3; i4++) {
-          const id = ref3[i4];
+        for (let ref5 = n.names, i6 = 0, len5 = ref5.length; i6 < len5; i6++) {
+          const id = ref5[i6];
           thisAssignments2.push({
             type: "AssignmentExpression",
             children: [`this.${id} = `, id],
@@ -1828,8 +1887,8 @@ function gatherBindingCode(statements, opts) {
   return [splices, thisAssignments];
 }
 function arrayElementHasTrailingComma(elementNode) {
-  let ref4;
-  const lastChild = (ref4 = elementNode.children)[ref4.length - 1];
+  let ref6;
+  const lastChild = (ref6 = elementNode.children)[ref6.length - 1];
   return lastChild && lastChild[lastChild.length - 1]?.token === ",";
 }
 function gatherBindingPatternTypeSuffix(pattern) {
@@ -1840,9 +1899,9 @@ function gatherBindingPatternTypeSuffix(pattern) {
   switch (pattern.type) {
     case "ArrayBindingPattern": {
       {
-        const results = [];
-        for (let ref5 = pattern.elements, i5 = 0, len4 = ref5.length; i5 < len4; i5++) {
-          const elem = ref5[i5];
+        const results1 = [];
+        for (let ref7 = pattern.elements, i7 = 0, len6 = ref7.length; i7 < len6; i7++) {
+          const elem = ref7[i7];
           let { typeSuffix } = elem;
           typeSuffix ??= elem.binding?.typeSuffix;
           if (typeSuffix) {
@@ -1859,10 +1918,10 @@ function gatherBindingPatternTypeSuffix(pattern) {
           } else {
             typeElement[0] ??= "unknown";
           }
-          results.push(typeElement);
+          results1.push(typeElement);
         }
         ;
-        const types = results;
+        const types = results1;
         if (count) {
           const t = [": [", types, "]"];
           pattern.typeSuffix = {
@@ -1879,9 +1938,9 @@ function gatherBindingPatternTypeSuffix(pattern) {
     case "ObjectBindingPattern": {
       {
         let restType;
-        const results1 = [];
-        for (let ref6 = pattern.properties, i6 = 0, len5 = ref6.length; i6 < len5; i6++) {
-          const prop = ref6[i6];
+        const results2 = [];
+        for (let ref8 = pattern.properties, i8 = 0, len7 = ref8.length; i8 < len7; i8++) {
+          const prop = ref8[i8];
           let { typeSuffix } = prop;
           typeSuffix ??= prop.value?.typeSuffix;
           if (typeSuffix) {
@@ -1895,12 +1954,12 @@ function gatherBindingPatternTypeSuffix(pattern) {
           switch (prop.type) {
             case "BindingProperty": {
               const ws = prop.children.slice(0, prop.children.indexOf(prop.name));
-              results1.push([...ws, prop.name, typeSuffix, prop.delim]);
+              results2.push([...ws, prop.name, typeSuffix, prop.delim]);
               break;
             }
             case "AtBindingProperty": {
               const ws = prop.children.slice(0, prop.children.indexOf(prop.binding));
-              results1.push([...ws, prop.ref.id, typeSuffix, prop.delim]);
+              results2.push([...ws, prop.ref.id.replace(/^#/, ""), typeSuffix, prop.delim]);
               break;
             }
             case "BindingRestProperty": {
@@ -1910,7 +1969,7 @@ function gatherBindingPatternTypeSuffix(pattern) {
           }
         }
         ;
-        const types = results1;
+        const types = results2;
         if (count) {
           const t = ["{", types, "}"];
           if (restType != null) {
@@ -3023,6 +3082,7 @@ function assignResults(node, collect) {
     exp = exp.statement;
   }
   let ref6;
+  let m1;
   switch (exp.type) {
     case "BreakStatement":
     case "ContinueStatement":
@@ -3102,6 +3162,9 @@ function assignResults(node, collect) {
       return;
     }
     case "PipelineExpression": {
+      if (m1 = exp.children[1]?.type, m1 === "ReturnStatement" || m1 === "ThrowStatement") {
+        return;
+      }
       const semi2 = exp.children.lastIndexOf(";");
       if (0 <= semi2 && semi2 < exp.children.length - 1) {
         exp.children.splice(semi2 + 1, 1 / 0, ...[collect(exp.children.slice(semi2 + 1))]);
@@ -3127,8 +3190,8 @@ function insertReturn(node) {
         const last = node.expressions[node.expressions.length - 1];
         insertReturn(last);
       } else {
-        let m1;
-        if (m1 = node.parent?.type, m1 === "CatchClause" || m1 === "WhenClause") {
+        let m2;
+        if (m2 = node.parent?.type, m2 === "CatchClause" || m2 === "WhenClause") {
           node.expressions.push(["", wrapWithReturn(void 0, node)]);
         }
       }
@@ -3174,6 +3237,7 @@ function insertReturn(node) {
     exp = exp.statement;
   }
   let ref11;
+  let m3;
   switch (exp.type) {
     case "BreakStatement":
     case "ContinueStatement":
@@ -3265,6 +3329,9 @@ function insertReturn(node) {
       return;
     }
     case "PipelineExpression": {
+      if (m3 = exp.children[1]?.type, m3 === "ReturnStatement" || m3 === "ThrowStatement") {
+        return;
+      }
       const semi2 = exp.children.lastIndexOf(";");
       if (0 <= semi2 && semi2 < exp.children.length - 1) {
         exp.children.splice(semi2 + 1, 1 / 0, ...[wrapWithReturn(exp.children.slice(semi2 + 1))]);
@@ -3287,8 +3354,8 @@ function processBreakContinueWith(statement) {
   )) {
     if (control.with) {
       if (control.label) {
-        let m2;
-        if (!(m2 = statement.parent, typeof m2 === "object" && m2 != null && "type" in m2 && m2.type === "LabelledStatement" && "label" in m2 && typeof m2.label === "object" && m2.label != null && "name" in m2.label && m2.label.name === control.label.name)) {
+        let m4;
+        if (!(m4 = statement.parent, typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "LabelledStatement" && "label" in m4 && typeof m4.label === "object" && m4.label != null && "name" in m4.label && m4.label.name === control.label.name)) {
           continue;
         }
       } else {
@@ -3509,8 +3576,8 @@ function iterationDefaultBody(statement) {
   const reduction = statement.type === "ForStatement" && statement.reduction;
   function fillBlock(expression) {
     let ref15;
-    let m3;
-    if (m3 = (ref15 = block.expressions)[ref15.length - 1], Array.isArray(m3) && m3.length >= 2 && typeof m3[1] === "object" && m3[1] != null && "type" in m3[1] && m3[1].type === "EmptyStatement" && "implicit" in m3[1] && m3[1].implicit === true) {
+    let m5;
+    if (m5 = (ref15 = block.expressions)[ref15.length - 1], Array.isArray(m5) && m5.length >= 2 && typeof m5[1] === "object" && m5[1] != null && "type" in m5[1] && m5[1].type === "EmptyStatement" && "implicit" in m5[1] && m5[1].implicit === true) {
       block.expressions.pop();
     }
     block.expressions.push(expression);
@@ -3638,7 +3705,8 @@ function processParams(f) {
     parameters.names.push(...rest.names || []);
     rest.children.pop();
     if (after.length) {
-      if (rest.binding.type === "ArrayBindingPattern" || rest.binding.type === "ObjectBindingPattern") {
+      let m6;
+      if (m6 = rest.binding.type, m6 === "ArrayBindingPattern" || m6 === "ObjectBindingPattern" || m6 === "NamedBindingPattern") {
         parameters.parameters.push({
           type: "Error",
           message: "Non-end rest parameter cannot be binding pattern"
@@ -3770,6 +3838,9 @@ function processParams(f) {
     injectParamProps: isConstructor,
     assignPins: true
   });
+  const subbindings = gatherSubbindings(parameters.parameters);
+  simplifyBindingProperties(parameters.parameters);
+  simplifyBindingProperties(subbindings);
   if (isConstructor) {
     const { ancestor } = findAncestor(f, ($10) => $10.type === "ClassExpression");
     if (ancestor != null) {
@@ -3777,8 +3848,8 @@ function processParams(f) {
       const classExpressions = ancestor.body.expressions;
       let index2 = findChildIndex(classExpressions, f);
       assert.notEqual(index2, -1, "Could not find constructor in class");
-      let m4;
-      while (m4 = classExpressions[index2 - 1]?.[1], typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "MethodDefinition" && "name" in m4 && m4.name === "constructor") {
+      let m7;
+      while (m7 = classExpressions[index2 - 1]?.[1], typeof m7 === "object" && m7 != null && "type" in m7 && m7.type === "MethodDefinition" && "name" in m7 && m7.name === "constructor") {
         index2--;
       }
       const fStatement = classExpressions[index2];
@@ -3818,6 +3889,15 @@ function processParams(f) {
     children: [";"]
   };
   let prefix = [];
+  if (subbindings.length) {
+    prefix.push(makeNode({
+      type: "Declaration",
+      children: ["const ", subbindings.slice(1)],
+      names: subbindings.flatMap(($16) => $16.names ?? []),
+      bindings: [],
+      decl: "const"
+    }));
+  }
   for (let ref20 = splices, i11 = 0, len10 = ref20.length; i11 < len10; i11++) {
     const binding = ref20[i11];
     assert.equal(binding.type, "PostRestBindingElements", "splice should be of type Binding");
@@ -3871,7 +3951,7 @@ function processSignature(f) {
       f.async.push("async ");
       signature.modifier.async = true;
     } else {
-      for (let ref21 = gatherRecursiveWithinFunction(block, ($16) => $16.type === "Await"), i12 = 0, len11 = ref21.length; i12 < len11; i12++) {
+      for (let ref21 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i12 = 0, len11 = ref21.length; i12 < len11; i12++) {
         const a = ref21[i12];
         const i = findChildIndex(a.parent, a);
         a.parent.children.splice(i + 1, 0, {
@@ -3886,9 +3966,9 @@ function processSignature(f) {
       f.generator.push("*");
       signature.modifier.generator = true;
     } else {
-      for (let ref22 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "YieldExpression"), i13 = 0, len12 = ref22.length; i13 < len12; i13++) {
+      for (let ref22 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i13 = 0, len12 = ref22.length; i13 < len12; i13++) {
         const y = ref22[i13];
-        const i = y.children.findIndex(($18) => $18.type === "Yield");
+        const i = y.children.findIndex(($19) => $19.type === "Yield");
         y.children.splice(i + 1, 0, {
           type: "Error",
           message: `yield invalid in ${f.type === "ArrowFunction" ? "=> arrow function" : signature.modifier.get ? "getter" : signature.modifier.set ? "setter" : signature.name}`
@@ -3901,7 +3981,7 @@ function processSignature(f) {
   }
 }
 function processFunctions(statements, config2) {
-  for (let ref23 = gatherRecursiveAll(statements, ($19) => $19.type === "FunctionExpression" || $19.type === "ArrowFunction" || $19.type === "MethodDefinition"), i14 = 0, len13 = ref23.length; i14 < len13; i14++) {
+  for (let ref23 = gatherRecursiveAll(statements, ($20) => $20.type === "FunctionExpression" || $20.type === "ArrowFunction" || $20.type === "MethodDefinition"), i14 = 0, len13 = ref23.length; i14 < len13; i14++) {
     const f = ref23[i14];
     if (f.type === "FunctionExpression" || f.type === "MethodDefinition") {
       implicitFunctionBlock(f);
@@ -3971,7 +4051,7 @@ function expressionizeIteration(exp) {
   }
 }
 function processIterationExpressions(statements) {
-  for (let ref25 = gatherRecursiveAll(statements, ($20) => $20.type === "IterationExpression"), i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
+  for (let ref25 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
     const s = ref25[i15];
     expressionizeIteration(s);
   }
@@ -4021,12 +4101,12 @@ function processCoffeeDo(ws, expression) {
     const newParameters = {
       ...parameters,
       parameters: newParameterList,
-      children: parameters.children.map(($21) => $21 === parameterList ? newParameterList : $21)
+      children: parameters.children.map(($22) => $22 === parameterList ? newParameterList : $22)
     };
     expression = {
       ...expression,
       parameters: newParameters,
-      children: expression.children.map(($22) => $22 === parameters ? newParameters : $22)
+      children: expression.children.map(($23) => $23 === parameters ? newParameters : $23)
     };
   }
   return {
@@ -4048,7 +4128,7 @@ function makeAmpersandFunction(rhs) {
     ref = makeRef("$");
     inplacePrepend(ref, body);
   }
-  if (startsWithPredicate(body, ($23) => $23.type === "ObjectExpression")) {
+  if (startsWithPredicate(body, ($24) => $24.type === "ObjectExpression")) {
     body = makeLeftHandSideExpression(body);
   }
   const parameterList = [
@@ -4844,17 +4924,15 @@ function getPatternConditions(pattern, ref, conditions = []) {
       break;
     }
     case "ConditionFragment": {
-      let { children } = pattern;
-      if (children.length) {
-        let [first, ...rest] = children;
+      let { rhs } = pattern;
+      if (rhs.length) {
+        let [first, ...rest] = rhs;
         let [ws, ...op] = first;
         ws = [" "].concat(ws);
         first = [ws, ...op];
-        children = [first, ...rest];
+        rhs = [first, ...rest];
       }
-      conditions.push(
-        processBinaryOpExpression([ref, children])
-      );
+      conditions.push(processBinaryOpExpression([ref, rhs]));
       break;
     }
     case "RegularExpressionLiteral": {
@@ -4872,6 +4950,10 @@ function getPatternConditions(pattern, ref, conditions = []) {
       ]);
       break;
     }
+    case "NamedBindingPattern": {
+      getPatternConditions(pattern.pattern, ref, conditions);
+      break;
+    }
     case "Literal": {
       conditions.push([
         ref,
@@ -4901,43 +4983,60 @@ function getPatternBlockPrefix(pattern, ref, decl = "const ", typeSuffix) {
     }
     case "Literal":
     case "RegularExpressionLiteral":
-    case "PinPattern":
-    case "ConditionFragment": {
+    case "PinPattern": {
       return;
     }
+    case "ConditionFragment": {
+      if (!pattern.binding) {
+        return;
+      }
+      ;
+      break;
+    }
   }
   let [splices, thisAssignments] = gatherBindingCode(pattern);
   const patternBindings2 = nonMatcherBindings(pattern);
-  const results = [];
-  for (let ref2 = gatherRecursiveAll(patternBindings2, ($7) => $7.subbinding != null), i5 = 0, len4 = ref2.length; i5 < len4; i5++) {
-    const p = ref2[i5];
-    results.push(prepend(", ", p.subbinding));
-  }
-  ;
-  const subbindings = results;
-  splices = splices.map((s) => [", ", nonMatcherBindings(s)]);
-  thisAssignments = thisAssignments.map(($8) => ["", $8, ";"]);
-  const duplicateDeclarations = aggregateDuplicateBindings([patternBindings2, splices]);
-  return [
-    ["", {
+  const subbindings = gatherSubbindings(patternBindings2);
+  simplifyBindingProperties(patternBindings2);
+  simplifyBindingProperties(subbindings);
+  splices = splices.flatMap((s) => [", ", nonMatcherBindings(s)]);
+  thisAssignments = thisAssignments.map(($7) => ["", $7, ";"]);
+  const duplicateDeclarations = aggregateDuplicateBindings([patternBindings2, splices, subbindings]);
+  const blockPrefix = [];
+  if (ref || subbindings.length || splices.length) {
+    const children = [decl];
+    if (ref) {
+      children.push(patternBindings2, typeSuffix, " = ", ref);
+    }
+    children.push(...subbindings);
+    children.push(...splices);
+    if (!ref) {
+      children.splice(1, 1);
+    }
+    blockPrefix.push(["", {
       type: "Declaration",
-      children: [decl, patternBindings2, typeSuffix, " = ", ref, ...subbindings, ...splices],
+      children,
+      decl,
       names: [],
       bindings: []
       // avoid implicit return of any bindings
-    }, ";"],
-    ...thisAssignments,
-    ...duplicateDeclarations.map(($9) => ["", $9, ";"])
-  ];
+    }, ";"]);
+  }
+  blockPrefix.push(...thisAssignments);
+  blockPrefix.push(...duplicateDeclarations.map(($8) => ["", $8, ";"]));
+  if (!blockPrefix.length) {
+    return;
+  }
+  return blockPrefix;
 }
 function elideMatchersFromArrayBindings(elements) {
-  const results1 = [];
-  for (let i6 = 0, len5 = elements.length; i6 < len5; i6++) {
-    const element = elements[i6];
+  const results = [];
+  for (let i5 = 0, len4 = elements.length; i5 < len4; i5++) {
+    const element = elements[i5];
     switch (element.type) {
       case "BindingRestElement":
       case "ElisionElement": {
-        results1.push(element);
+        results.push(element);
         break;
       }
       case "BindingElement": {
@@ -4946,12 +5045,12 @@ function elideMatchersFromArrayBindings(elements) {
           case "RegularExpressionLiteral":
           case "StringLiteral":
           case "PinPattern": {
-            results1.push(element.delim);
+            results.push(element.delim);
             break;
           }
           default: {
             const binding = nonMatcherBindings(element.binding);
-            results1.push(makeNode({
+            results.push(makeNode({
               ...element,
               binding,
               children: element.children.map((c) => {
@@ -4966,29 +5065,23 @@ function elideMatchersFromArrayBindings(elements) {
     }
   }
   ;
-  return results1;
+  return results;
 }
 function elideMatchersFromPropertyBindings(properties) {
-  const results2 = [];
-  for (let i7 = 0, len6 = properties.length; i7 < len6; i7++) {
-    const p = properties[i7];
+  const results1 = [];
+  for (let i6 = 0, len5 = properties.length; i6 < len5; i6++) {
+    const p = properties[i6];
     switch (p.type) {
       case "BindingProperty":
       case "PinProperty": {
-        const { children, name, value, bind } = p;
+        const { children, name, value } = p;
         const [ws] = children;
         const shouldElide = name.type === "NumericLiteral" && !value?.name || name.type === "ComputedPropertyName" && value?.subtype === "NumericLiteral";
         if (shouldElide) {
-          if (bind) {
-            results2.push({
-              type: "Error",
-              message: `Cannot bind ${name.type}`
-            });
-          } else {
-            continue;
-          }
+          continue;
         } else {
           let contents;
+          let m1;
           switch (value?.type) {
             case "ArrayBindingPattern":
             case "ObjectBindingPattern": {
@@ -5005,22 +5098,28 @@ function elideMatchersFromPropertyBindings(properties) {
               contents = p;
               break;
             }
+            case "NamedBindingPattern": {
+              const bindings = nonMatcherBindings(value.pattern);
+              contents = {
+                ...p,
+                subbinding: (m1 = bindings?.type, m1 === "ArrayBindingPattern" || m1 === "ObjectBindingPattern" || m1 === "Identifier") ? [
+                  bindings,
+                  " = ",
+                  name
+                ] : void 0
+              };
+              if (p.name === value.binding) {
+                contents.children = [ws, name, p.delim];
+              }
+              ;
+              break;
+            }
             default: {
               contents = void 0;
             }
           }
-          if (bind) {
-            results2.push({
-              ...p,
-              children: [ws, name, p.delim],
-              subbinding: contents?.value ? [
-                contents.value,
-                " = ",
-                name
-              ] : void 0
-            });
-          } else if (contents) {
-            results2.push(contents);
+          if (contents) {
+            results1.push(contents);
           } else {
             continue;
           }
@@ -5029,14 +5128,15 @@ function elideMatchersFromPropertyBindings(properties) {
         break;
       }
       default: {
-        results2.push(p);
+        results1.push(p);
       }
     }
   }
   ;
-  return results2;
+  return results1;
 }
 function nonMatcherBindings(pattern) {
+  let m2;
   switch (pattern.type) {
     case "ArrayBindingPattern":
     case "PostRestBindingElements": {
@@ -5044,7 +5144,7 @@ function nonMatcherBindings(pattern) {
       return makeNode({
         ...pattern,
         elements,
-        children: pattern.children.map(($10) => $10 === pattern.elements ? elements : $10)
+        children: pattern.children.map(($9) => $9 === pattern.elements ? elements : $9)
       });
     }
     case "ObjectBindingPattern": {
@@ -5052,9 +5152,19 @@ function nonMatcherBindings(pattern) {
       return makeNode({
         ...pattern,
         properties,
-        children: pattern.children.map(($11) => $11 === pattern.properties ? properties : $11)
+        children: pattern.children.map(($10) => $10 === pattern.properties ? properties : $10)
       });
     }
+    case "NamedBindingPattern": {
+      const bindings = nonMatcherBindings(pattern.pattern);
+      return makeNode({
+        ...pattern,
+        subbinding: (m2 = bindings?.type, m2 === "ArrayBindingPattern" || m2 === "ObjectBindingPattern" || m2 === "Identifier") ? [bindings, " = ", pattern.binding] : void 0
+      });
+    }
+    case "ConditionFragment": {
+      return pattern.binding;
+    }
     default: {
       return pattern;
     }
@@ -5070,11 +5180,11 @@ function aggregateDuplicateBindings(bindings) {
   );
   const declarations = [];
   const propsGroupedByName = /* @__PURE__ */ new Map();
-  for (let i8 = 0, len7 = props.length; i8 < len7; i8++) {
-    const p = props[i8];
+  for (let i7 = 0, len6 = props.length; i7 < len6; i7++) {
+    const p = props[i7];
     const { name, value } = p;
-    let m1;
-    if (m1 = value?.type, m1 === "ArrayBindingPattern" || m1 === "ObjectBindingPattern") {
+    let m3;
+    if (m3 = value?.type, m3 === "ArrayBindingPattern" || m3 === "ObjectBindingPattern") {
       continue;
     }
     const key = value?.name || name?.name || name;
@@ -5096,8 +5206,8 @@ function aggregateDuplicateBindings(bindings) {
       pos: 0,
       input: key
     })) {
-      for (let i9 = 0, len8 = shared.length; i9 < len8; i9++) {
-        const p = shared[i9];
+      for (let i8 = 0, len7 = shared.length; i8 < len7; i8++) {
+        const p = shared[i8];
         aliasBinding(p, makeRef(`_${key}`, key));
       }
       return;
@@ -5189,8 +5299,18 @@ function processDeclarations(statements) {
     if (!(bindings != null)) {
       continue;
     }
-    for (let i2 = 0, len22 = bindings.length; i2 < len22; i2++) {
-      const binding = bindings[i2];
+    for (let i2 = bindings.length + -1; i2 >= 0; --i2) {
+      const i = i2;
+      const binding = bindings[i];
+      const subbindings = gatherSubbindings(binding);
+      if (subbindings.length) {
+        simplifyBindingProperties(binding);
+        simplifyBindingProperties(subbindings);
+        spliceChild(declaration, binding, 1, binding, subbindings);
+      }
+    }
+    for (let i3 = 0, len22 = bindings.length; i3 < len22; i3++) {
+      const binding = bindings[i3];
       let { typeSuffix, initializer } = binding;
       if (typeSuffix && typeSuffix.optional) {
         if (initializer && !typeSuffix.t) {
@@ -5228,6 +5348,25 @@ function processDeclarations(statements) {
       }
     }
   }
+  for (let ref2 = gatherRecursiveAll(statements, ($1) => $1.type === "ForStatement"), i4 = 0, len3 = ref2.length; i4 < len3; i4++) {
+    const statement = ref2[i4];
+    const { declaration } = statement;
+    if (!(declaration?.type === "ForDeclaration")) {
+      continue;
+    }
+    const { binding } = declaration;
+    const blockPrefix = getPatternBlockPrefix(
+      binding.pattern,
+      void 0,
+      append(declaration.decl, " "),
+      binding.typeSuffix
+    );
+    simplifyBindingProperties(binding);
+    if (blockPrefix != null) {
+      statement.block.expressions.unshift(...blockPrefix);
+      braceBlock(statement.block);
+    }
+  }
 }
 function prependStatementExpressionBlock(initializer, statement) {
   let { expression: exp } = initializer;
@@ -5371,8 +5510,7 @@ function processDeclarationConditionStatement(s) {
   }
   let { expression } = condition;
   if (expression && typeof expression === "object" && "type" in expression && expression.type === "UnaryExpression" && "children" in expression && Array.isArray(expression.children) && len2(expression.children, 2) && Array.isArray(expression.children[0]) && len2(expression.children[0], 1) && expression.children[0][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];
+    const { children: [[], { expression: expression2 }] } = expression;
     expression = expression2;
   }
   processDeclarationCondition(expression, condition.expression, s);
@@ -5397,8 +5535,8 @@ function processDeclarationConditionStatement(s) {
         ({ children } = condition.expression.children[1]);
       }
       children.unshift("(");
-      for (let i3 = 0, len3 = conditions.length; i3 < len3; i3++) {
-        const c = conditions[i3];
+      for (let i5 = 0, len4 = conditions.length; i5 < len4; i5++) {
+        const c = conditions[i5];
         children.push(" && ", c);
       }
       children.push(")");
@@ -5420,11 +5558,11 @@ function processDeclarationConditionStatement(s) {
     ancestor.expressions.splice(index + 1, 0, ...blockPrefix);
     updateParentPointers(ancestor);
     braceBlock(ancestor);
-    let ref2;
+    let ref3;
     switch (s.type) {
       case "IfStatement": {
-        if (ref2 = s.else?.block) {
-          const elseBlock = ref2;
+        if (ref3 = s.else?.block) {
+          const elseBlock = ref3;
           if (elseBlock.bare && !elseBlock.semicolon) {
             elseBlock.children.push(elseBlock.semicolon = ";");
           }
@@ -5448,13 +5586,13 @@ function processDeclarationConditionStatement(s) {
       if (s.negated) {
         if (e != null) {
           const block = blockWithPrefix(blockPrefix, e.block);
-          e.children = e.children.map(($1) => $1 === e.block ? block : $1);
+          e.children = e.children.map(($2) => $2 === e.block ? block : $2);
           e.block = block;
           updateParentPointers(e);
         }
       } else {
         const block = blockWithPrefix(blockPrefix, s.then);
-        s.children = s.children.map(($2) => $2 === s.then ? block : $2);
+        s.children = s.children.map(($3) => $3 === s.then ? block : $3);
         s.then = block;
         updateParentPointers(s);
       }
@@ -5467,7 +5605,7 @@ function processDeclarationConditionStatement(s) {
       }
       const { children, block } = s;
       const newBlock = blockWithPrefix(blockPrefix, block);
-      s.children = children.map(($3) => $3 === block ? newBlock : $3);
+      s.children = children.map(($4) => $4 === block ? newBlock : $4);
       updateParentPointers(s);
       break;
     }
@@ -5495,7 +5633,7 @@ function processDeclarationConditionStatement(s) {
         const block = makeEmptyBlock();
         replaceBlockExpression(s.parent, s, block);
         block.expressions.push(["", s]);
-        s.children.splice(s.children.findIndex(($4) => $4.token === "switch"), 0, blockPrefix);
+        s.children.splice(s.children.findIndex(($5) => $5.token === "switch"), 0, blockPrefix);
         s.parent = block;
       } else {
         const block = blockWithPrefix([["", [{
@@ -5515,12 +5653,12 @@ function processDeclarationConditionStatement(s) {
 function dynamizeFromClause(from) {
   from = from.slice(1);
   from = trimFirstSpace(from);
-  let ref3;
-  if (ref3 = from[from.length - 1]?.assertion) {
-    const assert2 = ref3;
-    let ref4;
-    ref4 = from[from.length - 1];
-    ref4.children = ref4.children.filter((a2) => a2 !== assert2);
+  let ref4;
+  if (ref4 = from[from.length - 1]?.assertion) {
+    const assert2 = ref4;
+    let ref5;
+    ref5 = from[from.length - 1];
+    ref5.children = ref5.children.filter((a2) => a2 !== assert2);
     from.push(", {", assert2.keyword, ":", assert2.object, "}");
   }
   return ["(", ...from, ")"];
@@ -5529,20 +5667,20 @@ function dynamizeImportDeclaration(decl) {
   const { imports } = decl;
   let { star, binding, specifiers } = imports;
   const justDefault = binding && !specifiers && !star;
-  let ref5;
+  let ref6;
   {
     if (binding) {
       if (specifiers) {
-        ref5 = makeRef();
+        ref6 = makeRef();
       } else {
-        ref5 = binding;
+        ref6 = binding;
       }
     } else {
-      ref5 = convertNamedImportsToObject(imports, true);
+      ref6 = convertNamedImportsToObject(imports, true);
     }
   }
   ;
-  const pattern = ref5;
+  const pattern = ref6;
   const c = "const";
   const expression = [
     justDefault ? "(" : void 0,
@@ -5807,7 +5945,7 @@ function processUnaryNestedExpression(pre, args, post) {
           children: args.children.map(
             (arg) => {
               if (typeof arg === "object" && arg != null && "type" in arg && arg.type === "ArrayElement" && "expression" in arg && "children" in arg) {
-                const { type, expression: exp, children } = arg;
+                const { expression: exp, children } = arg;
                 let expression = processUnaryExpression([last], trimFirstSpace(exp));
                 expression = prepend(getTrimmingSpace(exp), expression);
                 return {
@@ -5868,9 +6006,8 @@ function constructInvocation(fn, arg) {
   if (lhs.type === "NewExpression") {
     let { expression } = lhs;
     expression = {
-      ...expression,
       type: "CallExpression",
-      children: [...expression.children, call]
+      children: [expression, call]
     };
     return {
       ...lhs,
@@ -5923,23 +6060,22 @@ function constructPipeStep(fn, arg, returning) {
   ];
 }
 function processPipelineExpressions(statements) {
-  gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
+  for (let ref1 = gatherRecursiveAll(statements, ($1) => $1.type === "PipelineExpression"), i1 = 0, len3 = ref1.length; i1 < len3; i1++) {
+    const s = ref1[i1];
     const [ws, , body] = s.children;
     let [, arg] = s.children;
-    let i = 0;
-    const l = body.length;
     const children = [ws];
     const comma = blockContainingStatement(s) ? ";" : ",";
     let usingRef = null;
-    for (let i1 = 0, len3 = body.length; i1 < len3; i1++) {
-      const i2 = i1;
-      const step = body[i1];
+    for (let i2 = 0, len1 = body.length; i2 < len1; i2++) {
+      const i = i2;
+      const step = body[i2];
       const [leadingComment, pipe, trailingComment, expr] = step;
       const returns = pipe.token === "||>";
       let ref, result, returning = returns ? arg : null;
       if (pipe.token === "|>=") {
         let initRef;
-        if (i2 === 0) {
+        if (i === 0) {
           checkValidLHS(arg);
           outer: switch (arg.type) {
             case "MemberExpression": {
@@ -5988,7 +6124,7 @@ function processPipelineExpressions(statements) {
           });
         }
       } else {
-        if (i2 === 0) s.children = children;
+        if (i === 0) s.children = children;
       }
       if (returns && (ref = needsRef(arg))) {
         usingRef = usingRef || ref;
@@ -6012,7 +6148,7 @@ function processPipelineExpressions(statements) {
         returning
       );
       if (result.type === "ReturnStatement") {
-        if (i2 < l - 1) {
+        if (i < body.length - 1) {
           result.children.push({
             type: "Error",
             message: "Can't continue a pipeline after returning"
@@ -6040,7 +6176,7 @@ function processPipelineExpressions(statements) {
       };
     }
     children.push(arg);
-    if (!children.some(($1) => $1?.type === "ReturnStatement") && children.some(($2) => $2 === ",")) {
+    if (!children.some(($2) => $2?.type === "ReturnStatement") && children.some(($3) => $3 === ",")) {
       const { parent } = s;
       const parenthesizedExpression = makeLeftHandSideExpression({ ...s });
       Object.assign(s, parenthesizedExpression, {
@@ -6048,17 +6184,17 @@ function processPipelineExpressions(statements) {
         hoistDec: void 0
       });
     }
-    return addParentPointers(s, s.parent);
-  });
+    addParentPointers(s, s.parent);
+  }
 }
 
 // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\for.civet.jsx
-function processRangeExpression(start, ws1, range, end) {
-  ws1 = [ws1, range.children[0]];
-  const ws2 = range.children[1];
-  const comma = { $loc: range.$loc, token: "," };
+function processRangeExpression(start, ws1, range2, end) {
+  ws1 = [ws1, range2.children[0]];
+  const ws2 = range2.children[1];
+  const comma = { $loc: range2.$loc, token: "," };
   let ref;
-  switch (range.increasing) {
+  switch (range2.increasing) {
     case true: {
       ref = ($) => $;
       break;
@@ -6073,7 +6209,7 @@ function processRangeExpression(start, ws1, range, end) {
   }
   ;
   const abs = ref;
-  const lengthAdjust = 1 - Number(!range.left.inclusive) - Number(!range.right.inclusive);
+  const lengthAdjust = 1 - Number(!range2.left.inclusive) - Number(!range2.right.inclusive);
   let children;
   if (typeof start === "object" && start != null && "type" in start && start.type === "Literal" && (typeof end === "object" && end != null && "type" in end && end.type === "Literal")) {
     let startValue = literalValue(start);
@@ -6086,7 +6222,7 @@ function processRangeExpression(start, ws1, range, end) {
       let endCode = endValue.charCodeAt(0);
       const step = startCode <= endCode ? 1 : -1;
       const length = abs(endCode - startCode) + lengthAdjust;
-      if (!range.left.inclusive) {
+      if (!range2.left.inclusive) {
         startCode += step;
       }
       if (length <= 26) {
@@ -6107,13 +6243,13 @@ function processRangeExpression(start, ws1, range, end) {
           ")"
         ];
       }
-      if (range.error != null) {
-        children.unshift(range.error);
+      if (range2.error != null) {
+        children.unshift(range2.error);
       }
     } else if (typeof startValue === "number" && typeof endValue === "number") {
       const step = startValue <= endValue ? 1 : -1;
       const length = abs(endValue - startValue) + lengthAdjust;
-      if (!range.left.inclusive) {
+      if (!range2.left.inclusive) {
         startValue += step;
       }
       if (length <= 20) {
@@ -6122,22 +6258,22 @@ function processRangeExpression(start, ws1, range, end) {
           Array.from({ length }, (_2, i) => startValue + i * step).join(", "),
           "]"
         ];
-        if (range.error != null) {
-          children.unshift(range.error);
+        if (range2.error != null) {
+          children.unshift(range2.error);
         }
       }
     }
   }
   if (!(children != null)) {
-    if (range.increasing != null) {
-      const sign = range.increasing ? "+" : "-";
+    if (range2.increasing != null) {
+      const sign = range2.increasing ? "+" : "-";
       end = makeLeftHandSideExpression(end);
       children = [
-        getHelperRef(range.increasing ? "range" : "revRange"),
+        getHelperRef(range2.increasing ? "range" : "revRange"),
         "(",
-        range.left.inclusive ? start : [makeLeftHandSideExpression(start), ` ${sign} 1`],
+        range2.left.inclusive ? start : [makeLeftHandSideExpression(start), ` ${sign} 1`],
         ",",
-        range.right.inclusive ? [makeLeftHandSideExpression(end), ` ${sign} 1`] : end,
+        range2.right.inclusive ? [makeLeftHandSideExpression(end), ` ${sign} 1`] : end,
         ...ws1,
         ")"
       ];
@@ -6146,11 +6282,11 @@ function processRangeExpression(start, ws1, range, end) {
         "((s, e) => s > e ? ",
         getHelperRef("revRange"),
         "(s, e",
-        range.right.inclusive ? " - 1" : void 0,
+        range2.right.inclusive ? " - 1" : void 0,
         ") : ",
         getHelperRef("range"),
         "(s, e",
-        range.right.inclusive ? " + 1" : void 0,
+        range2.right.inclusive ? " + 1" : void 0,
         "))",
         "(",
         start,
@@ -6167,14 +6303,14 @@ function processRangeExpression(start, ws1, range, end) {
     children,
     start,
     end,
-    error: range.error,
-    left: range.left,
-    right: range.right,
-    increasing: range.increasing
+    error: range2.error,
+    left: range2.left,
+    right: range2.right,
+    increasing: range2.increasing
   };
 }
-function forRange(open, forDeclaration, range, stepExp, close) {
-  let { start, end, left, right, increasing } = range;
+function forRange(open, forDeclaration, range2, stepExp, close) {
+  let { start, end, left, right, increasing } = range2;
   const counterRef = makeRef("i");
   const infinite = typeof end === "object" && end != null && "type" in end && end.type === "Identifier" && "name" in end && end.name === "Infinity";
   let stepRef, asc;
@@ -6273,7 +6409,7 @@ function forRange(open, forDeclaration, range, stepExp, close) {
     // This declaration doesn't always appear in the output,
     // but it's still helpful for determining the primary loop variable
     declaration: forDeclaration,
-    children: [range.error, open, declaration, "; ", ...condition, "; ", ...increment, close],
+    children: [range2.error, open, declaration, "; ", ...condition, "; ", ...increment, close],
     blockPrefix
   };
 }
@@ -6333,6 +6469,7 @@ function processForInOf($0) {
       declaration = {
         type: "Declaration",
         children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", trimFirstSpace(expRef2), ".length"],
+        decl: "let",
         names: []
       };
       const condition = [counterRef, " < ", lenRef, "; "];
@@ -6356,6 +6493,9 @@ function processForInOf($0) {
   }
   const { binding } = declaration;
   let pattern = binding?.pattern;
+  if (pattern?.type === "NamedBindingPattern") {
+    pattern = pattern.binding;
+  }
   if (binding?.typeSuffix || inOf.token === "in" && declaration2 && pattern.type !== "Identifier") {
     const itemRef = makeRef(inOf.token === "in" ? "key" : "item");
     blockPrefix.push(["", {
@@ -6394,12 +6534,14 @@ function processForInOf($0) {
       hoistDec = {
         type: "Declaration",
         children: ["let ", counterRef, " = 0"],
+        decl: "let",
         names: []
       };
       blockPrefix.push(["", {
         type: "Declaration",
         children: [trimFirstSpace(ws2), decl2, " = ", counterRef, "++"],
-        names: decl2.names
+        names: decl2.names,
+        decl: decl2.decl
       }, ";"]);
       break;
     }
@@ -6409,7 +6551,8 @@ function processForInOf($0) {
         hoistDec = {
           type: "Declaration",
           children: ["let ", expRef2],
-          names: []
+          names: [],
+          decl: "let"
         };
         exp = {
           type: "AssignmentExpression",
@@ -6421,20 +6564,58 @@ function processForInOf($0) {
         blockPrefix.push(["", ["if (!", hasPropRef, "(", trimFirstSpace(expRef2), ", ", trimFirstSpace(pattern), ")) continue"], ";"]);
       }
       if (decl2) {
-        blockPrefix.push(["", {
-          type: "Declaration",
+        const trimmedPattern = trimFirstSpace(pattern);
+        const expression = makeNode({
+          type: "MemberExpression",
           children: [
-            trimFirstSpace(ws2),
-            decl2,
-            " = ",
             trimFirstSpace(expRef2),
-            "[",
-            trimFirstSpace(pattern),
-            "]"
-          ],
-          decl: decl2,
-          names: decl2.names
-        }, ";"]);
+            makeNode({
+              type: "Index",
+              expression: trimmedPattern,
+              children: ["[", trimmedPattern, "]"]
+            })
+          ]
+        });
+        blockPrefix.push([
+          "",
+          (() => {
+            if (decl2.type === "ForDeclaration") {
+              const { binding: binding2, children } = decl2;
+              binding2.children.push(binding2.initializer = makeNode({
+                type: "Initializer",
+                expression,
+                children: [" = ", expression]
+              }));
+              return makeNode({
+                type: "Declaration",
+                children: [
+                  trimFirstSpace(ws2),
+                  ...children
+                ],
+                bindings: [decl2.binding],
+                decl: decl2.decl,
+                names: decl2.names
+              });
+            } else {
+              return makeNode({
+                type: "AssignmentExpression",
+                children: [
+                  trimFirstSpace(ws2),
+                  decl2,
+                  " = ",
+                  trimFirstSpace(expRef2),
+                  "[",
+                  trimFirstSpace(pattern),
+                  "]"
+                ],
+                names: decl2.names,
+                lhs: decl2,
+                assigned: decl2
+              });
+            }
+          })(),
+          ";"
+        ]);
       }
       ;
       break;
@@ -6964,7 +7145,7 @@ function processTryBlock($0) {
     const clauses = cs.map((clause) => {
       let ref1;
       if ((ref1 = clause.binding?.parameter) && typeof ref1 === "object" && "type" in ref1 && ref1.type === "CatchPattern" && "patterns" in ref1) {
-        const { type, patterns } = ref1;
+        const { patterns } = ref1;
         return {
           type: "PatternClause",
           patterns,
@@ -7155,14 +7336,21 @@ function processCallMemberExpression(node) {
       }
     }
     if (args.length) {
-      children.splice(
-        0,
-        2,
-        commaCount ? {
+      if (commaCount) {
+        children.splice(0, 2, {
           type: "ParenthesizedExpression",
-          children: ["(", ...call.children, ")"]
-        } : { ...call, type: "ParenthesizedExpression" }
-      );
+          children: ["(", call.children, ")"],
+          expression: call.children
+        });
+      } else {
+        const middle = call.children.slice(0 + 1, -1);
+        let ref2;
+        children.splice(0, 2, {
+          type: "ParenthesizedExpression",
+          expression: middle,
+          children: [call.children[0], middle, (ref2 = call.children)[ref2.length - 1]]
+        });
+      }
       if (children.length === 1) {
         return children[0];
       }
@@ -7245,14 +7433,14 @@ function processCallMemberExpression(node) {
           });
         }
       }
-      let ref2;
+      let ref3;
       const object = {
         type: "ObjectExpression",
         children: [
           glob.object.children[0],
           // {
           ...parts,
-          (ref2 = glob.object.children)[ref2.length - 1]
+          (ref3 = glob.object.children)[ref3.length - 1]
           // whitespace and }
         ],
         properties: parts
@@ -7313,7 +7501,7 @@ function processCallMemberExpression(node) {
           })
         ]
       });
-      let ref3;
+      let ref4;
       return processCallMemberExpression({
         // in case there are more
         ...node,
@@ -7327,7 +7515,7 @@ function processCallMemberExpression(node) {
               glob.children[0],
               // "[" token
               call,
-              (ref3 = glob.children)[ref3.length - 1]
+              (ref4 = glob.children)[ref4.length - 1]
               // "]" token
             ]
           }),
@@ -7340,7 +7528,7 @@ function processCallMemberExpression(node) {
         { ...glob.children[0], token: ", " },
         ...glob.children.slice(1, -1)
       ];
-      let ref4;
+      let ref5;
       const rsliceCall = makeNode({
         type: "CallExpression",
         implicit: true,
@@ -7352,7 +7540,7 @@ function processCallMemberExpression(node) {
             children: [
               "(",
               args,
-              (ref4 = glob.children)[ref4.length - 1]
+              (ref5 = glob.children)[ref5.length - 1]
             ]
           })
         ]
@@ -7437,8 +7625,8 @@ function convertNamedImportsToObject(node, pattern) {
       return { type: "Error", message: "cannot use `type` in dynamic import" };
     } else {
       const { source, binding } = specifier;
-      let ref5;
-      const delim = (ref5 = specifier.children)[ref5.length - 1];
+      let ref6;
+      const delim = (ref6 = specifier.children)[ref6.length - 1];
       return {
         type: pattern ? "BindingProperty" : "Property",
         name: source,
@@ -7448,7 +7636,7 @@ function convertNamedImportsToObject(node, pattern) {
       };
     }
   });
-  let ref6;
+  let ref7;
   return {
     type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
     names: node.names,
@@ -7457,7 +7645,7 @@ function convertNamedImportsToObject(node, pattern) {
       node.children[0],
       // {
       properties,
-      (ref6 = node.children)[ref6.length - 1]
+      (ref7 = node.children)[ref7.length - 1]
       // }
     ]
   };
@@ -7568,10 +7756,17 @@ function makeGetterMethod(name, ws, value, returnType, block, kind = { token: "g
 function processBindingPatternLHS(lhs, tail) {
   adjustAtBindings(lhs, true);
   const [splices, thisAssignments] = gatherBindingCode(lhs);
-  tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
+  const subbindings = gatherSubbindings(lhs);
+  simplifyBindingProperties(lhs);
+  simplifyBindingProperties(subbindings);
+  tail.push(
+    ...splices.map((s) => [", ", s]),
+    ...thisAssignments.map((a) => [", ", a]),
+    ...subbindings
+  );
 }
 function processAssignments(statements) {
-  for (let ref7 = gatherRecursiveAll(statements, ($4) => $4.type === "AssignmentExpression" || $4.type === "UpdateExpression"), i5 = 0, len3 = ref7.length; i5 < len3; i5++) {
+  for (let ref8 = gatherRecursiveAll(statements, ($4) => $4.type === "AssignmentExpression" || $4.type === "UpdateExpression"), i5 = 0, len3 = ref8.length; i5 < len3; i5++) {
     let extractAssignment = function(lhs) {
       let expr = lhs;
       while (expr.type === "ParenthesizedExpression") {
@@ -7591,20 +7786,20 @@ function processAssignments(statements) {
       ;
       return;
     };
-    const exp = ref7[i5];
+    const exp = ref8[i5];
     checkValidLHS(exp.assigned);
     const pre = [], post = [];
-    let ref8;
+    let ref9;
     switch (exp.type) {
       case "AssignmentExpression": {
         if (!exp.lhs) {
           continue;
         }
-        for (let ref9 = exp.lhs, i6 = 0, len4 = ref9.length; i6 < len4; i6++) {
-          const lhsPart = ref9[i6];
-          let ref10;
-          if (ref10 = extractAssignment(lhsPart[1])) {
-            const newLhs = ref10;
+        for (let ref10 = exp.lhs, i6 = 0, len4 = ref10.length; i6 < len4; i6++) {
+          const lhsPart = ref10[i6];
+          let ref11;
+          if (ref11 = extractAssignment(lhsPart[1])) {
+            const newLhs = ref11;
             lhsPart[1] = newLhs;
           }
         }
@@ -7612,8 +7807,8 @@ function processAssignments(statements) {
         break;
       }
       case "UpdateExpression": {
-        if (ref8 = extractAssignment(exp.assigned)) {
-          const newLhs = ref8;
+        if (ref9 = extractAssignment(exp.assigned)) {
+          const newLhs = ref9;
           const i = exp.children.indexOf(exp.assigned);
           exp.assigned = exp.children[i] = newLhs;
         }
@@ -7645,22 +7840,22 @@ function processAssignments(statements) {
       }
     }
   }
-  for (let ref11 = gatherRecursiveAll(statements, ($6) => $6.type === "AssignmentExpression"), i7 = 0, len5 = ref11.length; i7 < len5; i7++) {
-    const exp = ref11[i7];
+  for (let ref12 = gatherRecursiveAll(statements, ($6) => $6.type === "AssignmentExpression"), i7 = 0, len5 = ref12.length; i7 < len5; i7++) {
+    const exp = ref12[i7];
     if (!(exp.names === null)) {
       continue;
     }
     let { lhs: $1, expression: $2 } = exp, tail = [], len3 = $1.length;
     let block;
-    let ref12;
-    if (blockContainingStatement(exp) && !(ref12 = $1[$1.length - 1])?.[ref12.length - 1]?.special) {
+    let ref13;
+    if (blockContainingStatement(exp) && !(ref13 = $1[$1.length - 1])?.[ref13.length - 1]?.special) {
       block = makeBlockFragment();
-      let ref13;
-      if (ref13 = prependStatementExpressionBlock(
+      let ref14;
+      if (ref14 = prependStatementExpressionBlock(
         { type: "Initializer", expression: $2, children: [void 0, void 0, $2] },
         block
       )) {
-        const ref = ref13;
+        const ref = ref14;
         exp.children = exp.children.map(($7) => $7 === $2 ? ref : $7);
         $2 = ref;
       } else {
@@ -7737,7 +7932,7 @@ function processAssignments(statements) {
             message: "Slice range cannot be decreasing in assignment"
           });
           break;
-        } else if (m3 = lhs.type, m3 === "ObjectBindingPattern" || m3 === "ArrayBindingPattern") {
+        } else if (m3 = lhs.type, m3 === "ObjectBindingPattern" || m3 === "ArrayBindingPattern" || m3 === "NamedBindingPattern") {
           processBindingPatternLHS(lhs, tail);
           gatherRecursiveAll(lhs, ($9) => $9.type === "Ref").forEach(refsToDeclare.add.bind(refsToDeclare));
         }
@@ -7841,9 +8036,9 @@ function unchainOptionalMemberExpression(exp, ref, innerExp) {
     }
     j++;
   }
-  let ref14;
-  if (ref14 = conditions.length) {
-    const l = ref14;
+  let ref15;
+  if (ref15 = conditions.length) {
+    const l = ref15;
     const cs = flatJoin(conditions, " && ");
     return {
       ...exp,
@@ -7879,14 +8074,14 @@ function attachPostfixStatementAsExpression(exp, post) {
 }
 function processTypes(node) {
   const results1 = [];
-  for (let ref15 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len6 = ref15.length; i8 < len6; i8++) {
-    const unary = ref15[i8];
+  for (let ref16 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len6 = ref16.length; i8 < len6; i8++) {
+    const unary = ref16[i8];
     let suffixIndex = unary.suffix.length - 1;
     const results2 = [];
     while (suffixIndex >= 0) {
       const suffix = unary.suffix[suffixIndex];
       if (typeof suffix === "object" && suffix != null && "token" in suffix && suffix.token === "?") {
-        const { token } = suffix;
+        const {} = suffix;
         let count = 0;
         let m4;
         while (m4 = unary.suffix[suffixIndex], typeof m4 === "object" && m4 != null && "token" in m4 && m4.token === "?") {
@@ -7944,7 +8139,7 @@ function processTypes(node) {
         }
         results2.push(replaceNode(unary, replace, parent));
       } else if (typeof suffix === "object" && suffix != null && "type" in suffix && suffix.type === "NonNullAssertion") {
-        const { type } = suffix;
+        const {} = suffix;
         let m6;
         while (m6 = unary.suffix[suffixIndex], typeof m6 === "object" && m6 != null && "type" in m6 && m6.type === "NonNullAssertion") {
           unary.suffix.splice(suffixIndex--, 1);
@@ -7959,10 +8154,10 @@ function processTypes(node) {
         const outer = unary.suffix.splice(suffixIndex + 1, Infinity);
         const space = getTrimmingSpace(unary);
         inplaceInsertTrimmingSpace(unary, "");
-        let ref16;
-        if (unary.suffix.length) ref16 = unary;
-        else ref16 = unary.t;
-        const t = ref16;
+        let ref17;
+        if (unary.suffix.length) ref17 = unary;
+        else ref17 = unary.t;
+        const t = ref17;
         const arg = makeNode({
           type: "TypeArgument",
           ts: true,
@@ -8007,18 +8202,18 @@ function processTypes(node) {
   return results1;
 }
 function processStatementExpressions(statements) {
-  for (let ref17 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len7 = ref17.length; i9 < len7; i9++) {
-    const exp = ref17[i9];
+  for (let ref18 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len7 = ref18.length; i9 < len7; i9++) {
+    const exp = ref18[i9];
     const { maybe, statement } = exp;
     if ((maybe || statement.type === "ThrowStatement") && blockContainingStatement(exp)) {
       replaceNode(exp, statement);
       continue;
     }
-    let ref18;
+    let ref19;
     switch (statement.type) {
       case "IfStatement": {
-        if (ref18 = expressionizeIfStatement(statement)) {
-          const expression = ref18;
+        if (ref19 = expressionizeIfStatement(statement)) {
+          const expression = ref19;
           replaceNode(statement, expression, exp);
         } else {
           replaceNode(statement, wrapIIFE([["", statement]]), exp);
@@ -8077,13 +8272,13 @@ function processNegativeIndexAccess(statements) {
   });
 }
 function processFinallyClauses(statements) {
-  for (let ref19 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len8 = ref19.length; i10 < len8; i10++) {
-    let f = ref19[i10];
-    let ref20;
-    if (!((ref20 = blockContainingStatement(f)) && typeof ref20 === "object" && "block" in ref20 && "index" in ref20)) {
+  for (let ref20 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len8 = ref20.length; i10 < len8; i10++) {
+    let f = ref20[i10];
+    let ref21;
+    if (!((ref21 = blockContainingStatement(f)) && typeof ref21 === "object" && "block" in ref21 && "index" in ref21)) {
       throw new Error("finally clause must be inside try statement or block");
     }
-    const { block, index } = ref20;
+    const { block, index } = ref21;
     const indent = block.expressions[index][0];
     const expressions = block.expressions.slice(index + 1);
     const t = makeNode({
@@ -8155,8 +8350,8 @@ function processBreaksContinues(statements) {
   }
 }
 function processCoffeeClasses(statements) {
-  for (let ref21 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref21.length; i11 < len9; i11++) {
-    const ce = ref21[i11];
+  for (let ref22 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref22.length; i11 < len9; i11++) {
+    const ce = ref22[i11];
     const { expressions } = ce.body;
     const indent = expressions[0]?.[0] ?? "\n";
     const autoBinds = expressions.filter(($14) => $14[1]?.autoBind);
@@ -8306,8 +8501,8 @@ async function processProgramAsync(root) {
 function processRepl(root, rootIIFE) {
   const topBlock = gatherRecursive(rootIIFE, ($17) => $17.type === "BlockStatement")[0];
   let i = 0;
-  for (let ref22 = gatherRecursiveWithinFunction(topBlock, ($18) => $18.type === "Declaration"), i14 = 0, len11 = ref22.length; i14 < len11; i14++) {
-    const decl = ref22[i14];
+  for (let ref23 = gatherRecursiveWithinFunction(topBlock, ($18) => $18.type === "Declaration"), i14 = 0, len11 = ref23.length; i14 < len11; i14++) {
+    const decl = ref23[i14];
     if (!decl.names?.length) {
       continue;
     }
@@ -8320,8 +8515,8 @@ function processRepl(root, rootIIFE) {
       root.expressions.splice(i++, 0, ["", `var ${decl.names.join(",")}`, ";"]);
     }
   }
-  for (let ref23 = gatherRecursive(topBlock, ($19) => $19.type === "FunctionExpression"), i15 = 0, len12 = ref23.length; i15 < len12; i15++) {
-    const func = ref23[i15];
+  for (let ref24 = gatherRecursive(topBlock, ($19) => $19.type === "FunctionExpression"), i15 = 0, len12 = ref24.length; i15 < len12; i15++) {
+    const func = ref24[i15];
     if (func.name && func.parent?.type === "BlockStatement") {
       if (func.parent === topBlock) {
         replaceNode(func, void 0);
@@ -8333,8 +8528,8 @@ function processRepl(root, rootIIFE) {
       }
     }
   }
-  for (let ref24 = gatherRecursiveWithinFunction(topBlock, ($20) => $20.type === "ClassExpression"), i16 = 0, len13 = ref24.length; i16 < len13; i16++) {
-    const classExp = ref24[i16];
+  for (let ref25 = gatherRecursiveWithinFunction(topBlock, ($20) => $20.type === "ClassExpression"), i16 = 0, len13 = ref25.length; i16 < len13; i16++) {
+    const classExp = ref25[i16];
     let m8;
     if (classExp.name && classExp.parent === topBlock || (m8 = classExp.parent, typeof m8 === "object" && m8 != null && "type" in m8 && m8.type === "ReturnStatement" && "parent" in m8 && m8.parent === topBlock)) {
       classExp.children.unshift(classExp.name, "=");
@@ -8342,31 +8537,11 @@ function processRepl(root, rootIIFE) {
     }
   }
 }
-function populateRefs(statements) {
-  const refNodes = gatherRecursive(statements, ($21) => $21.type === "Ref");
-  if (refNodes.length) {
-    const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
-    const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
-    refNodes.forEach((ref) => {
-      const { type, base } = ref;
-      if (type !== "Ref") return;
-      ref.type = "Identifier";
-      let n = 0;
-      let name = base;
-      while (names.has(name)) {
-        n++;
-        name = `${base}${n}`;
-      }
-      names.add(name);
-      return ref.children = ref.names = [name];
-    });
-  }
-}
 function processPlaceholders(statements) {
   const placeholderMap = /* @__PURE__ */ new Map();
   const liftedIfs = /* @__PURE__ */ new Set();
-  for (let ref25 = gatherRecursiveAll(statements, ($22) => $22.type === "Placeholder"), i17 = 0, len14 = ref25.length; i17 < len14; i17++) {
-    const exp = ref25[i17];
+  for (let ref26 = gatherRecursiveAll(statements, ($21) => $21.type === "Placeholder"), i17 = 0, len14 = ref26.length; i17 < len14; i17++) {
+    const exp = ref26[i17];
     let ancestor;
     if (exp.subtype === ".") {
       ({ ancestor } = findAncestor(
@@ -8478,8 +8653,8 @@ function processPlaceholders(statements) {
     for (let i18 = 0, len15 = placeholders.length; i18 < len15; i18++) {
       const placeholder = placeholders[i18];
       typeSuffix ??= placeholder.typeSuffix;
-      let ref26;
-      (ref26 = placeholder.children)[ref26.length - 1] = ref;
+      let ref27;
+      (ref27 = placeholder.children)[ref27.length - 1] = ref;
     }
     const { parent } = ancestor;
     const body = maybeUnwrap(ancestor);
@@ -8500,16 +8675,16 @@ function processPlaceholders(statements) {
       }
       case "PipelineExpression": {
         const i = findChildIndex(parent, ancestor);
-        let ref27;
+        let ref28;
         if (i === 1) {
-          ref27 = ancestor === parent.children[i];
+          ref28 = ancestor === parent.children[i];
         } else if (i === 2) {
-          ref27 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
+          ref28 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
         } else {
-          ref27 = void 0;
+          ref28 = void 0;
         }
         ;
-        outer = ref27;
+        outer = ref28;
         break;
       }
       case "AssignmentExpression":
@@ -8524,9 +8699,12 @@ function processPlaceholders(statements) {
       fnExp = makeLeftHandSideExpression(fnExp);
     }
     replaceNode(ancestor, fnExp, parent);
-    let ref28;
-    if (ref28 = getTrimmingSpace(body)) {
-      const ws = ref28;
+    if (typeof parent === "object" && parent != null && "type" in parent && parent.type === "BlockStatement" && "parent" in parent && typeof parent.parent === "object" && parent.parent != null && "type" in parent.parent && parent.parent.type === "ArrowFunction" && "ampersandBlock" in parent.parent && parent.parent.ampersandBlock === true && "body" in parent.parent && parent.parent.body === body) {
+      parent.parent.body = fnExp;
+    }
+    let ref29;
+    if (ref29 = getTrimmingSpace(body)) {
+      const ws = ref29;
       inplaceInsertTrimmingSpace(body, "");
       inplacePrepend(ws, fnExp);
     }
@@ -8570,8 +8748,8 @@ function reorderBindingRestProperty(props) {
       }
     ];
   }
-  let ref29;
-  if (Array.isArray(rest.delim) && (ref29 = rest.delim)[ref29.length - 1]?.token === ",") {
+  let ref30;
+  if (Array.isArray(rest.delim) && (ref30 = rest.delim)[ref30.length - 1]?.token === ",") {
     rest.delim = rest.delim.slice(0, -1);
     rest.children = [...rest.children.slice(0, -1), rest.delim];
   }
@@ -8808,6 +8986,7 @@ var grammar = {
   NWBindingIdentifier,
   AtIdentifierRef,
   PinPattern,
+  NamedBindingPattern,
   BindingPattern,
   ObjectBindingPattern,
   ObjectBindingPatternContent,
@@ -10758,24 +10937,27 @@ var PipelineHeadItem$$ = [PipelineHeadItem$0, PipelineHeadItem$1];
 function PipelineHeadItem(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "PipelineHeadItem", PipelineHeadItem$$);
 }
-var PipelineTailItem$0 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$C)(AwaitOp, Yield, Return, Throw), (0, import_lib2.$N)(AccessStart), (0, import_lib2.$N)(MaybeParenNestedExpression)), function(value) {
+var PipelineTailItem$0 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$C)(AwaitOp, Return, Throw), (0, import_lib2.$N)(AccessStart), (0, import_lib2.$N)(MaybeParenNestedExpression)), function(value) {
   return value[0];
 });
-var PipelineTailItem$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L15, 'PipelineTailItem "import"'), (0, import_lib2.$N)(AccessStart)), function($skip, $loc, $0, $1, $2) {
+var PipelineTailItem$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$TEXT)((0, import_lib2.$S)(Yield, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)(_), Star)))), (0, import_lib2.$N)(AccessStart), (0, import_lib2.$N)(MaybeParenNestedExpression)), function($skip, $loc, $0, $1, $2, $3) {
+  return { $loc, token: $1, type: "Yield" };
+});
+var PipelineTailItem$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L15, 'PipelineTailItem "import"'), (0, import_lib2.$N)(AccessStart)), function($skip, $loc, $0, $1, $2) {
   return {
     type: "Identifier",
     children: [$1]
   };
 });
-var PipelineTailItem$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(NWTypePostfix, (0, import_lib2.$Q)(TypePostfix)), function($skip, $loc, $0, $1, $2) {
+var PipelineTailItem$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(NWTypePostfix, (0, import_lib2.$Q)(TypePostfix)), function($skip, $loc, $0, $1, $2) {
   return makeAmpersandFunction({
     body: [" ", $1, ...$2]
   });
 });
-var PipelineTailItem$3 = (0, import_lib2.$T)((0, import_lib2.$S)(PipelineHeadItem), function(value) {
+var PipelineTailItem$4 = (0, import_lib2.$T)((0, import_lib2.$S)(PipelineHeadItem), function(value) {
   return value[0];
 });
-var PipelineTailItem$$ = [PipelineTailItem$0, PipelineTailItem$1, PipelineTailItem$2, PipelineTailItem$3];
+var PipelineTailItem$$ = [PipelineTailItem$0, PipelineTailItem$1, PipelineTailItem$2, PipelineTailItem$3, PipelineTailItem$4];
 function PipelineTailItem(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "PipelineTailItem", PipelineTailItem$$);
 }
@@ -11357,8 +11539,9 @@ var LeftHandSideExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, impo
     expression
   };
 });
-var LeftHandSideExpression$1 = CallExpression;
-var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
+var LeftHandSideExpression$1 = NamedBindingPattern;
+var LeftHandSideExpression$2 = CallExpression;
+var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1, LeftHandSideExpression$2];
 function LeftHandSideExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "LeftHandSideExpression", LeftHandSideExpression$$);
 }
@@ -11981,7 +12164,7 @@ var FunctionRestParameter$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, impor
 function FunctionRestParameter(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "FunctionRestParameter", FunctionRestParameter$0);
 }
-var ParameterElement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$E)(AccessModifier), (0, import_lib2.$E)(_), (0, import_lib2.$C)(NWBindingIdentifier, BindingPattern), (0, import_lib2.$E)(TypeSuffix), (0, import_lib2.$E)(Initializer), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+var ParameterElement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$E)(AccessModifier), (0, import_lib2.$E)(_), (0, import_lib2.$C)(BindingPattern, NWBindingIdentifier), (0, import_lib2.$E)(TypeSuffix), (0, import_lib2.$E)(Initializer), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
   var accessModifier = $2;
   var binding = $4;
   var typeSuffix = $5;
@@ -12094,12 +12277,31 @@ var PinPattern$$ = [PinPattern$0, PinPattern$1, PinPattern$2, PinPattern$3];
 function PinPattern(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "PinPattern", PinPattern$$);
 }
+var NamedBindingPattern$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(BindingIdentifier, Caret, (0, import_lib2.$E)(_), BindingPattern), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var binding = $1;
+  var ws = $3;
+  var pattern = $4;
+  pattern = prepend(ws, pattern);
+  return {
+    type: "NamedBindingPattern",
+    // NOTE: children just has binding, not pattern, for easy destructuring
+    children: [binding],
+    binding,
+    pattern,
+    subbinding: [pattern, " = ", binding],
+    typeSuffix: pattern.typeSuffix
+  };
+});
+function NamedBindingPattern(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "NamedBindingPattern", NamedBindingPattern$0);
+}
 var BindingPattern$0 = ObjectBindingPattern;
 var BindingPattern$1 = ArrayBindingPattern;
 var BindingPattern$2 = PinPattern;
 var BindingPattern$3 = Literal;
 var BindingPattern$4 = RegularExpressionLiteral;
-var BindingPattern$$ = [BindingPattern$0, BindingPattern$1, BindingPattern$2, BindingPattern$3, BindingPattern$4];
+var BindingPattern$5 = NamedBindingPattern;
+var BindingPattern$$ = [BindingPattern$0, BindingPattern$1, BindingPattern$2, BindingPattern$3, BindingPattern$4, BindingPattern$5];
 function BindingPattern(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "BindingPattern", BindingPattern$$);
 }
@@ -12223,7 +12425,7 @@ function NestedBindingPropertyList(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "NestedBindingPropertyList", NestedBindingPropertyList$0);
 }
 var BindingProperty$0 = BindingRestProperty;
-var BindingProperty$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), PropertyName, (0, import_lib2.$E)(Caret), (0, import_lib2.$E)(_), Colon, (0, import_lib2.$E)(_), (0, import_lib2.$C)(BindingIdentifier, BindingPattern), (0, import_lib2.$E)(BindingTypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+var BindingProperty$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), PropertyName, (0, import_lib2.$E)(Caret), (0, import_lib2.$E)(_), Colon, (0, import_lib2.$E)(_), (0, import_lib2.$C)(BindingPattern, BindingIdentifier), (0, import_lib2.$E)(BindingTypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
   var ws1 = $1;
   var name = $2;
   var bind = $3;
@@ -12233,6 +12435,19 @@ var BindingProperty$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
   var value = $7;
   var typeSuffix = $8;
   var initializer = $9;
+  if (bind) {
+    const binding = name, pattern = value;
+    value = {
+      type: "NamedBindingPattern",
+      // NOTE: children just has binding, not pattern, for easy destructuring
+      children: [binding],
+      binding,
+      pattern,
+      subbinding: [pattern, " = ", binding],
+      typeSuffix: pattern.typeSuffix,
+      names: value.names
+    };
+  }
   return {
     type: "BindingProperty",
     children: [ws1, name, ws2, colon, ws3, value, initializer],
@@ -12241,8 +12456,7 @@ var BindingProperty$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
     value,
     typeSuffix,
     initializer,
-    names: value.names,
-    bind: !!bind
+    names: value.names
   };
 });
 var BindingProperty$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), Caret, BindingIdentifier, (0, import_lib2.$E)(BindingTypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
@@ -12307,8 +12521,7 @@ var BindingProperty$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
     typeSuffix,
     initializer,
     names: binding.names,
-    identifier: binding,
-    bind: !!bind
+    identifier: binding
   };
 });
 var BindingProperty$$ = [BindingProperty$0, BindingProperty$1, BindingProperty$2, BindingProperty$3];
@@ -12366,7 +12579,7 @@ function NestedBindingElements(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "NestedBindingElements", NestedBindingElements$0);
 }
 var BindingElement$0 = BindingRestElement;
-var BindingElement$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$C)(BindingIdentifier, BindingPattern), (0, import_lib2.$E)(BindingTypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
+var BindingElement$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$C)(BindingPattern, BindingIdentifier), (0, import_lib2.$E)(BindingTypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
   var ws = $1;
   var binding = $2;
   var typeSuffix = $3;
@@ -12391,7 +12604,7 @@ var BindingElement$$ = [BindingElement$0, BindingElement$1, BindingElement$2];
 function BindingElement(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "BindingElement", BindingElement$$);
 }
-var BindingRestElement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), DotDotDot, (0, import_lib2.$C)(BindingIdentifier, BindingPattern, EmptyBindingPattern), (0, import_lib2.$E)(BindingTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4) {
+var BindingRestElement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), DotDotDot, (0, import_lib2.$C)(BindingPattern, BindingIdentifier, EmptyBindingPattern), (0, import_lib2.$E)(BindingTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4) {
   var ws = $1;
   var dots = $2;
   var binding = $3;
@@ -12407,7 +12620,7 @@ var BindingRestElement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
     rest: true
   };
 });
-var BindingRestElement$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$C)(BindingIdentifier, BindingPattern), DotDotDot), function($skip, $loc, $0, $1, $2, $3) {
+var BindingRestElement$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$C)(BindingPattern, BindingIdentifier), DotDotDot), function($skip, $loc, $0, $1, $2, $3) {
   var ws = $1;
   var binding = $2;
   var dots = $3;
@@ -12495,13 +12708,17 @@ var FunctionExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(FunctionSign
     block
   };
 });
-var FunctionExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(ArrowFunction), OpenParen, BinaryOp, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
+var FunctionExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(ArrowFunction), OpenParen, __, BinaryOp, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var open = $2;
-  var op = $3;
-  var close = $4;
+  var ws1 = $3;
+  var op = $4;
+  var ws2 = $5;
+  var close = $6;
   if (op.special && op.call && !op.negated) return op.call;
+  if (!ws1) ws1 = op.spaced ? [" "] : [];
+  if (!ws2) ws2 = op.spaced ? [" "] : [];
   const refA = makeRef("a"), refB = makeRef("b"), body = processBinaryOpExpression([refA, [
-    [[], op, [], refB]
+    [ws1, op, ws2, refB]
     // BinaryOpRHS
   ]]);
   const parameterList = [[refA, ","], refB];
@@ -12533,6 +12750,8 @@ var FunctionExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, N
   var op = $4;
   var ws2 = $5;
   var close = $6;
+  if (!ws1) ws1 = op.spaced ? [" "] : [];
+  if (!ws2) ws2 = op.spaced ? [" "] : [];
   const refB = makeRef("b");
   const fn = makeAmpersandFunction({
     ref: refB,
@@ -12599,6 +12818,8 @@ var FunctionExpression$5 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, _
   var ws2 = $6;
   var rhs = $7;
   var close = $8;
+  if (!ws1) ws1 = op.spaced ? [" "] : [];
+  if (!ws2) ws2 = op.spaced ? [" "] : [];
   const refA = makeRef("a");
   const fn = makeAmpersandFunction({
     ref: refA,
@@ -12623,10 +12844,9 @@ var OperatorDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Operator, (
   var w = $3;
   var decl = $4;
   decl.names.forEach((name) => state.operators.set(name, behavior));
-  return {
-    ...decl,
-    children: [trimFirstSpace(w), ...decl.children]
-  };
+  if (behavior?.error) decl = prepend(behavior.error, decl);
+  decl = prepend(trimFirstSpace(w), decl);
+  return decl;
 });
 var OperatorDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(OperatorSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
   var signature = $1;
@@ -12647,11 +12867,16 @@ var OperatorDeclaration$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(Operator, _
   var id = $3;
   var behavior = $4;
   var ids = $5;
+  const children = [];
   state.operators.set(id.name, behavior);
-  ids.forEach(([, , id2, behavior2]) => state.operators.set(id2.name, behavior2));
+  if (behavior?.error) children.push(behavior.error);
+  ids.forEach(([, , id2, behavior2]) => {
+    state.operators.set(id2.name, behavior2);
+    if (behavior2?.error) children.push(behavior2.error);
+  });
   return {
     id,
-    children: []
+    children
   };
 });
 var OperatorDeclaration$$ = [OperatorDeclaration$0, OperatorDeclaration$1, OperatorDeclaration$2];
@@ -12689,7 +12914,7 @@ var OperatorSignature$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
       generator: !!generator.length
     },
     block: null,
-    children: [async, func, generator, w1, id, w2, parameters, returnType],
+    children: [async, func, generator, w1, id, behavior?.error, w2, parameters, returnType],
     behavior
   };
 });
@@ -12709,16 +12934,29 @@ function OperatorBehavior(ctx, state2) {
 var OperatorPrecedence$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$C)((0, import_lib2.$EXPECT)($L27, 'OperatorPrecedence "tighter"'), (0, import_lib2.$EXPECT)($L28, 'OperatorPrecedence "looser"'), (0, import_lib2.$EXPECT)($L29, 'OperatorPrecedence "same"')), NonIdContinue, (0, import_lib2.$E)(_), (0, import_lib2.$C)(Identifier, (0, import_lib2.$S)(OpenParen, BinaryOp, CloseParen))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var mod = $2;
   var op = $5;
-  let prec = op.type === "Identifier" ? state.operators.get(op.name).prec : getPrecedence(op[1]);
+  let prec, error;
+  if (op.type === "Identifier") {
+    if (state.operators.has(op.name)) {
+      prec = state.operators.get(op.name).prec;
+    } else {
+      prec = precedenceCustomDefault;
+      error = {
+        type: "Error",
+        message: `Precedence refers to unknown operator ${op.name}`
+      };
+    }
+  } else {
+    prec = getPrecedence(op[1]);
+  }
   switch (mod) {
     case "tighter":
-      prec += 1 / 64;
+      prec += precedenceStep;
       break;
     case "looser":
-      prec -= 1 / 64;
+      prec -= precedenceStep;
       break;
   }
-  return { prec };
+  return { prec, error };
 });
 function OperatorPrecedence(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "OperatorPrecedence", OperatorPrecedence$0);
@@ -13416,9 +13654,9 @@ function RangeEnd(ctx, state2) {
 var RangeExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Expression, __, RangeDots, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
   var start = $1;
   var ws = $2;
-  var range = $3;
+  var range2 = $3;
   var end = $4;
-  return processRangeExpression(start, ws, range, end);
+  return processRangeExpression(start, ws, range2, end);
 });
 var RangeExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Expression, __, DotDot, (0, import_lib2.$Y)((0, import_lib2.$S)(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
   var s = $1;
@@ -14556,6 +14794,7 @@ var BinaryOpSymbol$13 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L23, 'Bin
   return {
     $loc,
     token: "instanceof",
+    spaced: true,
     relational: true,
     special: true
   };
@@ -14564,6 +14803,7 @@ var BinaryOpSymbol$14 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L84, 'Bin
   return {
     $loc,
     token: "instanceof",
+    spaced: true,
     relational: true,
     special: true,
     negated: true
@@ -14639,6 +14879,7 @@ var BinaryOpSymbol$40 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
   return {
     $loc,
     token: $1,
+    spaced: true,
     relational: true,
     special: true
     // for typeof shorthand
@@ -14741,6 +14982,7 @@ var CoffeeOfOp$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(OmittedNegation, __,
   return {
     $loc,
     token: "in",
+    spaced: true,
     special: true,
     negated: true
   };
@@ -14762,6 +15004,7 @@ var NotOp$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)(
   return {
     $loc,
     token: "instanceof",
+    spaced: true,
     relational: true,
     special: true,
     negated: true
@@ -14771,6 +15014,7 @@ var NotOp$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(In), function($skip, $loc
   return {
     $loc,
     token: "in",
+    spaced: true,
     special: true,
     negated: true
   };
@@ -15556,10 +15800,13 @@ var ForDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(LetOrConstOrVar,
 var ForDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertConst, (0, import_lib2.$N)(ActualMemberExpression), ForBinding), function($skip, $loc, $0, $1, $2, $3) {
   var c = $1;
   var binding = $3;
+  if (gatherRecursive(binding, ($) => $.type === "PinPattern").length) {
+    return $skip;
+  }
   return {
     type: "ForDeclaration",
     children: [c, binding],
-    decl: c.token,
+    decl: c.token.trimEnd(),
     binding,
     names: binding.names
   };
@@ -15729,12 +15976,17 @@ function PatternExpressionList(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "PatternExpressionList", PatternExpressionList$0);
 }
 var PatternExpression$0 = BindingPattern;
-var PatternExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidIndentedApplication, (0, import_lib2.$E)((0, import_lib2.$P)(SingleLineBinaryOpRHS)), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
-  var pattern = $2;
-  if (!pattern) return $skip;
+var PatternExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidIndentedApplication, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(BindingIdentifier, (0, import_lib2.$E)(Caret))), (0, import_lib2.$P)(SingleLineBinaryOpRHS))), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
+  var body = $2;
+  if (!body) return $skip;
+  const [named, rhs] = body;
+  let binding;
+  if (named) [binding] = named;
   return {
     type: "ConditionFragment",
-    children: pattern
+    children: [binding, rhs],
+    binding,
+    rhs
   };
 });
 var PatternExpression$$ = [PatternExpression$0, PatternExpression$1];
@@ -15846,31 +16098,31 @@ var FinallyClause$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Finally, (0, impo
 function FinallyClause(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "FinallyClause", FinallyClause$0);
 }
-var CatchParameter$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(BindingIdentifier, (0, import_lib2.$E)(TypeSuffix)), function($skip, $loc, $0, $1, $2) {
+var CatchParameter$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)(ObjectBindingPattern, ArrayBindingPattern), TypeSuffix), function($skip, $loc, $0, $1, $2) {
   var binding = $1;
   var typeSuffix = $2;
   return {
     type: "CatchParameter",
     binding,
     typeSuffix,
-    children: $0
+    children: [binding, typeSuffix]
   };
 });
-var CatchParameter$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)(ObjectBindingPattern, ArrayBindingPattern), TypeSuffix), function($skip, $loc, $0, $1, $2) {
+var CatchParameter$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(PatternExpressionList), function($skip, $loc, $0, $1) {
+  return {
+    type: "CatchPattern",
+    children: $0,
+    patterns: $1
+  };
+});
+var CatchParameter$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(BindingIdentifier, (0, import_lib2.$E)(TypeSuffix)), function($skip, $loc, $0, $1, $2) {
   var binding = $1;
   var typeSuffix = $2;
   return {
     type: "CatchParameter",
     binding,
     typeSuffix,
-    children: [binding, typeSuffix]
-  };
-});
-var CatchParameter$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PatternExpressionList), function($skip, $loc, $0, $1) {
-  return {
-    type: "CatchPattern",
-    children: $0,
-    patterns: $1
+    children: $0
   };
 });
 var CatchParameter$$ = [CatchParameter$0, CatchParameter$1, CatchParameter$2];
@@ -16364,12 +16616,15 @@ var ImportDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
   var imports = $5;
   var ws2 = $6;
   var from = $7;
+  const errors = [];
+  if (behavior?.error) errors.push(behavior.error);
   imports.specifiers.forEach((spec) => {
     state.operators.set(spec.binding.name, spec.behavior ?? behavior);
+    if (spec.behavior?.error) errors.push(spec.behavior.error);
   });
   return {
     type: "ImportDeclaration",
-    children: [i, trimFirstSpace(ws1), imports, ws2, from],
+    children: [i, ...errors, trimFirstSpace(ws1), imports, ws2, from],
     // omit $2 = Operator and $3 = OperatorBehavior
     imports,
     from
@@ -16412,12 +16667,15 @@ var ImportDeclaration$5 = (0, import_lib2.$TS)((0, import_lib2.$S)(ImpliedFromCl
   var behavior = $6;
   var ows = $7;
   var imports = $8;
+  const errors = [];
+  if (behavior?.error) errors.push(behavior.error);
   imports.specifiers.forEach((spec) => {
     state.operators.set(spec.binding.name, spec.behavior ?? behavior);
+    if (spec.behavior?.error) errors.push(spec.behavior.error);
   });
   return {
     type: "ImportDeclaration",
-    children: [i, iws, trimFirstSpace(ows), imports, fws, from],
+    children: [i, iws, ...errors, trimFirstSpace(ows), imports, fws, from],
     // omit Operator and OperatorBehavior
     imports,
     from
@@ -16599,7 +16857,7 @@ var OperatorImportSpecifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, Mod
   return {
     binding,
     behavior,
-    children: [$1, $2, $4, $5, $6, $7]
+    children: [$1, $2, $3?.error, $4, $5, $6, $7]
   };
 });
 var OperatorImportSpecifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, ImportedBinding, (0, import_lib2.$E)(OperatorBehavior), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
@@ -16608,7 +16866,7 @@ var OperatorImportSpecifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, Imp
   return {
     binding,
     behavior,
-    children: [$1, $2, $4]
+    children: [$1, $2, $3?.error, $4]
   };
 });
 var OperatorImportSpecifier$$ = [OperatorImportSpecifier$0, OperatorImportSpecifier$1];
@@ -17486,7 +17744,7 @@ var By$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L1
 function By(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "By", By$0);
 }
-var Caret$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L22, 'Caret "^"'), function($skip, $loc, $0, $1) {
+var Caret$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L22, 'Caret "^"'), (0, import_lib2.$N)((0, import_lib2.$EXPECT)($L22, 'Caret "^"'))), function($skip, $loc, $0, $1, $2) {
   return { $loc, token: $1 };
 });
 function Caret(ctx, state2) {
@@ -17731,7 +17989,7 @@ function Import(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "Import", Import$0);
 }
 var In$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L180, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-  return { $loc, token: $1 };
+  return { $loc, token: $1, spaced: true };
 });
 function In(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "In", In$0);