@danielx/civet 0.9.5 → 0.9.6

package/dist/main.js

@@ -555,6 +555,7 @@ __export(lib_civet_exports, {
   maybeRefAssignment: () => maybeRefAssignment,
   modifyString: () => modifyString,
   negateCondition: () => negateCondition,
+  precedenceCustomDefault: () => precedenceCustomDefault,
   precedenceStep: () => precedenceStep,
   prepend: () => prepend,
   processAssignmentDeclaration: () => processAssignmentDeclaration,
@@ -3100,6 +3101,7 @@ function assignResults(node, collect) {
     exp = exp.statement;
   }
   let ref6;
+  let m1;
   switch (exp.type) {
     case "BreakStatement":
     case "ContinueStatement":
@@ -3179,6 +3181,9 @@ function assignResults(node, collect) {
       return;
     }
     case "PipelineExpression": {
+      if (m1 = exp.children[1]?.type, m1 === "ReturnStatement" || m1 === "ThrowStatement") {
+        return;
+      }
       const semi2 = exp.children.lastIndexOf(";");
       if (0 <= semi2 && semi2 < exp.children.length - 1) {
         exp.children.splice(semi2 + 1, 1 / 0, ...[collect(exp.children.slice(semi2 + 1))]);
@@ -3204,8 +3209,8 @@ function insertReturn(node) {
         const last = node.expressions[node.expressions.length - 1];
         insertReturn(last);
       } else {
-        let m1;
-        if (m1 = node.parent?.type, m1 === "CatchClause" || m1 === "WhenClause") {
+        let m2;
+        if (m2 = node.parent?.type, m2 === "CatchClause" || m2 === "WhenClause") {
           node.expressions.push(["", wrapWithReturn(void 0, node)]);
         }
       }
@@ -3251,6 +3256,7 @@ function insertReturn(node) {
     exp = exp.statement;
   }
   let ref11;
+  let m3;
   switch (exp.type) {
     case "BreakStatement":
     case "ContinueStatement":
@@ -3342,6 +3348,9 @@ function insertReturn(node) {
       return;
     }
     case "PipelineExpression": {
+      if (m3 = exp.children[1]?.type, m3 === "ReturnStatement" || m3 === "ThrowStatement") {
+        return;
+      }
       const semi2 = exp.children.lastIndexOf(";");
       if (0 <= semi2 && semi2 < exp.children.length - 1) {
         exp.children.splice(semi2 + 1, 1 / 0, ...[wrapWithReturn(exp.children.slice(semi2 + 1))]);
@@ -3364,8 +3373,8 @@ function processBreakContinueWith(statement) {
   )) {
     if (control.with) {
       if (control.label) {
-        let m2;
-        if (!(m2 = statement.parent, typeof m2 === "object" && m2 != null && "type" in m2 && m2.type === "LabelledStatement" && "label" in m2 && typeof m2.label === "object" && m2.label != null && "name" in m2.label && m2.label.name === control.label.name)) {
+        let m4;
+        if (!(m4 = statement.parent, typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "LabelledStatement" && "label" in m4 && typeof m4.label === "object" && m4.label != null && "name" in m4.label && m4.label.name === control.label.name)) {
           continue;
         }
       } else {
@@ -3586,8 +3595,8 @@ function iterationDefaultBody(statement) {
   const reduction = statement.type === "ForStatement" && statement.reduction;
   function fillBlock(expression) {
     let ref15;
-    let m3;
-    if (m3 = (ref15 = block.expressions)[ref15.length - 1], Array.isArray(m3) && m3.length >= 2 && typeof m3[1] === "object" && m3[1] != null && "type" in m3[1] && m3[1].type === "EmptyStatement" && "implicit" in m3[1] && m3[1].implicit === true) {
+    let m5;
+    if (m5 = (ref15 = block.expressions)[ref15.length - 1], Array.isArray(m5) && m5.length >= 2 && typeof m5[1] === "object" && m5[1] != null && "type" in m5[1] && m5[1].type === "EmptyStatement" && "implicit" in m5[1] && m5[1].implicit === true) {
       block.expressions.pop();
     }
     block.expressions.push(expression);
@@ -3715,8 +3724,8 @@ function processParams(f) {
     parameters.names.push(...rest.names || []);
     rest.children.pop();
     if (after.length) {
-      let m4;
-      if (m4 = rest.binding.type, m4 === "ArrayBindingPattern" || m4 === "ObjectBindingPattern" || m4 === "NamedBindingPattern") {
+      let m6;
+      if (m6 = rest.binding.type, m6 === "ArrayBindingPattern" || m6 === "ObjectBindingPattern" || m6 === "NamedBindingPattern") {
         parameters.parameters.push({
           type: "Error",
           message: "Non-end rest parameter cannot be binding pattern"
@@ -3858,8 +3867,8 @@ function processParams(f) {
       const classExpressions = ancestor.body.expressions;
       let index2 = findChildIndex(classExpressions, f);
       assert.notEqual(index2, -1, "Could not find constructor in class");
-      let m5;
-      while (m5 = classExpressions[index2 - 1]?.[1], typeof m5 === "object" && m5 != null && "type" in m5 && m5.type === "MethodDefinition" && "name" in m5 && m5.name === "constructor") {
+      let m7;
+      while (m7 = classExpressions[index2 - 1]?.[1], typeof m7 === "object" && m7 != null && "type" in m7 && m7.type === "MethodDefinition" && "name" in m7 && m7.name === "constructor") {
         index2--;
       }
       const fStatement = classExpressions[index2];
@@ -6016,9 +6025,8 @@ function constructInvocation(fn, arg) {
   if (lhs.type === "NewExpression") {
     let { expression } = lhs;
     expression = {
-      ...expression,
       type: "CallExpression",
-      children: [...expression.children, call]
+      children: [expression, call]
     };
     return {
       ...lhs,
@@ -6071,23 +6079,22 @@ function constructPipeStep(fn, arg, returning) {
   ];
 }
 function processPipelineExpressions(statements) {
-  gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
+  for (let ref1 = gatherRecursiveAll(statements, ($1) => $1.type === "PipelineExpression"), i1 = 0, len3 = ref1.length; i1 < len3; i1++) {
+    const s = ref1[i1];
     const [ws, , body] = s.children;
     let [, arg] = s.children;
-    let i = 0;
-    const l = body.length;
     const children = [ws];
     const comma = blockContainingStatement(s) ? ";" : ",";
     let usingRef = null;
-    for (let i1 = 0, len3 = body.length; i1 < len3; i1++) {
-      const i2 = i1;
-      const step = body[i1];
+    for (let i2 = 0, len1 = body.length; i2 < len1; i2++) {
+      const i = i2;
+      const step = body[i2];
       const [leadingComment, pipe, trailingComment, expr] = step;
       const returns = pipe.token === "||>";
       let ref, result, returning = returns ? arg : null;
       if (pipe.token === "|>=") {
         let initRef;
-        if (i2 === 0) {
+        if (i === 0) {
           checkValidLHS(arg);
           outer: switch (arg.type) {
             case "MemberExpression": {
@@ -6136,7 +6143,7 @@ function processPipelineExpressions(statements) {
           });
         }
       } else {
-        if (i2 === 0) s.children = children;
+        if (i === 0) s.children = children;
       }
       if (returns && (ref = needsRef(arg))) {
         usingRef = usingRef || ref;
@@ -6160,7 +6167,7 @@ function processPipelineExpressions(statements) {
         returning
       );
       if (result.type === "ReturnStatement") {
-        if (i2 < l - 1) {
+        if (i < body.length - 1) {
           result.children.push({
             type: "Error",
             message: "Can't continue a pipeline after returning"
@@ -6188,7 +6195,7 @@ function processPipelineExpressions(statements) {
       };
     }
     children.push(arg);
-    if (!children.some(($1) => $1?.type === "ReturnStatement") && children.some(($2) => $2 === ",")) {
+    if (!children.some(($2) => $2?.type === "ReturnStatement") && children.some(($3) => $3 === ",")) {
       const { parent } = s;
       const parenthesizedExpression = makeLeftHandSideExpression({ ...s });
       Object.assign(s, parenthesizedExpression, {
@@ -6196,8 +6203,8 @@ function processPipelineExpressions(statements) {
         hoistDec: void 0
       });
     }
-    return addParentPointers(s, s.parent);
-  });
+    addParentPointers(s, s.parent);
+  }
 }
 
 // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\for.civet.jsx
@@ -7348,14 +7355,21 @@ function processCallMemberExpression(node) {
       }
     }
     if (args.length) {
-      children.splice(
-        0,
-        2,
-        commaCount ? {
+      if (commaCount) {
+        children.splice(0, 2, {
           type: "ParenthesizedExpression",
-          children: ["(", ...call.children, ")"]
-        } : { ...call, type: "ParenthesizedExpression" }
-      );
+          children: ["(", call.children, ")"],
+          expression: call.children
+        });
+      } else {
+        const middle = call.children.slice(0 + 1, -1);
+        let ref2;
+        children.splice(0, 2, {
+          type: "ParenthesizedExpression",
+          expression: middle,
+          children: [call.children[0], middle, (ref2 = call.children)[ref2.length - 1]]
+        });
+      }
       if (children.length === 1) {
         return children[0];
       }
@@ -7438,14 +7452,14 @@ function processCallMemberExpression(node) {
           });
         }
       }
-      let ref2;
+      let ref3;
       const object = {
         type: "ObjectExpression",
         children: [
           glob.object.children[0],
           // {
           ...parts,
-          (ref2 = glob.object.children)[ref2.length - 1]
+          (ref3 = glob.object.children)[ref3.length - 1]
           // whitespace and }
         ],
         properties: parts
@@ -7506,7 +7520,7 @@ function processCallMemberExpression(node) {
           })
         ]
       });
-      let ref3;
+      let ref4;
       return processCallMemberExpression({
         // in case there are more
         ...node,
@@ -7520,7 +7534,7 @@ function processCallMemberExpression(node) {
               glob.children[0],
               // "[" token
               call,
-              (ref3 = glob.children)[ref3.length - 1]
+              (ref4 = glob.children)[ref4.length - 1]
               // "]" token
             ]
           }),
@@ -7533,7 +7547,7 @@ function processCallMemberExpression(node) {
         { ...glob.children[0], token: ", " },
         ...glob.children.slice(1, -1)
       ];
-      let ref4;
+      let ref5;
       const rsliceCall = makeNode({
         type: "CallExpression",
         implicit: true,
@@ -7545,7 +7559,7 @@ function processCallMemberExpression(node) {
             children: [
               "(",
               args,
-              (ref4 = glob.children)[ref4.length - 1]
+              (ref5 = glob.children)[ref5.length - 1]
             ]
           })
         ]
@@ -7630,8 +7644,8 @@ function convertNamedImportsToObject(node, pattern) {
       return { type: "Error", message: "cannot use `type` in dynamic import" };
     } else {
       const { source, binding } = specifier;
-      let ref5;
-      const delim = (ref5 = specifier.children)[ref5.length - 1];
+      let ref6;
+      const delim = (ref6 = specifier.children)[ref6.length - 1];
       return {
         type: pattern ? "BindingProperty" : "Property",
         name: source,
@@ -7641,7 +7655,7 @@ function convertNamedImportsToObject(node, pattern) {
       };
     }
   });
-  let ref6;
+  let ref7;
   return {
     type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
     names: node.names,
@@ -7650,7 +7664,7 @@ function convertNamedImportsToObject(node, pattern) {
       node.children[0],
       // {
       properties,
-      (ref6 = node.children)[ref6.length - 1]
+      (ref7 = node.children)[ref7.length - 1]
       // }
     ]
   };
@@ -7771,7 +7785,7 @@ function processBindingPatternLHS(lhs, tail) {
   );
 }
 function processAssignments(statements) {
-  for (let ref7 = gatherRecursiveAll(statements, ($4) => $4.type === "AssignmentExpression" || $4.type === "UpdateExpression"), i5 = 0, len3 = ref7.length; i5 < len3; i5++) {
+  for (let ref8 = gatherRecursiveAll(statements, ($4) => $4.type === "AssignmentExpression" || $4.type === "UpdateExpression"), i5 = 0, len3 = ref8.length; i5 < len3; i5++) {
     let extractAssignment = function(lhs) {
       let expr = lhs;
       while (expr.type === "ParenthesizedExpression") {
@@ -7791,20 +7805,20 @@ function processAssignments(statements) {
       ;
       return;
     };
-    const exp = ref7[i5];
+    const exp = ref8[i5];
     checkValidLHS(exp.assigned);
     const pre = [], post = [];
-    let ref8;
+    let ref9;
     switch (exp.type) {
       case "AssignmentExpression": {
         if (!exp.lhs) {
           continue;
         }
-        for (let ref9 = exp.lhs, i6 = 0, len4 = ref9.length; i6 < len4; i6++) {
-          const lhsPart = ref9[i6];
-          let ref10;
-          if (ref10 = extractAssignment(lhsPart[1])) {
-            const newLhs = ref10;
+        for (let ref10 = exp.lhs, i6 = 0, len4 = ref10.length; i6 < len4; i6++) {
+          const lhsPart = ref10[i6];
+          let ref11;
+          if (ref11 = extractAssignment(lhsPart[1])) {
+            const newLhs = ref11;
             lhsPart[1] = newLhs;
           }
         }
@@ -7812,8 +7826,8 @@ function processAssignments(statements) {
         break;
       }
       case "UpdateExpression": {
-        if (ref8 = extractAssignment(exp.assigned)) {
-          const newLhs = ref8;
+        if (ref9 = extractAssignment(exp.assigned)) {
+          const newLhs = ref9;
           const i = exp.children.indexOf(exp.assigned);
           exp.assigned = exp.children[i] = newLhs;
         }
@@ -7845,22 +7859,22 @@ function processAssignments(statements) {
       }
     }
   }
-  for (let ref11 = gatherRecursiveAll(statements, ($6) => $6.type === "AssignmentExpression"), i7 = 0, len5 = ref11.length; i7 < len5; i7++) {
-    const exp = ref11[i7];
+  for (let ref12 = gatherRecursiveAll(statements, ($6) => $6.type === "AssignmentExpression"), i7 = 0, len5 = ref12.length; i7 < len5; i7++) {
+    const exp = ref12[i7];
     if (!(exp.names === null)) {
       continue;
     }
     let { lhs: $1, expression: $2 } = exp, tail = [], len3 = $1.length;
     let block;
-    let ref12;
-    if (blockContainingStatement(exp) && !(ref12 = $1[$1.length - 1])?.[ref12.length - 1]?.special) {
+    let ref13;
+    if (blockContainingStatement(exp) && !(ref13 = $1[$1.length - 1])?.[ref13.length - 1]?.special) {
       block = makeBlockFragment();
-      let ref13;
-      if (ref13 = prependStatementExpressionBlock(
+      let ref14;
+      if (ref14 = prependStatementExpressionBlock(
         { type: "Initializer", expression: $2, children: [void 0, void 0, $2] },
         block
       )) {
-        const ref = ref13;
+        const ref = ref14;
         exp.children = exp.children.map(($7) => $7 === $2 ? ref : $7);
         $2 = ref;
       } else {
@@ -8041,9 +8055,9 @@ function unchainOptionalMemberExpression(exp, ref, innerExp) {
     }
     j++;
   }
-  let ref14;
-  if (ref14 = conditions.length) {
-    const l = ref14;
+  let ref15;
+  if (ref15 = conditions.length) {
+    const l = ref15;
     const cs = flatJoin(conditions, " && ");
     return {
       ...exp,
@@ -8079,8 +8093,8 @@ function attachPostfixStatementAsExpression(exp, post) {
 }
 function processTypes(node) {
   const results1 = [];
-  for (let ref15 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len6 = ref15.length; i8 < len6; i8++) {
-    const unary = ref15[i8];
+  for (let ref16 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len6 = ref16.length; i8 < len6; i8++) {
+    const unary = ref16[i8];
     let suffixIndex = unary.suffix.length - 1;
     const results2 = [];
     while (suffixIndex >= 0) {
@@ -8159,10 +8173,10 @@ function processTypes(node) {
         const outer = unary.suffix.splice(suffixIndex + 1, Infinity);
         const space = getTrimmingSpace(unary);
         inplaceInsertTrimmingSpace(unary, "");
-        let ref16;
-        if (unary.suffix.length) ref16 = unary;
-        else ref16 = unary.t;
-        const t = ref16;
+        let ref17;
+        if (unary.suffix.length) ref17 = unary;
+        else ref17 = unary.t;
+        const t = ref17;
         const arg = makeNode({
           type: "TypeArgument",
           ts: true,
@@ -8207,18 +8221,18 @@ function processTypes(node) {
   return results1;
 }
 function processStatementExpressions(statements) {
-  for (let ref17 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len7 = ref17.length; i9 < len7; i9++) {
-    const exp = ref17[i9];
+  for (let ref18 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len7 = ref18.length; i9 < len7; i9++) {
+    const exp = ref18[i9];
     const { maybe, statement } = exp;
     if ((maybe || statement.type === "ThrowStatement") && blockContainingStatement(exp)) {
       replaceNode(exp, statement);
       continue;
     }
-    let ref18;
+    let ref19;
     switch (statement.type) {
       case "IfStatement": {
-        if (ref18 = expressionizeIfStatement(statement)) {
-          const expression = ref18;
+        if (ref19 = expressionizeIfStatement(statement)) {
+          const expression = ref19;
           replaceNode(statement, expression, exp);
         } else {
           replaceNode(statement, wrapIIFE([["", statement]]), exp);
@@ -8277,13 +8291,13 @@ function processNegativeIndexAccess(statements) {
   });
 }
 function processFinallyClauses(statements) {
-  for (let ref19 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len8 = ref19.length; i10 < len8; i10++) {
-    let f = ref19[i10];
-    let ref20;
-    if (!((ref20 = blockContainingStatement(f)) && typeof ref20 === "object" && "block" in ref20 && "index" in ref20)) {
+  for (let ref20 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len8 = ref20.length; i10 < len8; i10++) {
+    let f = ref20[i10];
+    let ref21;
+    if (!((ref21 = blockContainingStatement(f)) && typeof ref21 === "object" && "block" in ref21 && "index" in ref21)) {
       throw new Error("finally clause must be inside try statement or block");
     }
-    const { block, index } = ref20;
+    const { block, index } = ref21;
     const indent = block.expressions[index][0];
     const expressions = block.expressions.slice(index + 1);
     const t = makeNode({
@@ -8355,8 +8369,8 @@ function processBreaksContinues(statements) {
   }
 }
 function processCoffeeClasses(statements) {
-  for (let ref21 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref21.length; i11 < len9; i11++) {
-    const ce = ref21[i11];
+  for (let ref22 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref22.length; i11 < len9; i11++) {
+    const ce = ref22[i11];
     const { expressions } = ce.body;
     const indent = expressions[0]?.[0] ?? "\n";
     const autoBinds = expressions.filter(($14) => $14[1]?.autoBind);
@@ -8506,8 +8520,8 @@ async function processProgramAsync(root) {
 function processRepl(root, rootIIFE) {
   const topBlock = gatherRecursive(rootIIFE, ($17) => $17.type === "BlockStatement")[0];
   let i = 0;
-  for (let ref22 = gatherRecursiveWithinFunction(topBlock, ($18) => $18.type === "Declaration"), i14 = 0, len11 = ref22.length; i14 < len11; i14++) {
-    const decl = ref22[i14];
+  for (let ref23 = gatherRecursiveWithinFunction(topBlock, ($18) => $18.type === "Declaration"), i14 = 0, len11 = ref23.length; i14 < len11; i14++) {
+    const decl = ref23[i14];
     if (!decl.names?.length) {
       continue;
     }
@@ -8520,8 +8534,8 @@ function processRepl(root, rootIIFE) {
       root.expressions.splice(i++, 0, ["", `var ${decl.names.join(",")}`, ";"]);
     }
   }
-  for (let ref23 = gatherRecursive(topBlock, ($19) => $19.type === "FunctionExpression"), i15 = 0, len12 = ref23.length; i15 < len12; i15++) {
-    const func = ref23[i15];
+  for (let ref24 = gatherRecursive(topBlock, ($19) => $19.type === "FunctionExpression"), i15 = 0, len12 = ref24.length; i15 < len12; i15++) {
+    const func = ref24[i15];
     if (func.name && func.parent?.type === "BlockStatement") {
       if (func.parent === topBlock) {
         replaceNode(func, void 0);
@@ -8533,8 +8547,8 @@ function processRepl(root, rootIIFE) {
       }
     }
   }
-  for (let ref24 = gatherRecursiveWithinFunction(topBlock, ($20) => $20.type === "ClassExpression"), i16 = 0, len13 = ref24.length; i16 < len13; i16++) {
-    const classExp = ref24[i16];
+  for (let ref25 = gatherRecursiveWithinFunction(topBlock, ($20) => $20.type === "ClassExpression"), i16 = 0, len13 = ref25.length; i16 < len13; i16++) {
+    const classExp = ref25[i16];
     let m8;
     if (classExp.name && classExp.parent === topBlock || (m8 = classExp.parent, typeof m8 === "object" && m8 != null && "type" in m8 && m8.type === "ReturnStatement" && "parent" in m8 && m8.parent === topBlock)) {
       classExp.children.unshift(classExp.name, "=");
@@ -8545,8 +8559,8 @@ function processRepl(root, rootIIFE) {
 function processPlaceholders(statements) {
   const placeholderMap = /* @__PURE__ */ new Map();
   const liftedIfs = /* @__PURE__ */ new Set();
-  for (let ref25 = gatherRecursiveAll(statements, ($21) => $21.type === "Placeholder"), i17 = 0, len14 = ref25.length; i17 < len14; i17++) {
-    const exp = ref25[i17];
+  for (let ref26 = gatherRecursiveAll(statements, ($21) => $21.type === "Placeholder"), i17 = 0, len14 = ref26.length; i17 < len14; i17++) {
+    const exp = ref26[i17];
     let ancestor;
     if (exp.subtype === ".") {
       ({ ancestor } = findAncestor(
@@ -8658,8 +8672,8 @@ function processPlaceholders(statements) {
     for (let i18 = 0, len15 = placeholders.length; i18 < len15; i18++) {
       const placeholder = placeholders[i18];
       typeSuffix ??= placeholder.typeSuffix;
-      let ref26;
-      (ref26 = placeholder.children)[ref26.length - 1] = ref;
+      let ref27;
+      (ref27 = placeholder.children)[ref27.length - 1] = ref;
     }
     const { parent } = ancestor;
     const body = maybeUnwrap(ancestor);
@@ -8680,16 +8694,16 @@ function processPlaceholders(statements) {
       }
       case "PipelineExpression": {
         const i = findChildIndex(parent, ancestor);
-        let ref27;
+        let ref28;
         if (i === 1) {
-          ref27 = ancestor === parent.children[i];
+          ref28 = ancestor === parent.children[i];
         } else if (i === 2) {
-          ref27 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
+          ref28 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
         } else {
-          ref27 = void 0;
+          ref28 = void 0;
         }
         ;
-        outer = ref27;
+        outer = ref28;
         break;
       }
       case "AssignmentExpression":
@@ -8704,9 +8718,12 @@ function processPlaceholders(statements) {
       fnExp = makeLeftHandSideExpression(fnExp);
     }
     replaceNode(ancestor, fnExp, parent);
-    let ref28;
-    if (ref28 = getTrimmingSpace(body)) {
-      const ws = ref28;
+    if (typeof parent === "object" && parent != null && "type" in parent && parent.type === "BlockStatement" && "parent" in parent && typeof parent.parent === "object" && parent.parent != null && "type" in parent.parent && parent.parent.type === "ArrowFunction" && "ampersandBlock" in parent.parent && parent.parent.ampersandBlock === true && "body" in parent.parent && parent.parent.body === body) {
+      parent.parent.body = fnExp;
+    }
+    let ref29;
+    if (ref29 = getTrimmingSpace(body)) {
+      const ws = ref29;
       inplaceInsertTrimmingSpace(body, "");
       inplacePrepend(ws, fnExp);
     }
@@ -8750,8 +8767,8 @@ function reorderBindingRestProperty(props) {
       }
     ];
   }
-  let ref29;
-  if (Array.isArray(rest.delim) && (ref29 = rest.delim)[ref29.length - 1]?.token === ",") {
+  let ref30;
+  if (Array.isArray(rest.delim) && (ref30 = rest.delim)[ref30.length - 1]?.token === ",") {
     rest.delim = rest.delim.slice(0, -1);
     rest.children = [...rest.children.slice(0, -1), rest.delim];
   }
@@ -10939,24 +10956,27 @@ var PipelineHeadItem$$ = [PipelineHeadItem$0, PipelineHeadItem$1];
 function PipelineHeadItem(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "PipelineHeadItem", PipelineHeadItem$$);
 }
-var PipelineTailItem$0 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$C)(AwaitOp, Yield, Return, Throw), (0, import_lib2.$N)(AccessStart), (0, import_lib2.$N)(MaybeParenNestedExpression)), function(value) {
+var PipelineTailItem$0 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$C)(AwaitOp, Return, Throw), (0, import_lib2.$N)(AccessStart), (0, import_lib2.$N)(MaybeParenNestedExpression)), function(value) {
   return value[0];
 });
-var PipelineTailItem$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L15, 'PipelineTailItem "import"'), (0, import_lib2.$N)(AccessStart)), function($skip, $loc, $0, $1, $2) {
+var PipelineTailItem$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$TEXT)((0, import_lib2.$S)(Yield, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)(_), Star)))), (0, import_lib2.$N)(AccessStart), (0, import_lib2.$N)(MaybeParenNestedExpression)), function($skip, $loc, $0, $1, $2, $3) {
+  return { $loc, token: $1, type: "Yield" };
+});
+var PipelineTailItem$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L15, 'PipelineTailItem "import"'), (0, import_lib2.$N)(AccessStart)), function($skip, $loc, $0, $1, $2) {
   return {
     type: "Identifier",
     children: [$1]
   };
 });
-var PipelineTailItem$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(NWTypePostfix, (0, import_lib2.$Q)(TypePostfix)), function($skip, $loc, $0, $1, $2) {
+var PipelineTailItem$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(NWTypePostfix, (0, import_lib2.$Q)(TypePostfix)), function($skip, $loc, $0, $1, $2) {
   return makeAmpersandFunction({
     body: [" ", $1, ...$2]
   });
 });
-var PipelineTailItem$3 = (0, import_lib2.$T)((0, import_lib2.$S)(PipelineHeadItem), function(value) {
+var PipelineTailItem$4 = (0, import_lib2.$T)((0, import_lib2.$S)(PipelineHeadItem), function(value) {
   return value[0];
 });
-var PipelineTailItem$$ = [PipelineTailItem$0, PipelineTailItem$1, PipelineTailItem$2, PipelineTailItem$3];
+var PipelineTailItem$$ = [PipelineTailItem$0, PipelineTailItem$1, PipelineTailItem$2, PipelineTailItem$3, PipelineTailItem$4];
 function PipelineTailItem(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "PipelineTailItem", PipelineTailItem$$);
 }
@@ -12707,13 +12727,17 @@ var FunctionExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(FunctionSign
     block
   };
 });
-var FunctionExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(ArrowFunction), OpenParen, BinaryOp, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
+var FunctionExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(ArrowFunction), OpenParen, __, BinaryOp, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var open = $2;
-  var op = $3;
-  var close = $4;
+  var ws1 = $3;
+  var op = $4;
+  var ws2 = $5;
+  var close = $6;
   if (op.special && op.call && !op.negated) return op.call;
+  if (!ws1) ws1 = op.spaced ? [" "] : [];
+  if (!ws2) ws2 = op.spaced ? [" "] : [];
   const refA = makeRef("a"), refB = makeRef("b"), body = processBinaryOpExpression([refA, [
-    [[], op, [], refB]
+    [ws1, op, ws2, refB]
     // BinaryOpRHS
   ]]);
   const parameterList = [[refA, ","], refB];
@@ -12745,6 +12769,8 @@ var FunctionExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, N
   var op = $4;
   var ws2 = $5;
   var close = $6;
+  if (!ws1) ws1 = op.spaced ? [" "] : [];
+  if (!ws2) ws2 = op.spaced ? [" "] : [];
   const refB = makeRef("b");
   const fn = makeAmpersandFunction({
     ref: refB,
@@ -12811,6 +12837,8 @@ var FunctionExpression$5 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, _
   var ws2 = $6;
   var rhs = $7;
   var close = $8;
+  if (!ws1) ws1 = op.spaced ? [" "] : [];
+  if (!ws2) ws2 = op.spaced ? [" "] : [];
   const refA = makeRef("a");
   const fn = makeAmpersandFunction({
     ref: refA,
@@ -12835,10 +12863,9 @@ var OperatorDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Operator, (
   var w = $3;
   var decl = $4;
   decl.names.forEach((name) => state.operators.set(name, behavior));
-  return {
-    ...decl,
-    children: [trimFirstSpace(w), ...decl.children]
-  };
+  if (behavior?.error) decl = prepend(behavior.error, decl);
+  decl = prepend(trimFirstSpace(w), decl);
+  return decl;
 });
 var OperatorDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(OperatorSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
   var signature = $1;
@@ -12859,11 +12886,16 @@ var OperatorDeclaration$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(Operator, _
   var id = $3;
   var behavior = $4;
   var ids = $5;
+  const children = [];
   state.operators.set(id.name, behavior);
-  ids.forEach(([, , id2, behavior2]) => state.operators.set(id2.name, behavior2));
+  if (behavior?.error) children.push(behavior.error);
+  ids.forEach(([, , id2, behavior2]) => {
+    state.operators.set(id2.name, behavior2);
+    if (behavior2?.error) children.push(behavior2.error);
+  });
   return {
     id,
-    children: []
+    children
   };
 });
 var OperatorDeclaration$$ = [OperatorDeclaration$0, OperatorDeclaration$1, OperatorDeclaration$2];
@@ -12901,7 +12933,7 @@ var OperatorSignature$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
       generator: !!generator.length
     },
     block: null,
-    children: [async, func, generator, w1, id, w2, parameters, returnType],
+    children: [async, func, generator, w1, id, behavior?.error, w2, parameters, returnType],
     behavior
   };
 });
@@ -12921,16 +12953,29 @@ function OperatorBehavior(ctx, state2) {
 var OperatorPrecedence$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$C)((0, import_lib2.$EXPECT)($L27, 'OperatorPrecedence "tighter"'), (0, import_lib2.$EXPECT)($L28, 'OperatorPrecedence "looser"'), (0, import_lib2.$EXPECT)($L29, 'OperatorPrecedence "same"')), NonIdContinue, (0, import_lib2.$E)(_), (0, import_lib2.$C)(Identifier, (0, import_lib2.$S)(OpenParen, BinaryOp, CloseParen))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var mod = $2;
   var op = $5;
-  let prec = op.type === "Identifier" ? state.operators.get(op.name).prec : getPrecedence(op[1]);
+  let prec, error;
+  if (op.type === "Identifier") {
+    if (state.operators.has(op.name)) {
+      prec = state.operators.get(op.name).prec;
+    } else {
+      prec = precedenceCustomDefault;
+      error = {
+        type: "Error",
+        message: `Precedence refers to unknown operator ${op.name}`
+      };
+    }
+  } else {
+    prec = getPrecedence(op[1]);
+  }
   switch (mod) {
     case "tighter":
-      prec += 1 / 64;
+      prec += precedenceStep;
       break;
     case "looser":
-      prec -= 1 / 64;
+      prec -= precedenceStep;
       break;
   }
-  return { prec };
+  return { prec, error };
 });
 function OperatorPrecedence(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "OperatorPrecedence", OperatorPrecedence$0);
@@ -14768,6 +14813,7 @@ var BinaryOpSymbol$13 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L23, 'Bin
   return {
     $loc,
     token: "instanceof",
+    spaced: true,
     relational: true,
     special: true
   };
@@ -14776,6 +14822,7 @@ var BinaryOpSymbol$14 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L84, 'Bin
   return {
     $loc,
     token: "instanceof",
+    spaced: true,
     relational: true,
     special: true,
     negated: true
@@ -14851,6 +14898,7 @@ var BinaryOpSymbol$40 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
   return {
     $loc,
     token: $1,
+    spaced: true,
     relational: true,
     special: true
     // for typeof shorthand
@@ -14953,6 +15001,7 @@ var CoffeeOfOp$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(OmittedNegation, __,
   return {
     $loc,
     token: "in",
+    spaced: true,
     special: true,
     negated: true
   };
@@ -14974,6 +15023,7 @@ var NotOp$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)(
   return {
     $loc,
     token: "instanceof",
+    spaced: true,
     relational: true,
     special: true,
     negated: true
@@ -14983,6 +15033,7 @@ var NotOp$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(In), function($skip, $loc
   return {
     $loc,
     token: "in",
+    spaced: true,
     special: true,
     negated: true
   };
@@ -16584,12 +16635,15 @@ var ImportDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
   var imports = $5;
   var ws2 = $6;
   var from = $7;
+  const errors = [];
+  if (behavior?.error) errors.push(behavior.error);
   imports.specifiers.forEach((spec) => {
     state.operators.set(spec.binding.name, spec.behavior ?? behavior);
+    if (spec.behavior?.error) errors.push(spec.behavior.error);
   });
   return {
     type: "ImportDeclaration",
-    children: [i, trimFirstSpace(ws1), imports, ws2, from],
+    children: [i, ...errors, trimFirstSpace(ws1), imports, ws2, from],
     // omit $2 = Operator and $3 = OperatorBehavior
     imports,
     from
@@ -16632,12 +16686,15 @@ var ImportDeclaration$5 = (0, import_lib2.$TS)((0, import_lib2.$S)(ImpliedFromCl
   var behavior = $6;
   var ows = $7;
   var imports = $8;
+  const errors = [];
+  if (behavior?.error) errors.push(behavior.error);
   imports.specifiers.forEach((spec) => {
     state.operators.set(spec.binding.name, spec.behavior ?? behavior);
+    if (spec.behavior?.error) errors.push(spec.behavior.error);
   });
   return {
     type: "ImportDeclaration",
-    children: [i, iws, trimFirstSpace(ows), imports, fws, from],
+    children: [i, iws, ...errors, trimFirstSpace(ows), imports, fws, from],
     // omit Operator and OperatorBehavior
     imports,
     from
@@ -16819,7 +16876,7 @@ var OperatorImportSpecifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, Mod
   return {
     binding,
     behavior,
-    children: [$1, $2, $4, $5, $6, $7]
+    children: [$1, $2, $3?.error, $4, $5, $6, $7]
   };
 });
 var OperatorImportSpecifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, ImportedBinding, (0, import_lib2.$E)(OperatorBehavior), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
@@ -16828,7 +16885,7 @@ var OperatorImportSpecifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, Imp
   return {
     binding,
     behavior,
-    children: [$1, $2, $4]
+    children: [$1, $2, $3?.error, $4]
   };
 });
 var OperatorImportSpecifier$$ = [OperatorImportSpecifier$0, OperatorImportSpecifier$1];
@@ -17951,7 +18008,7 @@ function Import(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "Import", Import$0);
 }
 var In$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L180, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-  return { $loc, token: $1 };
+  return { $loc, token: $1, spaced: true };
 });
 function In(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "In", In$0);