@danielx/civet 0.9.4 → 0.9.6

package/dist/browser.js

@@ -473,6 +473,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     maybeRefAssignment: () => maybeRefAssignment,
     modifyString: () => modifyString,
     negateCondition: () => negateCondition,
+    precedenceCustomDefault: () => precedenceCustomDefault,
     precedenceStep: () => precedenceStep,
     prepend: () => prepend,
     processAssignmentDeclaration: () => processAssignmentDeclaration,
@@ -1271,6 +1272,14 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
   }
 
   // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\ref.civet.jsx
+  var range = (start, end) => {
+    let length = end - start;
+    if (length <= 0) return [];
+    let 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",
@@ -1281,7 +1290,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
   function needsRef(expression, base = "ref") {
     if (expression != null && typeof expression == "object") {
       if (Array.isArray(expression)) {
-        let nonempty = ((s) => Array.from({ length: expression.length - s }, (_2, i) => s + i))(0).filter((i) => !isWhitespaceOrEmpty(expression[i]));
+        let nonempty = range(0, expression.length).filter((i) => !isWhitespaceOrEmpty(expression[i]));
         if (nonempty.length === 1) {
           let ref1;
           return (ref1 = needsRef(expression[nonempty[0]], base)) ? ref1 : void 0;
@@ -1320,10 +1329,27 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     let ref = maybeRef(exp, base);
     return ref === exp ? { ref, refAssignmentComma: [] } : { ref, ...makeRefAssignment(ref, exp) };
   }
+  function populateRefs(statements) {
+    let refNodes = gatherRecursive(statements, ($) => $.type === "Ref");
+    if (!refNodes.length)
+      return;
+    let ids = gatherRecursive(statements, ($1) => $1.type === "Identifier"), names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
+    for (let i1 = 0, len3 = refNodes.length; i1 < len3; i1++) {
+      let ref = refNodes[i1];
+      if (ref.type !== "Ref")
+        continue;
+      let { base } = ref;
+      ref.type = "Identifier";
+      let n = 0, name = base;
+      for (; 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 = !1) {
-    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++) {
       let binding = ref1[i1], { ref } = binding;
       if (asThis) {
         let atBinding = binding.binding;
@@ -1334,7 +1360,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     }
   }
   function adjustBindingElements(elements) {
-    let names = elements.flatMap(($1) => $1.names || []), { length } = elements, blockPrefix, restIndex = -1, restCount = 0;
+    let names = elements.flatMap(($2) => $2.names || []), { length } = elements, blockPrefix, restIndex = -1, restCount = 0;
     for (let i2 = 0, len1 = elements.length; i2 < len1; i2++) {
       let i = i2, { type } = elements[i2];
       type === "BindingRestElement" && (restIndex < 0 && (restIndex = i), restCount++);
@@ -1382,21 +1408,40 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
       length
     };
   }
+  function gatherSubbindings(node, subbindings = []) {
+    for (let ref2 = gatherRecursiveAll(node, ($) => $.subbinding != null), i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
+      let p = ref2[i3], { subbinding } = p;
+      subbindings.push(", ", subbinding), gatherSubbindings(subbinding, subbindings);
+    }
+    return subbindings;
+  }
+  function simplifyBindingProperties(node) {
+    let results = [];
+    for (let ref3 = gatherRecursiveAll(node, ($3) => $3.type === "BindingProperty"), i4 = 0, len3 = ref3.length; i4 < len3; i4++) {
+      let p = ref3[i4], { name, value } = p;
+      if (value?.type === "NamedBindingPattern" && value.binding === name) {
+        let [ws] = p.children;
+        results.push(p.children = [ws, name, p.delim]);
+      } else
+        results.push(void 0);
+    }
+    return results;
+  }
   function gatherBindingCode(statements, opts) {
     let thisAssignments = [], 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") {
           let { ref } = n, { id } = ref;
           thisAssignments2.push([`this.${id} = `, ref]);
           continue;
         }
-        if (opts?.assignPins && (n.type === "PinProperty" && (n.children = n.children.flatMap(($2) => $2 === n.name ? [n.name, ": ", n.value] : $2), updateParentPointers(n), n = n.value), n.type === "PinPattern")) {
+        if (opts?.assignPins && (n.type === "PinProperty" && (n.children = n.children.flatMap(($4) => $4 === n.name ? [n.name, ": ", n.value] : $4), updateParentPointers(n), n = n.value), n.type === "PinPattern")) {
           n.ref = makeRef(
             n.expression.type === "Identifier" ? n.expression.name : "pin"
           ), n.children = [n.ref], updateParentPointers(n), thisAssignments2.push({
@@ -1410,8 +1455,8 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
           continue;
         }
         if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-          for (let ref3 = n.names, i4 = 0, len3 = ref3.length; i4 < len3; i4++) {
-            let id = ref3[i4];
+          for (let ref5 = n.names, i6 = 0, len5 = ref5.length; i6 < len5; i6++) {
+            let id = ref5[i6];
             thisAssignments2.push({
               type: "AssignmentExpression",
               children: [`this.${id} = `, id],
@@ -1427,7 +1472,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     return insertRestSplices(statements, splices, thisAssignments), [splices, thisAssignments];
   }
   function arrayElementHasTrailingComma(elementNode) {
-    let ref4, lastChild = (ref4 = elementNode.children)[ref4.length - 1];
+    let ref6, lastChild = (ref6 = elementNode.children)[ref6.length - 1];
     return lastChild && lastChild[lastChild.length - 1]?.token === ",";
   }
   function gatherBindingPatternTypeSuffix(pattern) {
@@ -1437,14 +1482,14 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     switch (pattern.type) {
       case "ArrayBindingPattern": {
         {
-          let results = [];
-          for (let ref5 = pattern.elements, i5 = 0, len4 = ref5.length; i5 < len4; i5++) {
-            let elem = ref5[i5], { typeSuffix } = elem;
+          let results1 = [];
+          for (let ref7 = pattern.elements, i7 = 0, len6 = ref7.length; i7 < len6; i7++) {
+            let elem = ref7[i7], { typeSuffix } = elem;
             typeSuffix ??= elem.binding?.typeSuffix, typeSuffix && count++;
             let typeElement = [typeSuffix?.t, elem.delim];
-            typeSuffix?.optional && (typeElement[0] = parenthesizeType(typeElement[0]), typeElement.unshift("undefined |")), elem.type === "BindingRestElement" ? (typeElement[0] ??= "unknown[]", typeElement.unshift(elem.dots)) : typeElement[0] ??= "unknown", results.push(typeElement);
+            typeSuffix?.optional && (typeElement[0] = parenthesizeType(typeElement[0]), typeElement.unshift("undefined |")), elem.type === "BindingRestElement" ? (typeElement[0] ??= "unknown[]", typeElement.unshift(elem.dots)) : typeElement[0] ??= "unknown", results1.push(typeElement);
           }
-          let types = results;
+          let types = results1;
           if (count) {
             let t = [": [", types, "]"];
             pattern.typeSuffix = {
@@ -1459,9 +1504,9 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
       }
       case "ObjectBindingPattern": {
         {
-          let restType, results1 = [];
-          for (let ref6 = pattern.properties, i6 = 0, len5 = ref6.length; i6 < len5; i6++) {
-            let prop = ref6[i6], { typeSuffix } = prop;
+          let restType, results2 = [];
+          for (let ref8 = pattern.properties, i8 = 0, len7 = ref8.length; i8 < len7; i8++) {
+            let prop = ref8[i8], { typeSuffix } = prop;
             switch (typeSuffix ??= prop.value?.typeSuffix, typeSuffix && count++, typeSuffix ??= {
               type: "TypeSuffix",
               ts: !0,
@@ -1469,12 +1514,12 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
             }, prop.type) {
               case "BindingProperty": {
                 let 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": {
                 let 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": {
@@ -1483,7 +1528,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
               }
             }
           }
-          let types = results1;
+          let types = results2;
           if (count) {
             let t = ["{", types, "}"];
             restType != null && t.push(" & ", parenthesizeType(trimFirstSpace(restType))), pattern.typeSuffix = {
@@ -2385,7 +2430,7 @@ ${js}`
     exp = exp;
     let outer = exp;
     exp.type === "LabelledStatement" && (exp = exp.statement);
-    let ref6;
+    let ref6, m1;
     switch (exp.type) {
       case "BreakStatement":
       case "ContinueStatement":
@@ -2450,6 +2495,8 @@ ${js}`
         return;
       }
       case "PipelineExpression": {
+        if (m1 = exp.children[1]?.type, m1 === "ReturnStatement" || m1 === "ThrowStatement")
+          return;
         let 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)));
@@ -2470,8 +2517,8 @@ ${js}`
           let last = node.expressions[node.expressions.length - 1];
           insertReturn(last);
         } else {
-          let m1;
-          m1 = node.parent?.type, (m1 === "CatchClause" || m1 === "WhenClause") && node.expressions.push(["", wrapWithReturn(void 0, node)]);
+          let m2;
+          m2 = node.parent?.type, (m2 === "CatchClause" || m2 === "WhenClause") && node.expressions.push(["", wrapWithReturn(void 0, node)]);
         }
         return;
       }
@@ -2502,7 +2549,7 @@ ${js}`
       return;
     let outer = exp;
     exp.type === "LabelledStatement" && (exp = exp.statement);
-    let ref11;
+    let ref11, m3;
     switch (exp.type) {
       case "BreakStatement":
       case "ContinueStatement":
@@ -2579,6 +2626,8 @@ ${js}`
         return;
       }
       case "PipelineExpression": {
+        if (m3 = exp.children[1]?.type, m3 === "ReturnStatement" || m3 === "ThrowStatement")
+          return;
         let 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)));
@@ -2597,8 +2646,8 @@ ${js}`
     ))
       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 {
           let { ancestor } = findAncestor(
@@ -2749,8 +2798,8 @@ ${js}`
       return !1;
     let reduction = statement.type === "ForStatement" && statement.reduction;
     function fillBlock(expression) {
-      let ref15, m3;
-      return 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 === !0 && block.expressions.pop(), block.expressions.push(expression), block.empty = !1, braceBlock(block);
+      let ref15, m5;
+      return 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 === !0 && block.expressions.pop(), block.expressions.push(expression), block.empty = !1, braceBlock(block);
     }
     if (reduction)
       switch (reduction.subtype) {
@@ -2828,7 +2877,8 @@ ${js}`
     if (parameters.names = before.flatMap(($7) => $7.names), parameters.parameters.splice(0, 1 / 0), tt && parameters.parameters.push(tt), parameters.parameters.push(...before), rest) {
       let restIdentifier = rest.binding.ref || rest.binding;
       if (parameters.names.push(...rest.names || []), rest.children.pop(), after.length) {
-        (rest.binding.type === "ArrayBindingPattern" || rest.binding.type === "ObjectBindingPattern") && parameters.parameters.push({
+        let m6;
+        m6 = rest.binding.type, (m6 === "ArrayBindingPattern" || m6 === "ObjectBindingPattern" || m6 === "NamedBindingPattern") && parameters.parameters.push({
           type: "Error",
           message: "Non-end rest parameter cannot be binding pattern"
         }), after = trimFirstSpace(after);
@@ -2924,14 +2974,14 @@ ${js}`
     let [splices, thisAssignments] = gatherBindingCode(parameters, {
       injectParamProps: isConstructor,
       assignPins: !0
-    });
-    if (isConstructor) {
+    }), subbindings = gatherSubbindings(parameters.parameters);
+    if (simplifyBindingProperties(parameters.parameters), simplifyBindingProperties(subbindings), isConstructor) {
       let { ancestor } = findAncestor(f, ($10) => $10.type === "ClassExpression");
       if (ancestor != null) {
         let fields = new Set(gatherRecursiveWithinFunction(ancestor, ($11) => $11.type === "FieldDefinition").map(($12) => $12.id).filter((a3) => typeof a3 == "object" && a3 != null && "type" in a3 && a3.type === "Identifier").map(($13) => $13.name)), classExpressions = ancestor.body.expressions, index2 = findChildIndex(classExpressions, f);
         assert.notEqual(index2, -1, "Could not find constructor in class");
-        let m4;
-        for (; m4 = classExpressions[index2 - 1]?.[1], typeof m4 == "object" && m4 != null && "type" in m4 && m4.type === "MethodDefinition" && "name" in m4 && m4.name === "constructor"; )
+        let m7;
+        for (; m7 = classExpressions[index2 - 1]?.[1], typeof m7 == "object" && m7 != null && "type" in m7 && m7.type === "MethodDefinition" && "name" in m7 && m7.name === "constructor"; )
           index2--;
         let fStatement = classExpressions[index2];
         for (let ref18 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
@@ -2957,6 +3007,13 @@ ${js}`
       type: "SemicolonDelimiter",
       children: [";"]
     }, prefix = [];
+    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++) {
       let binding = ref20[i11];
       assert.equal(binding.type, "PostRestBindingElements", "splice should be of type Binding"), prefix.push(makeNode({
@@ -2996,7 +3053,7 @@ ${js}`
       if (f.async != null)
         f.async.push("async "), signature.modifier.async = !0;
       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++) {
           let a = ref21[i12], i = findChildIndex(a.parent, a);
           a.parent.children.splice(i + 1, 0, {
             type: "Error",
@@ -3007,8 +3064,8 @@ ${js}`
       if (f.generator != null)
         f.generator.push("*"), signature.modifier.generator = !0;
       else
-        for (let ref22 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "YieldExpression"), i13 = 0, len12 = ref22.length; i13 < len12; i13++) {
-          let y = ref22[i13], i = y.children.findIndex(($18) => $18.type === "Yield");
+        for (let ref22 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i13 = 0, len12 = ref22.length; i13 < len12; i13++) {
+          let y = ref22[i13], 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}`
@@ -3017,7 +3074,7 @@ ${js}`
     signature.modifier.async && !signature.modifier.generator && signature.returnType && !isPromiseType(signature.returnType.t) && replaceNode(signature.returnType.t, wrapTypeInPromise(signature.returnType.t));
   }
   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++) {
       let f = ref23[i14];
       (f.type === "FunctionExpression" || f.type === "MethodDefinition") && implicitFunctionBlock(f), processSignature(f), processParams(f), processReturn(f, config2.implicitReturns);
     }
@@ -3064,7 +3121,7 @@ ${js}`
     done || (generator || (statements[statements.length - 1][1] = wrapWithReturn(statements[statements.length - 1][1])), children.splice(i, 1, wrapIIFE(statements, async, generator)), updateParentPointers(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++) {
       let s = ref25[i15];
       expressionizeIteration(s);
     }
@@ -3102,12 +3159,12 @@ ${js}`
       let newParameterList = results1, 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 {
@@ -3125,7 +3182,7 @@ ${js}`
   }
   function makeAmpersandFunction(rhs) {
     let { ref, typeSuffix, body } = rhs;
-    ref == null && (ref = makeRef("$"), inplacePrepend(ref, body)), startsWithPredicate(body, ($23) => $23.type === "ObjectExpression") && (body = makeLeftHandSideExpression(body));
+    ref == null && (ref = makeRef("$"), inplacePrepend(ref, body)), startsWithPredicate(body, ($24) => $24.type === "ObjectExpression") && (body = makeLeftHandSideExpression(body));
     let parameterList = [
       typeSuffix ? [ref, typeSuffix] : ref
     ], parameters = makeNode({
@@ -3642,14 +3699,12 @@ ${js}`
         break;
       }
       case "ConditionFragment": {
-        let { children } = pattern;
-        if (children.length) {
-          let [first, ...rest] = children, [ws, ...op] = first;
-          ws = [" "].concat(ws), first = [ws, ...op], children = [first, ...rest];
+        let { rhs } = pattern;
+        if (rhs.length) {
+          let [first, ...rest] = rhs, [ws, ...op] = first;
+          ws = [" "].concat(ws), first = [ws, ...op], rhs = [first, ...rest];
         }
-        conditions.push(
-          processBinaryOpExpression([ref, children])
-        );
+        conditions.push(processBinaryOpExpression([ref, rhs]));
         break;
       }
       case "RegularExpressionLiteral": {
@@ -3667,6 +3722,10 @@ ${js}`
         ]);
         break;
       }
+      case "NamedBindingPattern": {
+        getPatternConditions(pattern.pattern, ref, conditions);
+        break;
+      }
       case "Literal": {
         conditions.push([
           ref,
@@ -3693,37 +3752,38 @@ ${js}`
       case "Literal":
       case "RegularExpressionLiteral":
       case "PinPattern":
-      case "ConditionFragment":
         return;
+      case "ConditionFragment": {
+        if (!pattern.binding)
+          return;
+        break;
+      }
     }
-    let [splices, thisAssignments] = gatherBindingCode(pattern), patternBindings2 = nonMatcherBindings(pattern), results = [];
-    for (let ref2 = gatherRecursiveAll(patternBindings2, ($7) => $7.subbinding != null), i5 = 0, len4 = ref2.length; i5 < len4; i5++) {
-      let p = ref2[i5];
-      results.push(prepend(", ", p.subbinding));
-    }
-    let subbindings = results;
-    splices = splices.map((s) => [", ", nonMatcherBindings(s)]), thisAssignments = thisAssignments.map(($8) => ["", $8, ";"]);
-    let duplicateDeclarations = aggregateDuplicateBindings([patternBindings2, splices]);
-    return [
-      ["", {
+    let [splices, thisAssignments] = gatherBindingCode(pattern), patternBindings2 = nonMatcherBindings(pattern), subbindings = gatherSubbindings(patternBindings2);
+    simplifyBindingProperties(patternBindings2), simplifyBindingProperties(subbindings), splices = splices.flatMap((s) => [", ", nonMatcherBindings(s)]), thisAssignments = thisAssignments.map(($7) => ["", $7, ";"]);
+    let duplicateDeclarations = aggregateDuplicateBindings([patternBindings2, splices, subbindings]), blockPrefix = [];
+    if (ref || subbindings.length || splices.length) {
+      let children = [decl];
+      ref && children.push(patternBindings2, typeSuffix, " = ", ref), children.push(...subbindings), children.push(...splices), 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, ";"])
-    ];
+      }, ";"]);
+    }
+    if (blockPrefix.push(...thisAssignments), blockPrefix.push(...duplicateDeclarations.map(($8) => ["", $8, ";"])), !!blockPrefix.length)
+      return blockPrefix;
   }
   function elideMatchersFromArrayBindings(elements) {
-    let results1 = [];
-    for (let i6 = 0, len5 = elements.length; i6 < len5; i6++) {
-      let element = elements[i6];
+    let results = [];
+    for (let i5 = 0, len4 = elements.length; i5 < len4; i5++) {
+      let element = elements[i5];
       switch (element.type) {
         case "BindingRestElement":
         case "ElisionElement": {
-          results1.push(element);
+          results.push(element);
           break;
         }
         case "BindingElement": {
@@ -3732,12 +3792,12 @@ ${js}`
             case "RegularExpressionLiteral":
             case "StringLiteral":
             case "PinPattern": {
-              results1.push(element.delim);
+              results.push(element.delim);
               break;
             }
             default: {
               let binding = nonMatcherBindings(element.binding);
-              results1.push(makeNode({
+              results.push(makeNode({
                 ...element,
                 binding,
                 children: element.children.map((c) => c === element.binding ? binding : c)
@@ -3748,26 +3808,20 @@ ${js}`
         }
       }
     }
-    return results1;
+    return results;
   }
   function elideMatchersFromPropertyBindings(properties) {
-    let results2 = [];
-    for (let i7 = 0, len6 = properties.length; i7 < len6; i7++) {
-      let p = properties[i7];
+    let results1 = [];
+    for (let i6 = 0, len5 = properties.length; i6 < len5; i6++) {
+      let p = properties[i6];
       switch (p.type) {
         case "BindingProperty":
         case "PinProperty": {
-          let { children, name, value, bind } = p, [ws] = children;
+          let { children, name, value } = p, [ws] = children;
           if (name.type === "NumericLiteral" && !value?.name || name.type === "ComputedPropertyName" && value?.subtype === "NumericLiteral")
-            if (bind)
-              results2.push({
-                type: "Error",
-                message: `Cannot bind ${name.type}`
-              });
-            else
-              continue;
-          else {
-            let contents;
+            continue;
+          {
+            let contents, m1;
             switch (value?.type) {
               case "ArrayBindingPattern":
               case "ObjectBindingPattern": {
@@ -3784,33 +3838,36 @@ ${js}`
                 contents = p;
                 break;
               }
+              case "NamedBindingPattern": {
+                let bindings = nonMatcherBindings(value.pattern);
+                contents = {
+                  ...p,
+                  subbinding: (m1 = bindings?.type, m1 === "ArrayBindingPattern" || m1 === "ObjectBindingPattern" || m1 === "Identifier" ? [
+                    bindings,
+                    " = ",
+                    name
+                  ] : void 0)
+                }, 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;
           }
           break;
         }
         default:
-          results2.push(p);
+          results1.push(p);
       }
     }
-    return results2;
+    return results1;
   }
   function nonMatcherBindings(pattern) {
+    let m2;
     switch (pattern.type) {
       case "ArrayBindingPattern":
       case "PostRestBindingElements": {
@@ -3818,7 +3875,7 @@ ${js}`
         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": {
@@ -3826,9 +3883,18 @@ ${js}`
         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": {
+        let 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;
     }
@@ -3841,9 +3907,9 @@ ${js}`
       //$.type is "BindingRestProperty"
       $.type === "Identifier" && $.parent?.type === "BindingElement" || $.type === "BindingRestElement"
     ), declarations = [], propsGroupedByName = /* @__PURE__ */ new Map();
-    for (let i8 = 0, len7 = props.length; i8 < len7; i8++) {
-      let p = props[i8], { name, value } = p, m1;
-      if (m1 = value?.type, m1 === "ArrayBindingPattern" || m1 === "ObjectBindingPattern")
+    for (let i7 = 0, len6 = props.length; i7 < len6; i7++) {
+      let p = props[i7], { name, value } = p, m3;
+      if (m3 = value?.type, m3 === "ArrayBindingPattern" || m3 === "ObjectBindingPattern")
         continue;
       let key = value?.name || name?.name || name;
       key?.type === "NumericLiteral" || key?.type === "ComputedPropertyName" || (propsGroupedByName.has(key) ? propsGroupedByName.get(key).push(p) : propsGroupedByName.set(key, [p]));
@@ -3856,8 +3922,8 @@ ${js}`
         pos: 0,
         input: key
       })) {
-        for (let i9 = 0, len8 = shared.length; i9 < len8; i9++) {
-          let p = shared[i9];
+        for (let i8 = 0, len7 = shared.length; i8 < len7; i8++) {
+          let p = shared[i8];
           aliasBinding(p, makeRef(`_${key}`, key));
         }
         return;
@@ -3938,9 +4004,13 @@ ${js}`
   function processDeclarations(statements) {
     for (let ref1 = gatherRecursiveAll(statements, ($) => $.type === "Declaration"), i1 = 0, len1 = ref1.length; i1 < len1; i1++) {
       let declaration = ref1[i1], { bindings } = declaration;
-      if (bindings != null)
-        for (let i2 = 0, len22 = bindings.length; i2 < len22; i2++) {
-          let binding = bindings[i2], { typeSuffix, initializer } = binding;
+      if (bindings != null) {
+        for (let i2 = bindings.length + -1; i2 >= 0; --i2) {
+          let binding = bindings[i2], subbindings = gatherSubbindings(binding);
+          subbindings.length && (simplifyBindingProperties(binding), simplifyBindingProperties(subbindings), spliceChild(declaration, binding, 1, binding, subbindings));
+        }
+        for (let i3 = 0, len22 = bindings.length; i3 < len22; i3++) {
+          let binding = bindings[i3], { typeSuffix, initializer } = binding;
           if (typeSuffix && typeSuffix.optional) {
             if (initializer && !typeSuffix.t) {
               let expression = trimFirstSpace(initializer.expression), m;
@@ -3968,6 +4038,19 @@ ${js}`
           }
           initializer && prependStatementExpressionBlock(initializer, declaration);
         }
+      }
+    }
+    for (let ref2 = gatherRecursiveAll(statements, ($1) => $1.type === "ForStatement"), i4 = 0, len3 = ref2.length; i4 < len3; i4++) {
+      let statement = ref2[i4], { declaration } = statement;
+      if (declaration?.type !== "ForDeclaration")
+        continue;
+      let { binding } = declaration, blockPrefix = getPatternBlockPrefix(
+        binding.pattern,
+        void 0,
+        append(declaration.decl, " "),
+        binding.typeSuffix
+      );
+      simplifyBindingProperties(binding), blockPrefix != null && (statement.block.expressions.unshift(...blockPrefix), braceBlock(statement.block));
     }
   }
   function prependStatementExpressionBlock(initializer, statement) {
@@ -4068,7 +4151,7 @@ ${js}`
       return;
     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]) {
-      let { type: type1, children: [[], { type: type2, expression: expression2 }] } = expression, type = [type1, type2];
+      let { children: [[], { expression: expression2 }] } = expression;
       expression = expression2;
     }
     processDeclarationCondition(expression, condition.expression, s);
@@ -4090,8 +4173,8 @@ ${js}`
           ({ children } = condition.expression.children[1]);
         }
         children.unshift("(");
-        for (let i3 = 0, len3 = conditions.length; i3 < len3; i3++) {
-          let c = conditions[i3];
+        for (let i5 = 0, len4 = conditions.length; i5 < len4; i5++) {
+          let c = conditions[i5];
           children.push(" && ", c);
         }
         children.push(")");
@@ -4109,11 +4192,11 @@ ${js}`
       if (index < 0)
         throw new Error("Couldn't find where in block to put postfix declaration");
       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) {
-            let elseBlock = ref2;
+          if (ref3 = s.else?.block) {
+            let elseBlock = ref3;
             elseBlock.bare && !elseBlock.semicolon && elseBlock.children.push(elseBlock.semicolon = ";"), ancestor.expressions.splice(index + 1 + blockPrefix.length, 0, ["", elseBlock]), s.children = s.children.filter((a1) => a1 !== s.else), s.else = void 0;
           }
           let block = s.then;
@@ -4129,11 +4212,11 @@ ${js}`
         if (s.negated) {
           if (e != null) {
             let block = blockWithPrefix(blockPrefix, e.block);
-            e.children = e.children.map(($1) => $1 === e.block ? block : $1), e.block = block, updateParentPointers(e);
+            e.children = e.children.map(($2) => $2 === e.block ? block : $2), e.block = block, updateParentPointers(e);
           }
         } else {
           let block = blockWithPrefix(blockPrefix, s.then);
-          s.children = s.children.map(($2) => $2 === s.then ? block : $2), s.then = block, updateParentPointers(s);
+          s.children = s.children.map(($3) => $3 === s.then ? block : $3), s.then = block, updateParentPointers(s);
         }
         break;
       }
@@ -4141,7 +4224,7 @@ ${js}`
         if (!blockPrefix)
           return;
         let { children, block } = s, newBlock = blockWithPrefix(blockPrefix, block);
-        s.children = children.map(($3) => $3 === block ? newBlock : $3), updateParentPointers(s);
+        s.children = children.map(($4) => $4 === block ? newBlock : $4), updateParentPointers(s);
         break;
       }
       case "SwitchStatement": {
@@ -4158,7 +4241,7 @@ ${js}`
           return c === s.condition ? newCondition : c;
         }), s.condition = newCondition, updateParentPointers(s), statementDeclaration) {
           let block = makeEmptyBlock();
-          replaceBlockExpression(s.parent, s, block), block.expressions.push(["", s]), s.children.splice(s.children.findIndex(($4) => $4.token === "switch"), 0, blockPrefix), s.parent = block;
+          replaceBlockExpression(s.parent, s, block), block.expressions.push(["", s]), s.children.splice(s.children.findIndex(($5) => $5.token === "switch"), 0, blockPrefix), s.parent = block;
         } else {
           let block = blockWithPrefix([["", [{
             type: "Declaration",
@@ -4172,17 +4255,17 @@ ${js}`
   }
   function dynamizeFromClause(from) {
     from = from.slice(1), from = trimFirstSpace(from);
-    let ref3;
-    if (ref3 = from[from.length - 1]?.assertion) {
-      let assert4 = ref3, ref4;
-      ref4 = from[from.length - 1], ref4.children = ref4.children.filter((a2) => a2 !== assert4), from.push(", {", assert4.keyword, ":", assert4.object, "}");
+    let ref4;
+    if (ref4 = from[from.length - 1]?.assertion) {
+      let assert2 = ref4, ref5;
+      ref5 = from[from.length - 1], ref5.children = ref5.children.filter((a2) => a2 !== assert2), from.push(", {", assert2.keyword, ":", assert2.object, "}");
     }
     return ["(", ...from, ")"];
   }
   function dynamizeImportDeclaration(decl) {
-    let { imports } = decl, { star, binding, specifiers } = imports, justDefault = binding && !specifiers && !star, ref5;
-    binding ? specifiers ? ref5 = makeRef() : ref5 = binding : ref5 = convertNamedImportsToObject(imports, !0);
-    let pattern = ref5, c = "const", expression = [
+    let { imports } = decl, { star, binding, specifiers } = imports, justDefault = binding && !specifiers && !star, ref6;
+    binding ? specifiers ? ref6 = makeRef() : ref6 = binding : ref6 = convertNamedImportsToObject(imports, !0);
+    let pattern = ref6, c = "const", expression = [
       justDefault ? "(" : void 0,
       { type: "Await", children: ["await"] },
       " ",
@@ -4362,7 +4445,7 @@ ${js}`
         children: args.children.map(
           (arg) => {
             if (typeof arg == "object" && arg != null && "type" in arg && arg.type === "ArrayElement" && "expression" in arg && "children" in arg) {
-              let { type, expression: exp, children } = arg, expression = processUnaryExpression([last], trimFirstSpace(exp));
+              let { expression: exp, children } = arg, expression = processUnaryExpression([last], trimFirstSpace(exp));
               return expression = prepend(getTrimmingSpace(exp), expression), {
                 ...arg,
                 expression,
@@ -4430,9 +4513,8 @@ ${js}`
     if (lhs.type === "NewExpression") {
       let { expression } = lhs;
       return expression = {
-        ...expression,
         type: "CallExpression",
-        children: [...expression.children, call]
+        children: [expression, call]
       }, {
         ...lhs,
         expression,
@@ -4478,13 +4560,13 @@ ${js}`
     ];
   }
   function processPipelineExpressions(statements) {
-    gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
-      let [ws, , body] = s.children, [, arg] = s.children, i = 0, l = body.length, children = [ws], comma = blockContainingStatement(s) ? ";" : ",", usingRef = null;
-      for (let i1 = 0, len3 = body.length; i1 < len3; i1++) {
-        let i2 = i1, step = body[i1], [leadingComment, pipe, trailingComment, expr] = step, returns = pipe.token === "||>", ref, result, returning = returns ? arg : null;
+    for (let ref1 = gatherRecursiveAll(statements, ($1) => $1.type === "PipelineExpression"), i1 = 0, len3 = ref1.length; i1 < len3; i1++) {
+      let s = ref1[i1], [ws, , body] = s.children, [, arg] = s.children, children = [ws], comma = blockContainingStatement(s) ? ";" : ",", usingRef = null;
+      for (let i2 = 0, len1 = body.length; i2 < len1; i2++) {
+        let i = i2, step = body[i2], [leadingComment, pipe, trailingComment, expr] = step, returns = pipe.token === "||>", ref, result, returning = returns ? arg : null;
         if (pipe.token === "|>=") {
           let initRef;
-          if (i2 === 0) {
+          if (i === 0) {
             switch (checkValidLHS(arg), arg.type) {
               case "MemberExpression":
                 if (arg.children.length <= 2)
@@ -4522,7 +4604,7 @@ ${js}`
               message: "Can't use |>= in the middle of a pipeline"
             });
         } else
-          i2 === 0 && (s.children = children);
+          i === 0 && (s.children = children);
         if (returns && (ref = needsRef(arg)) && (usingRef = usingRef || ref, arg = {
           type: "ParenthesizedExpression",
           children: ["(", {
@@ -4538,7 +4620,7 @@ ${js}`
           arg,
           returning
         ), result.type === "ReturnStatement") {
-          i2 < l - 1 && result.children.push({
+          i < body.length - 1 && result.children.push({
             type: "Error",
             message: "Can't continue a pipeline after returning"
           }), arg = result, children[children.length - 1] === "," && (children.pop(), children.push(";"));
@@ -4550,22 +4632,22 @@ ${js}`
         type: "Declaration",
         children: ["let ", usingRef],
         names: []
-      }), children.push(arg), !children.some(($1) => $1?.type === "ReturnStatement") && children.some(($2) => $2 === ",")) {
+      }), children.push(arg), !children.some(($2) => $2?.type === "ReturnStatement") && children.some(($3) => $3 === ",")) {
         let { parent } = s, parenthesizedExpression = makeLeftHandSideExpression({ ...s });
         Object.assign(s, parenthesizedExpression, {
           parent,
           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]];
-    let ws2 = range.children[1], comma = { $loc: range.$loc, token: "," }, ref;
-    switch (range.increasing) {
+  function processRangeExpression(start, ws1, range2, end) {
+    ws1 = [ws1, range2.children[0]];
+    let ws2 = range2.children[1], comma = { $loc: range2.$loc, token: "," }, ref;
+    switch (range2.increasing) {
       case !0: {
         ref = ($) => $;
         break;
@@ -4577,14 +4659,14 @@ ${js}`
       default:
         ref = Math.abs;
     }
-    let abs = ref, lengthAdjust = 1 - +!range.left.inclusive - +!range.right.inclusive, children;
+    let abs = ref, lengthAdjust = 1 - +!range2.left.inclusive - +!range2.right.inclusive, 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), endValue = literalValue(end);
       if (typeof startValue == "string" && typeof endValue == "string") {
         if (!(startValue.length === 1 && endValue.length === 1))
           throw new Error("String range start and end must be a single character");
         let startCode = startValue.charCodeAt(0), endCode = endValue.charCodeAt(0), step = startCode <= endCode ? 1 : -1, length = abs(endCode - startCode) + lengthAdjust;
-        range.left.inclusive || (startCode += step), length <= 26 ? children = [
+        range2.left.inclusive || (startCode += step), length <= 26 ? children = [
           "[",
           Array.from({ length }, (_2, i) => JSON.stringify(String.fromCharCode(startCode + i * step))).join(", "),
           "]"
@@ -4595,25 +4677,25 @@ ${js}`
           ", ",
           length.toString(),
           ")"
-        ], range.error != null && children.unshift(range.error);
+        ], range2.error != null && children.unshift(range2.error);
       } else if (typeof startValue == "number" && typeof endValue == "number") {
         let step = startValue <= endValue ? 1 : -1, length = abs(endValue - startValue) + lengthAdjust;
-        range.left.inclusive || (startValue += step), length <= 20 && (children = [
+        range2.left.inclusive || (startValue += step), length <= 20 && (children = [
           "[",
           Array.from({ length }, (_2, i) => startValue + i * step).join(", "),
           "]"
-        ], range.error != null && children.unshift(range.error));
+        ], range2.error != null && children.unshift(range2.error));
       }
     }
     if (children == null)
-      if (range.increasing != null) {
-        let sign = range.increasing ? "+" : "-";
+      if (range2.increasing != null) {
+        let 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,
           ")"
         ];
@@ -4622,11 +4704,11 @@ ${js}`
           "((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,
@@ -4641,14 +4723,14 @@ ${js}`
       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, counterRef = makeRef("i"), infinite = typeof end == "object" && end != null && "type" in end && end.type === "Identifier" && "name" in end && end.name === "Infinity", stepRef, asc;
+  function forRange(open, forDeclaration, range2, stepExp, close) {
+    let { start, end, left, right, increasing } = range2, counterRef = makeRef("i"), infinite = typeof end == "object" && end != null && "type" in end && end.type === "Identifier" && "name" in end && end.name === "Infinity", stepRef, asc;
     stepExp ? (stepExp = trimFirstSpace(stepExp), stepRef = maybeRef(stepExp, "step")) : infinite ? stepExp = stepRef = makeNumericLiteral(1) : increasing != null && (increasing ? (stepExp = stepRef = makeNumericLiteral(1), asc = !0) : (stepExp = stepRef = makeNumericLiteral(-1), asc = !1));
     let ref1;
     if (stepExp?.type === "Literal")
@@ -4704,7 +4786,7 @@ ${js}`
       // 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
     };
   }
@@ -4749,6 +4831,7 @@ ${js}`
         return declaration = {
           type: "Declaration",
           children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", trimFirstSpace(expRef2), ".length"],
+          decl: "let",
           names: []
         }, { declaration, eachDeclaration, children: [open, declaration, "; ", [counterRef, " < ", lenRef, "; "], counterRef, increment, close], blockPrefix };
       } else
@@ -4762,7 +4845,7 @@ ${js}`
       message: "'own' is only meaningful in for..in loops"
     });
     let { binding } = declaration, pattern = binding?.pattern;
-    if (binding?.typeSuffix || inOf.token === "in" && declaration2 && pattern.type !== "Identifier") {
+    if (pattern?.type === "NamedBindingPattern" && (pattern = pattern.binding), binding?.typeSuffix || inOf.token === "in" && declaration2 && pattern.type !== "Identifier") {
       let itemRef = makeRef(inOf.token === "in" ? "key" : "item");
       blockPrefix.push(["", {
         type: "Declaration",
@@ -4794,11 +4877,13 @@ ${js}`
         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;
       }
@@ -4807,7 +4892,8 @@ ${js}`
         if (expRef2 !== exp && (hoistDec = {
           type: "Declaration",
           children: ["let ", expRef2],
-          names: []
+          names: [],
+          decl: "let"
         }, exp = {
           type: "AssignmentExpression",
           children: [" ", expRef2, " =", exp]
@@ -4815,20 +4901,57 @@ ${js}`
           let hasPropRef = getHelperRef("hasProp");
           blockPrefix.push(["", ["if (!", hasPropRef, "(", trimFirstSpace(expRef2), ", ", trimFirstSpace(pattern), ")) continue"], ";"]);
         }
-        decl2 && blockPrefix.push(["", {
-          type: "Declaration",
-          children: [
-            trimFirstSpace(ws2),
-            decl2,
-            " = ",
-            trimFirstSpace(expRef2),
-            "[",
-            trimFirstSpace(pattern),
-            "]"
-          ],
-          decl: decl2,
-          names: decl2.names
-        }, ";"]);
+        if (decl2) {
+          let trimmedPattern = trimFirstSpace(pattern), expression = makeNode({
+            type: "MemberExpression",
+            children: [
+              trimFirstSpace(expRef2),
+              makeNode({
+                type: "Index",
+                expression: trimmedPattern,
+                children: ["[", trimmedPattern, "]"]
+              })
+            ]
+          });
+          blockPrefix.push([
+            "",
+            (() => {
+              if (decl2.type === "ForDeclaration") {
+                let { binding: binding2, children } = decl2;
+                return binding2.children.push(binding2.initializer = makeNode({
+                  type: "Initializer",
+                  expression,
+                  children: [" = ", expression]
+                })), 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;
       }
       default:
@@ -5168,7 +5291,7 @@ ${js}`
       }, defaultClause = !1, clauses = cs.map((clause) => {
         let ref1;
         if ((ref1 = clause.binding?.parameter) && typeof ref1 == "object" && "type" in ref1 && ref1.type === "CatchPattern" && "patterns" in ref1) {
-          let { type, patterns } = ref1;
+          let { patterns } = ref1;
           return {
             type: "PatternClause",
             patterns,
@@ -5333,15 +5456,24 @@ ${js}`
         let i = i2, arg = args[i2];
         isComma(arg) && (arg = args[i] = deepCopy(arg), isComma(arg).token = `)${op.token}(`, commaCount++);
       }
-      if (args.length && (children.splice(
-        0,
-        2,
-        commaCount ? {
-          type: "ParenthesizedExpression",
-          children: ["(", ...call.children, ")"]
-        } : { ...call, type: "ParenthesizedExpression" }
-      ), children.length === 1))
-        return children[0];
+      if (args.length) {
+        if (commaCount)
+          children.splice(0, 2, {
+            type: "ParenthesizedExpression",
+            children: ["(", call.children, ")"],
+            expression: call.children
+          });
+        else {
+          let middle = call.children.slice(1, -1), 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];
+      }
     }
     for (let i3 = 0, len22 = children.length; i3 < len22; i3++) {
       let i = i3, glob = children[i3];
@@ -5399,13 +5531,13 @@ ${js}`
             usesRef: !!ref
           });
         }
-        let ref2, object = {
+        let ref3, 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
@@ -5460,7 +5592,7 @@ ${js}`
               ]
             })
           ]
-        }), ref3;
+        }), ref4;
         return processCallMemberExpression({
           // in case there are more
           ...node,
@@ -5474,7 +5606,7 @@ ${js}`
                 glob.children[0],
                 // "[" token
                 call,
-                (ref3 = glob.children)[ref3.length - 1]
+                (ref4 = glob.children)[ref4.length - 1]
                 // "]" token
               ]
             }),
@@ -5486,7 +5618,7 @@ ${js}`
           { ...node, children: node.children.slice(0, i) },
           { ...glob.children[0], token: ", " },
           ...glob.children.slice(1, -1)
-        ], ref4, rsliceCall = makeNode({
+        ], ref5, rsliceCall = makeNode({
           type: "CallExpression",
           implicit: !0,
           children: [
@@ -5497,7 +5629,7 @@ ${js}`
               children: [
                 "(",
                 args,
-                (ref4 = glob.children)[ref4.length - 1]
+                (ref5 = glob.children)[ref5.length - 1]
               ]
             })
           ]
@@ -5554,7 +5686,7 @@ ${js}`
       if (specifier.ts)
         return { type: "Error", message: "cannot use `type` in dynamic import" };
       {
-        let { source, binding } = specifier, ref5, delim = (ref5 = specifier.children)[ref5.length - 1];
+        let { source, binding } = specifier, ref6, delim = (ref6 = specifier.children)[ref6.length - 1];
         return {
           type: pattern ? "BindingProperty" : "Property",
           name: source,
@@ -5563,7 +5695,7 @@ ${js}`
           children: source === binding ? [source, delim] : [source, ":", binding, delim]
         };
       }
-    }), ref6;
+    }), ref7;
     return {
       type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
       names: node.names,
@@ -5572,7 +5704,7 @@ ${js}`
         node.children[0],
         // {
         properties,
-        (ref6 = node.children)[ref6.length - 1]
+        (ref7 = node.children)[ref7.length - 1]
         // }
       ]
     };
@@ -5648,11 +5780,15 @@ ${js}`
   }
   function processBindingPatternLHS(lhs, tail) {
     adjustAtBindings(lhs, !0);
-    let [splices, thisAssignments] = gatherBindingCode(lhs);
-    tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
+    let [splices, thisAssignments] = gatherBindingCode(lhs), 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;
         for (; expr.type === "ParenthesizedExpression"; )
@@ -5660,25 +5796,25 @@ ${js}`
         let m1;
         if (m1 = expr.type, m1 === "AssignmentExpression" || m1 === "UpdateExpression")
           return expr.type === "UpdateExpression" && expr.children[0] === expr.assigned ? (pre.push("("), post.push([", ", lhs, ")"])) : (pre.push(["(", lhs, ", "]), post.push(")")), expr.assigned;
-      }, exp = ref7[i5];
+      }, exp = ref8[i5];
       checkValidLHS(exp.assigned);
-      let pre = [], post = [], ref8;
+      let pre = [], post = [], ref9;
       switch (exp.type) {
         case "AssignmentExpression": {
           if (!exp.lhs)
             continue;
-          for (let ref9 = exp.lhs, i6 = 0, len4 = ref9.length; i6 < len4; i6++) {
-            let lhsPart = ref9[i6], ref10;
-            if (ref10 = extractAssignment(lhsPart[1])) {
-              let newLhs = ref10;
+          for (let ref10 = exp.lhs, i6 = 0, len4 = ref10.length; i6 < len4; i6++) {
+            let lhsPart = ref10[i6], ref11;
+            if (ref11 = extractAssignment(lhsPart[1])) {
+              let newLhs = ref11;
               lhsPart[1] = newLhs;
             }
           }
           break;
         }
         case "UpdateExpression": {
-          if (ref8 = extractAssignment(exp.assigned)) {
-            let newLhs = ref8, i = exp.children.indexOf(exp.assigned);
+          if (ref9 = extractAssignment(exp.assigned)) {
+            let newLhs = ref9, i = exp.children.indexOf(exp.assigned);
             exp.assigned = exp.children[i] = newLhs;
           }
           break;
@@ -5693,19 +5829,19 @@ ${js}`
         }), replaceNode(exp, newMemberExp));
       }
     }
-    for (let ref11 = gatherRecursiveAll(statements, ($6) => $6.type === "AssignmentExpression"), i7 = 0, len5 = ref11.length; i7 < len5; i7++) {
-      let exp = ref11[i7];
+    for (let ref12 = gatherRecursiveAll(statements, ($6) => $6.type === "AssignmentExpression"), i7 = 0, len5 = ref12.length; i7 < len5; i7++) {
+      let exp = ref12[i7];
       if (exp.names !== null)
         continue;
-      let { lhs: $1, expression: $2 } = exp, tail = [], len3 = $1.length, block, ref12;
-      if (blockContainingStatement(exp) && !(ref12 = $1[$1.length - 1])?.[ref12.length - 1]?.special) {
+      let { lhs: $1, expression: $2 } = exp, tail = [], len3 = $1.length, block, 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
         )) {
-          let ref = ref13;
+          let ref = ref14;
           exp.children = exp.children.map(($7) => $7 === $2 ? ref : $7), $2 = ref;
         } else
           block = void 0;
@@ -5751,7 +5887,7 @@ ${js}`
               message: "Slice range cannot be decreasing in assignment"
             });
             break;
-          } else m3 = lhs.type, (m3 === "ObjectBindingPattern" || m3 === "ArrayBindingPattern") && (processBindingPatternLHS(lhs, tail), gatherRecursiveAll(lhs, ($9) => $9.type === "Ref").forEach(refsToDeclare.add.bind(refsToDeclare)));
+          } else m3 = lhs.type, (m3 === "ObjectBindingPattern" || m3 === "ArrayBindingPattern" || m3 === "NamedBindingPattern") && (processBindingPatternLHS(lhs, tail), gatherRecursiveAll(lhs, ($9) => $9.type === "Ref").forEach(refsToDeclare.add.bind(refsToDeclare)));
         }
         i--;
       }
@@ -5808,9 +5944,9 @@ ${js}`
       }
       j++;
     }
-    let ref14;
-    if (ref14 = conditions.length) {
-      let l = ref14, cs = flatJoin(conditions, " && ");
+    let ref15;
+    if (ref15 = conditions.length) {
+      let l = ref15, cs = flatJoin(conditions, " && ");
       return {
         ...exp,
         children: [...cs, " ? ", innerExp(children), " : void 0"],
@@ -5842,12 +5978,12 @@ ${js}`
   }
   function processTypes(node) {
     let results1 = [];
-    for (let ref15 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len6 = ref15.length; i8 < len6; i8++) {
-      let unary = ref15[i8], suffixIndex = unary.suffix.length - 1, results2 = [];
+    for (let ref16 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len6 = ref16.length; i8 < len6; i8++) {
+      let unary = ref16[i8], suffixIndex = unary.suffix.length - 1, results2 = [];
       for (; suffixIndex >= 0; ) {
         let suffix = unary.suffix[suffixIndex];
         if (typeof suffix == "object" && suffix != null && "token" in suffix && suffix.token === "?") {
-          let { token } = suffix, count = 0, m4;
+          let {} = suffix, count = 0, m4;
           for (; m4 = unary.suffix[suffixIndex], typeof m4 == "object" && m4 != null && "token" in m4 && m4.token === "?"; )
             unary.suffix.splice(suffixIndex--, 1), count++;
           let m5;
@@ -5894,7 +6030,7 @@ ${js}`
             children: [prefix, replace, outer]
           })), results2.push(replaceNode(unary, replace, parent));
         } else if (typeof suffix == "object" && suffix != null && "type" in suffix && suffix.type === "NonNullAssertion") {
-          let { type } = suffix, m6;
+          let {} = suffix, m6;
           for (; m6 = unary.suffix[suffixIndex], typeof m6 == "object" && m6 != null && "type" in m6 && m6.type === "NonNullAssertion"; )
             unary.suffix.splice(suffixIndex--, 1);
           let m7;
@@ -5904,9 +6040,9 @@ ${js}`
           unary.prefix = [], unary.children = unary.children.filter((a2) => a2 !== prefix);
           let outer = unary.suffix.splice(suffixIndex + 1, 1 / 0), space = getTrimmingSpace(unary);
           inplaceInsertTrimmingSpace(unary, "");
-          let ref16;
-          unary.suffix.length ? ref16 = unary : ref16 = unary.t;
-          let t = ref16, argArray = [makeNode({
+          let ref17;
+          unary.suffix.length ? ref17 = unary : ref17 = unary.t;
+          let t = ref17, argArray = [makeNode({
             type: "TypeArgument",
             ts: !0,
             t,
@@ -5942,16 +6078,16 @@ ${js}`
     return results1;
   }
   function processStatementExpressions(statements) {
-    for (let ref17 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len7 = ref17.length; i9 < len7; i9++) {
-      let exp = ref17[i9], { maybe, statement } = exp;
+    for (let ref18 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len7 = ref18.length; i9 < len7; i9++) {
+      let exp = ref18[i9], { maybe, statement } = exp;
       if ((maybe || statement.type === "ThrowStatement") && blockContainingStatement(exp)) {
         replaceNode(exp, statement);
         continue;
       }
-      let ref18;
+      let ref19;
       switch (statement.type) {
         case "IfStatement": {
-          (ref18 = expressionizeIfStatement(statement)) ? replaceNode(statement, ref18, exp) : replaceNode(statement, wrapIIFE([["", statement]]), exp);
+          (ref19 = expressionizeIfStatement(statement)) ? replaceNode(statement, ref19, exp) : replaceNode(statement, wrapIIFE([["", statement]]), exp);
           break;
         }
         case "IterationExpression": {
@@ -5992,11 +6128,11 @@ ${js}`
     });
   }
   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], 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], 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");
-      let { block, index } = ref20, indent = block.expressions[index][0], expressions = block.expressions.slice(index + 1), t = makeNode({
+      let { block, index } = ref21, indent = block.expressions[index][0], expressions = block.expressions.slice(index + 1), t = makeNode({
         type: "BlockStatement",
         expressions,
         children: ["{", expressions, "}"],
@@ -6056,8 +6192,8 @@ ${js}`
     }
   }
   function processCoffeeClasses(statements) {
-    for (let ref21 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref21.length; i11 < len9; i11++) {
-      let ce = ref21[i11], { expressions } = ce.body, indent = expressions[0]?.[0] ?? `
+    for (let ref22 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref22.length; i11 < len9; i11++) {
+      let ce = ref22[i11], { expressions } = ce.body, indent = expressions[0]?.[0] ?? `
 `, autoBinds = expressions.filter(($14) => $14[1]?.autoBind);
       if (autoBinds.length) {
         let construct;
@@ -6147,38 +6283,23 @@ ${js}`
   }
   function processRepl(root, rootIIFE) {
     let topBlock = gatherRecursive(rootIIFE, ($17) => $17.type === "BlockStatement")[0], i = 0;
-    for (let ref22 = gatherRecursiveWithinFunction(topBlock, ($18) => $18.type === "Declaration"), i14 = 0, len11 = ref22.length; i14 < len11; i14++) {
-      let decl = ref22[i14];
+    for (let ref23 = gatherRecursiveWithinFunction(topBlock, ($18) => $18.type === "Declaration"), i14 = 0, len11 = ref23.length; i14 < len11; i14++) {
+      let decl = ref23[i14];
       decl.names?.length && (decl.parent === topBlock || decl.decl === "var") && (decl.children.shift(), decl.bindings[0]?.pattern?.type === "ObjectBindingPattern" && (decl.children.unshift("("), decl.children.push(")")), 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++) {
-      let func = ref23[i15];
+    for (let ref24 = gatherRecursive(topBlock, ($19) => $19.type === "FunctionExpression"), i15 = 0, len12 = ref24.length; i15 < len12; i15++) {
+      let func = ref24[i15];
       func.name && func.parent?.type === "BlockStatement" && (func.parent === topBlock ? (replaceNode(func, void 0), root.expressions.splice(i++, 0, ["", func]), func.parent = root) : (func.children.unshift(func.name, "="), root.expressions.splice(i++, 0, ["", `var ${func.name}`, ";"])));
     }
-    for (let ref24 = gatherRecursiveWithinFunction(topBlock, ($20) => $20.type === "ClassExpression"), i16 = 0, len13 = ref24.length; i16 < len13; i16++) {
-      let classExp = ref24[i16], m8;
+    for (let ref25 = gatherRecursiveWithinFunction(topBlock, ($20) => $20.type === "ClassExpression"), i16 = 0, len13 = ref25.length; i16 < len13; i16++) {
+      let classExp = ref25[i16], m8;
       (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, "="), root.expressions.splice(i++, 0, ["", `var ${classExp.name}`, ";"]));
     }
   }
-  function populateRefs(statements) {
-    let refNodes = gatherRecursive(statements, ($21) => $21.type === "Ref");
-    if (refNodes.length) {
-      let ids = gatherRecursive(statements, (s) => s.type === "Identifier"), names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
-      refNodes.forEach((ref) => {
-        let { type, base } = ref;
-        if (type !== "Ref") return;
-        ref.type = "Identifier";
-        let n = 0, name = base;
-        for (; names.has(name); )
-          n++, name = `${base}${n}`;
-        return names.add(name), ref.children = ref.names = [name];
-      });
-    }
-  }
   function processPlaceholders(statements) {
     let placeholderMap = /* @__PURE__ */ new Map(), liftedIfs = /* @__PURE__ */ new Set();
-    for (let ref25 = gatherRecursiveAll(statements, ($22) => $22.type === "Placeholder"), i17 = 0, len14 = ref25.length; i17 < len14; i17++) {
-      let exp = ref25[i17], ancestor;
+    for (let ref26 = gatherRecursiveAll(statements, ($21) => $21.type === "Placeholder"), i17 = 0, len14 = ref26.length; i17 < len14; i17++) {
+      let exp = ref26[i17], ancestor;
       if (exp.subtype === ".") {
         ({ ancestor } = findAncestor(
           exp,
@@ -6250,8 +6371,8 @@ ${js}`
       for (let i18 = 0, len15 = placeholders.length; i18 < len15; i18++) {
         let placeholder = placeholders[i18];
         typeSuffix ??= placeholder.typeSuffix;
-        let ref26;
-        (ref26 = placeholder.children)[ref26.length - 1] = ref;
+        let ref27;
+        (ref27 = placeholder.children)[ref27.length - 1] = ref;
       }
       let { parent } = ancestor, body = maybeUnwrap(ancestor), fnExp = makeAmpersandFunction({ ref, typeSuffix, body }), outer;
       switch (parent?.type) {
@@ -6268,8 +6389,8 @@ ${js}`
           break;
         }
         case "PipelineExpression": {
-          let i = findChildIndex(parent, ancestor), ref27;
-          i === 1 ? ref27 = ancestor === parent.children[i] : i === 2 ? ref27 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3] : ref27 = void 0, outer = ref27;
+          let i = findChildIndex(parent, ancestor), ref28;
+          i === 1 ? ref28 = ancestor === parent.children[i] : i === 2 ? ref28 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3] : ref28 = void 0, outer = ref28;
           break;
         }
         case "AssignmentExpression":
@@ -6280,10 +6401,10 @@ ${js}`
           break;
         }
       }
-      outer || (fnExp = makeLeftHandSideExpression(fnExp)), replaceNode(ancestor, fnExp, parent);
-      let ref28;
-      if (ref28 = getTrimmingSpace(body)) {
-        let ws = ref28;
+      outer || (fnExp = makeLeftHandSideExpression(fnExp)), replaceNode(ancestor, fnExp, parent), 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 === !0 && "body" in parent.parent && parent.parent.body === body && (parent.parent.body = fnExp);
+      let ref29;
+      if (ref29 = getTrimmingSpace(body)) {
+        let ws = ref29;
         inplaceInsertTrimmingSpace(body, ""), inplacePrepend(ws, fnExp);
       }
     }
@@ -6314,8 +6435,8 @@ ${js}`
         }
       ];
     }
-    let ref29;
-    Array.isArray(rest.delim) && (ref29 = rest.delim)[ref29.length - 1]?.token === "," && (rest.delim = rest.delim.slice(0, -1), rest.children = [...rest.children.slice(0, -1), rest.delim]);
+    let ref30;
+    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]);
     let children = [...props, ...after, rest];
     return restCount > 1 && children.push({
       type: "Error",
@@ -6525,6 +6646,7 @@ ${js}`
     NWBindingIdentifier,
     AtIdentifierRef,
     PinPattern,
+    NamedBindingPattern,
     BindingPattern,
     ObjectBindingPattern,
     ObjectBindingPatternContent,
@@ -7899,20 +8021,22 @@ ${js}`
   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];
-  }), 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) {
+  }), 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" };
+  }), 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]
     };
-  }), PipelineTailItem$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(NWTypePostfix, (0, import_lib2.$Q)(TypePostfix)), function($skip, $loc, $0, $1, $2) {
+  }), 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]
     });
-  }), PipelineTailItem$3 = (0, import_lib2.$T)((0, import_lib2.$S)(PipelineHeadItem), function(value) {
+  }), PipelineTailItem$4 = (0, import_lib2.$T)((0, import_lib2.$S)(PipelineHeadItem), function(value) {
     return value[0];
-  }), PipelineTailItem$$ = [PipelineTailItem$0, PipelineTailItem$1, PipelineTailItem$2, PipelineTailItem$3];
+  }), 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$$);
   }
@@ -8370,7 +8494,7 @@ ${js}`
       children: $0,
       expression
     };
-  }), LeftHandSideExpression$1 = CallExpression, LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
+  }), LeftHandSideExpression$1 = NamedBindingPattern, LeftHandSideExpression$2 = CallExpression, LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1, LeftHandSideExpression$2];
   function LeftHandSideExpression(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "LeftHandSideExpression", LeftHandSideExpression$$);
   }
@@ -8827,7 +8951,7 @@ ${js}`
   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, binding = $4, typeSuffix = $5, initializer = $6, delim = $7;
     return typeSuffix ??= binding.typeSuffix, {
       type: "Parameter",
@@ -8920,7 +9044,22 @@ ${js}`
   function PinPattern(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "PinPattern", PinPattern$$);
   }
-  var BindingPattern$0 = ObjectBindingPattern, BindingPattern$1 = ArrayBindingPattern, BindingPattern$2 = PinPattern, BindingPattern$3 = Literal, BindingPattern$4 = RegularExpressionLiteral, BindingPattern$$ = [BindingPattern$0, BindingPattern$1, BindingPattern$2, BindingPattern$3, BindingPattern$4];
+  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, ws = $3, pattern = $4;
+    return pattern = prepend(ws, pattern), {
+      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, BindingPattern$1 = ArrayBindingPattern, BindingPattern$2 = PinPattern, BindingPattern$3 = Literal, BindingPattern$4 = RegularExpressionLiteral, BindingPattern$5 = NamedBindingPattern, 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$$);
   }
@@ -9016,8 +9155,21 @@ ${js}`
   function NestedBindingPropertyList(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "NestedBindingPropertyList", NestedBindingPropertyList$0);
   }
-  var BindingProperty$0 = BindingRestProperty, 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$0 = BindingRestProperty, 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, name = $2, bind = $3, ws2 = $4, colon = $5, ws3 = $6, value = $7, typeSuffix = $8, initializer = $9;
+    if (bind) {
+      let 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],
@@ -9026,8 +9178,7 @@ ${js}`
       value,
       typeSuffix,
       initializer,
-      names: value.names,
-      bind: !!bind
+      names: value.names
     };
   }), 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) {
     var ws = $1, pin = $2, binding = $3, typeSuffix = $4, initializer = $5;
@@ -9070,8 +9221,7 @@ ${js}`
       typeSuffix,
       initializer,
       names: binding.names,
-      identifier: binding,
-      bind: !!bind
+      identifier: binding
     };
   }), BindingProperty$$ = [BindingProperty$0, BindingProperty$1, BindingProperty$2, BindingProperty$3];
   function BindingProperty(ctx, state2) {
@@ -9117,7 +9267,7 @@ ${js}`
   function NestedBindingElements(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "NestedBindingElements", NestedBindingElements$0);
   }
-  var BindingElement$0 = BindingRestElement, 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$0 = BindingRestElement, 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, binding = $2, typeSuffix = $3, initializer = $4;
     return {
       type: "BindingElement",
@@ -9137,7 +9287,7 @@ ${js}`
   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, dots = $2, binding = $3, typeSuffix = $4;
     return {
       type: "BindingRestElement",
@@ -9149,7 +9299,7 @@ ${js}`
       names: binding.names,
       rest: !0
     };
-  }), 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) {
+  }), 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, binding = $2, dots = $3;
     return {
       type: "BindingRestElement",
@@ -9220,11 +9370,12 @@ ${js}`
       signature,
       ts: !0
     };
-  }), 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 open = $2, op = $3, close = $4;
+  }), 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, ws1 = $3, op = $4, ws2 = $5, close = $6;
     if (op.special && op.call && !op.negated) return op.call;
+    ws1 || (ws1 = op.spaced ? [" "] : []), ws2 || (ws2 = op.spaced ? [" "] : []);
     let refA = makeRef("a"), refB = makeRef("b"), body = processBinaryOpExpression([refA, [
-      [[], op, [], refB]
+      [ws1, op, ws2, refB]
       // BinaryOpRHS
     ]]), parameterList = [[refA, ","], refB], parameters = {
       type: "Parameters",
@@ -9247,6 +9398,7 @@ ${js}`
     };
   }), FunctionExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, NonPipelineAssignmentExpression, __, BinaryOp, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
     var open = $1, lhs = $2, ws1 = $3, op = $4, ws2 = $5, close = $6;
+    ws1 || (ws1 = op.spaced ? [" "] : []), ws2 || (ws2 = op.spaced ? [" "] : []);
     let refB = makeRef("b"), fn = makeAmpersandFunction({
       ref: refB,
       body: processBinaryOpExpression([lhs, [
@@ -9294,6 +9446,7 @@ ${js}`
     };
   }), FunctionExpression$5 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, __, (0, import_lib2.$N)((0, import_lib2.$EXPECT)($R15, "FunctionExpression /\\+\\+|--|\u29FA|\u2014|[\\+\\-&]\\S/")), (0, import_lib2.$N)((0, import_lib2.$S)(Placeholder, (0, import_lib2.$C)(TypePostfix, BinaryOpRHS))), BinaryOp, __, NonPipelineAssignmentExpression, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
     var open = $1, ws1 = $2, op = $5, ws2 = $6, rhs = $7, close = $8;
+    ws1 || (ws1 = op.spaced ? [" "] : []), ws2 || (ws2 = op.spaced ? [" "] : []);
     let refA = makeRef("a"), fn = makeAmpersandFunction({
       ref: refA,
       body: processBinaryOpExpression([refA, [
@@ -9312,10 +9465,7 @@ ${js}`
   }
   var OperatorDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Operator, (0, import_lib2.$E)(OperatorBehavior), _, LexicalDeclaration), function($skip, $loc, $0, $1, $2, $3, $4) {
     var op = $1, behavior = $2, w = $3, decl = $4;
-    return decl.names.forEach((name) => state.operators.set(name, behavior)), {
-      ...decl,
-      children: [trimFirstSpace(w), ...decl.children]
-    };
+    return decl.names.forEach((name) => state.operators.set(name, behavior)), behavior?.error && (decl = prepend(behavior.error, decl)), decl = prepend(trimFirstSpace(w), decl), decl;
   }), OperatorDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(OperatorSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
     var signature = $1, block = $2;
     return state.operators.set(signature.id.name, signature.behavior), {
@@ -9328,9 +9478,12 @@ ${js}`
     };
   }), OperatorDeclaration$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(Operator, _, Identifier, (0, import_lib2.$E)(OperatorBehavior), (0, import_lib2.$Q)((0, import_lib2.$S)(CommaDelimiter, (0, import_lib2.$E)(_), Identifier, (0, import_lib2.$E)(OperatorBehavior)))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
     var op = $1, w1 = $2, id = $3, behavior = $4, ids = $5;
-    return state.operators.set(id.name, behavior), ids.forEach(([, , id2, behavior2]) => state.operators.set(id2.name, behavior2)), {
+    let children = [];
+    return state.operators.set(id.name, behavior), behavior?.error && children.push(behavior.error), ids.forEach(([, , id2, behavior2]) => {
+      state.operators.set(id2.name, behavior2), behavior2?.error && children.push(behavior2.error);
+    }), {
       id,
-      children: []
+      children
     };
   }), OperatorDeclaration$$ = [OperatorDeclaration$0, OperatorDeclaration$1, OperatorDeclaration$2];
   function OperatorDeclaration(ctx, state2) {
@@ -9351,7 +9504,7 @@ ${js}`
         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
     };
   });
@@ -9368,16 +9521,19 @@ ${js}`
   }
   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, op = $5;
-    let prec = op.type === "Identifier" ? state.operators.get(op.name).prec : getPrecedence(op[1]);
-    switch (mod) {
+    let prec, error;
+    switch (op.type === "Identifier" ? state.operators.has(op.name) ? prec = state.operators.get(op.name).prec : (prec = precedenceCustomDefault, error = {
+      type: "Error",
+      message: `Precedence refers to unknown operator ${op.name}`
+    }) : prec = getPrecedence(op[1]), 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);
@@ -9933,8 +10089,8 @@ ${js}`
     return (0, import_lib2.$EVENT)(ctx, state2, "RangeEnd", RangeEnd$0);
   }
   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, ws = $2, range = $3, end = $4;
-    return processRangeExpression(start, ws, range, end);
+    var start = $1, ws = $2, range2 = $3, end = $4;
+    return processRangeExpression(start, ws, range2, end);
   }), 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, ws = $2;
     return {
@@ -10791,6 +10947,7 @@ ${js}`
     return {
       $loc,
       token: "instanceof",
+      spaced: !0,
       relational: !0,
       special: !0
     };
@@ -10798,6 +10955,7 @@ ${js}`
     return {
       $loc,
       token: "instanceof",
+      spaced: !0,
       relational: !0,
       special: !0,
       negated: !0
@@ -10844,6 +11002,7 @@ ${js}`
     return {
       $loc,
       token: $1,
+      spaced: !0,
       relational: !0,
       special: !0
       // for typeof shorthand
@@ -10923,6 +11082,7 @@ ${js}`
     return {
       $loc,
       token: "in",
+      spaced: !0,
       special: !0,
       negated: !0
     };
@@ -10942,6 +11102,7 @@ ${js}`
     return {
       $loc,
       token: "instanceof",
+      spaced: !0,
       relational: !0,
       special: !0,
       negated: !0
@@ -10950,6 +11111,7 @@ ${js}`
     return {
       $loc,
       token: "in",
+      spaced: !0,
       special: !0,
       negated: !0
     };
@@ -11547,10 +11709,10 @@ ${js}`
     };
   }), 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, binding = $3;
-    return {
+    return gatherRecursive(binding, ($) => $.type === "PinPattern").length ? $skip : {
       type: "ForDeclaration",
       children: [c, binding],
-      decl: c.token,
+      decl: c.token.trimEnd(),
       binding,
       names: binding.names
     };
@@ -11691,12 +11853,16 @@ ${js}`
   function PatternExpressionList(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "PatternExpressionList", PatternExpressionList$0);
   }
-  var PatternExpression$0 = BindingPattern, 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;
-    return pattern ? {
+  var PatternExpression$0 = BindingPattern, 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;
+    let [named, rhs] = body, binding;
+    return named && ([binding] = named), {
       type: "ConditionFragment",
-      children: pattern
-    } : $skip;
+      children: [binding, rhs],
+      binding,
+      rhs
+    };
   }), PatternExpression$$ = [PatternExpression$0, PatternExpression$1];
   function PatternExpression(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "PatternExpression", PatternExpression$$);
@@ -11779,15 +11945,7 @@ ${js}`
   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 binding = $1, typeSuffix = $2;
-    return {
-      type: "CatchParameter",
-      binding,
-      typeSuffix,
-      children: $0
-    };
-  }), 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$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, typeSuffix = $2;
     return {
       type: "CatchParameter",
@@ -11795,12 +11953,20 @@ ${js}`
       typeSuffix,
       children: [binding, typeSuffix]
     };
-  }), CatchParameter$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PatternExpressionList), function($skip, $loc, $0, $1) {
+  }), CatchParameter$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(PatternExpressionList), function($skip, $loc, $0, $1) {
     return {
       type: "CatchPattern",
       children: $0,
       patterns: $1
     };
+  }), 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, typeSuffix = $2;
+    return {
+      type: "CatchParameter",
+      binding,
+      typeSuffix,
+      children: $0
+    };
   }), CatchParameter$$ = [CatchParameter$0, CatchParameter$1, CatchParameter$2];
   function CatchParameter(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "CatchParameter", CatchParameter$$);
@@ -12195,11 +12361,12 @@ ${js}`
     };
   }), ImportDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)((0, import_lib2.$S)(Import, __), ImpliedImport), Operator, (0, import_lib2.$E)(OperatorBehavior), __, OperatorNamedImports, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
     var i = $1, behavior = $3, ws1 = $4, imports = $5, ws2 = $6, from = $7;
-    return imports.specifiers.forEach((spec) => {
-      state.operators.set(spec.binding.name, spec.behavior ?? behavior);
+    let errors = [];
+    return behavior?.error && errors.push(behavior.error), imports.specifiers.forEach((spec) => {
+      state.operators.set(spec.binding.name, spec.behavior ?? behavior), spec.behavior?.error && errors.push(spec.behavior.error);
     }), {
       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
@@ -12224,11 +12391,12 @@ ${js}`
     }, { type: "ImportDeclaration", ts: !!t, children: [i, t, imports, w, from], imports, from };
   }), ImportDeclaration$5 = (0, import_lib2.$TS)((0, import_lib2.$S)(ImpliedFromClause, __, Import, __, Operator, (0, import_lib2.$E)(OperatorBehavior), __, OperatorNamedImports), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
     var from = $1, fws = $2, i = $3, iws = $4, behavior = $6, ows = $7, imports = $8;
-    return imports.specifiers.forEach((spec) => {
-      state.operators.set(spec.binding.name, spec.behavior ?? behavior);
+    let errors = [];
+    return behavior?.error && errors.push(behavior.error), imports.specifiers.forEach((spec) => {
+      state.operators.set(spec.binding.name, spec.behavior ?? behavior), spec.behavior?.error && errors.push(spec.behavior.error);
     }), {
       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
@@ -12382,14 +12550,14 @@ ${js}`
     return {
       binding,
       behavior,
-      children: [$1, $2, $4, $5, $6, $7]
+      children: [$1, $2, $3?.error, $4, $5, $6, $7]
     };
   }), 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) {
     var binding = $2, behavior = $3;
     return {
       binding,
       behavior,
-      children: [$1, $2, $4]
+      children: [$1, $2, $3?.error, $4]
     };
   }), OperatorImportSpecifier$$ = [OperatorImportSpecifier$0, OperatorImportSpecifier$1];
   function OperatorImportSpecifier(ctx, state2) {
@@ -13123,7 +13291,7 @@ ${js}`
   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) {
@@ -13362,7 +13530,7 @@ ${js}`
     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: !0 };
   });
   function In(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "In", In$0);