@danielx/civet 0.11.6 → 0.11.7

package/dist/main.js

@@ -30,9 +30,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// node_modules/.pnpm/@danielx+hera@0.8.19/node_modules/@danielx/hera/dist/machine.js
+// node_modules/.pnpm/@danielx+hera@0.8.20/node_modules/@danielx/hera/dist/machine.js
 var require_machine = __commonJS({
-  "node_modules/.pnpm/@danielx+hera@0.8.19/node_modules/@danielx/hera/dist/machine.js"(exports2, module2) {
+  "node_modules/.pnpm/@danielx+hera@0.8.20/node_modules/@danielx/hera/dist/machine.js"(exports2, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -561,6 +561,7 @@ __export(lib_exports, {
   maybeRefAssignment: () => maybeRefAssignment,
   modifyString: () => modifyString,
   negateCondition: () => negateCondition,
+  parenthesizeExpression: () => parenthesizeExpression,
   precedenceCustomDefault: () => precedenceCustomDefault,
   precedenceStep: () => precedenceStep,
   prepend: () => prepend,
@@ -586,6 +587,7 @@ __export(lib_exports, {
   stripTrailingImplicitComma: () => stripTrailingImplicitComma,
   trimFirstSpace: () => trimFirstSpace,
   typeOfJSX: () => typeOfJSX,
+  typeSuffixForExpression: () => typeSuffixForExpression,
   wrapIIFE: () => wrapIIFE,
   wrapTypeInPromise: () => wrapTypeInPromise
 });
@@ -1845,7 +1847,14 @@ function populateRefs(statements) {
       name = `${base}${n}`;
     }
     names.add(name);
-    ref.children = ref.names = [name];
+    if (ref.$loc) {
+      const loc = ref.$loc;
+      delete ref.$loc;
+      ref.children = [{ $loc: loc, token: name }];
+      ref.names = [name];
+    } else {
+      ref.children = ref.names = [name];
+    }
   }
 }
 
@@ -1858,7 +1867,16 @@ function adjustAtBindings(statements, asThis = false) {
       const atBinding = binding.binding;
       atBinding.children.pop();
       atBinding.type = void 0;
-      binding.children.splice(1, 0, ref.id, ": this.", ref.base);
+      const atLoc = atBinding.at?.$loc;
+      let ref2;
+      if (atLoc) {
+        ref2 = { $loc: atLoc, token: "this." };
+      } else {
+        ref2 = "this.";
+      }
+      ;
+      const thisNode = ref2;
+      binding.children.splice(1, 0, ref.id, ": ", thisNode, ref.base);
       binding.type = "Property";
       binding.ref = void 0;
     } else {
@@ -1928,8 +1946,8 @@ function adjustBindingElements(elements) {
   };
 }
 function gatherSubbindings(node, subbindings = []) {
-  for (let ref2 = gatherRecursiveAll(node, ($) => $.subbinding != null), i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
-    const p = ref2[i3];
+  for (let ref3 = gatherRecursiveAll(node, ($) => $.subbinding != null), i3 = 0, len22 = ref3.length; i3 < len22; i3++) {
+    const p = ref3[i3];
     const { subbinding } = p;
     subbindings.push(", ", subbinding);
     gatherSubbindings(subbinding, subbindings);
@@ -1938,8 +1956,8 @@ function gatherSubbindings(node, subbindings = []) {
 }
 function simplifyBindingProperties(node) {
   const results = [];
-  for (let ref3 = gatherRecursiveAll(node, ($3) => $3.type === "BindingProperty"), i4 = 0, len3 = ref3.length; i4 < len3; i4++) {
-    const p = ref3[i4];
+  for (let ref4 = gatherRecursiveAll(node, ($3) => $3.type === "BindingProperty"), i4 = 0, len3 = ref4.length; i4 < len3; i4++) {
+    const p = ref4[i4];
     const { name, value } = p;
     if (value?.type === "NamedBindingPattern" && value.binding === name) {
       const [ws] = p.children;
@@ -1956,15 +1974,26 @@ function gatherBindingCode(statements, opts) {
   const splices = [];
   function insertRestSplices(s, p, thisAssignments2) {
     let m;
-    for (let ref4 = gatherRecursiveAll(
+    for (let ref5 = gatherRecursiveAll(
       s,
       (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding" || opts?.assignPins && (m = n.type, m === "PinPattern" || m === "PinProperty")
-    ), i5 = 0, len4 = ref4.length; i5 < len4; i5++) {
-      let n = ref4[i5];
+    ), i5 = 0, len4 = ref5.length; i5 < len4; i5++) {
+      let n = ref5[i5];
       if (n.type === "AtBinding") {
-        const { ref } = n;
+        const { ref, at } = n;
         const { id } = ref;
-        thisAssignments2.push([`this.${id} = `, ref]);
+        const atLoc = at?.$loc;
+        if (atLoc) {
+          ref.$loc = { pos: atLoc.pos + 1, length: id.length };
+          thisAssignments2.push([
+            { $loc: atLoc, token: "this." },
+            { $loc: ref.$loc, token: id },
+            " = ",
+            ref
+          ]);
+        } else {
+          thisAssignments2.push([`this.${id} = `, ref]);
+        }
         continue;
       }
       if (opts?.assignPins) {
@@ -1991,8 +2020,8 @@ function gatherBindingCode(statements, opts) {
         }
       }
       if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-        for (let ref5 = n.names, i6 = 0, len5 = ref5.length; i6 < len5; i6++) {
-          const id = ref5[i6];
+        for (let ref6 = n.names, i6 = 0, len5 = ref6.length; i6 < len5; i6++) {
+          const id = ref6[i6];
           thisAssignments2.push({
             type: "AssignmentExpression",
             children: [`this.${id} = `, id],
@@ -2010,8 +2039,8 @@ function gatherBindingCode(statements, opts) {
   return [splices, thisAssignments];
 }
 function arrayElementHasTrailingComma(elementNode) {
-  let ref6;
-  const lastChild = (ref6 = elementNode.children)[ref6.length - 1];
+  let ref7;
+  const lastChild = (ref7 = elementNode.children)[ref7.length - 1];
   return lastChild && lastChild[lastChild.length - 1]?.token === ",";
 }
 function gatherBindingPatternTypeSuffix(pattern) {
@@ -2023,8 +2052,8 @@ function gatherBindingPatternTypeSuffix(pattern) {
     case "ArrayBindingPattern": {
       {
         const results1 = [];
-        for (let ref7 = pattern.elements, i7 = 0, len6 = ref7.length; i7 < len6; i7++) {
-          const elem = ref7[i7];
+        for (let ref8 = pattern.elements, i7 = 0, len6 = ref8.length; i7 < len6; i7++) {
+          const elem = ref8[i7];
           let { typeSuffix, initializer } = elem;
           typeSuffix ??= elem.binding?.typeSuffix;
           if (typeSuffix) {
@@ -2065,8 +2094,8 @@ function gatherBindingPatternTypeSuffix(pattern) {
       {
         let restType;
         const results2 = [];
-        for (let ref8 = pattern.properties, i8 = 0, len7 = ref8.length; i8 < len7; i8++) {
-          const prop = ref8[i8];
+        for (let ref9 = pattern.properties, i8 = 0, len7 = ref9.length; i8 < len7; i8++) {
+          const prop = ref9[i8];
           let { typeSuffix, initializer } = prop;
           typeSuffix ??= prop.value?.typeSuffix;
           if (typeSuffix) {
@@ -2084,7 +2113,8 @@ function gatherBindingPatternTypeSuffix(pattern) {
             typeSuffix.children.unshift(typeSuffix.optional = "?");
           }
           switch (prop.type) {
-            case "BindingProperty": {
+            case "BindingProperty":
+            case "PinProperty": {
               const ws = prop.children.slice(0, prop.children.indexOf(prop.name));
               results2.push([...ws, prop.name, typeSuffix, prop.delim]);
               break;
@@ -2677,8 +2707,9 @@ function serialize(value, context) {
     if (typeof val === "string") {
       return JSON.stringify(val);
     } else if (typeof val === "number") {
-      if (Object.is(-0, val)) return "-0";
-      else return val.toString();
+      if (Object.is(-0, val)) {
+        return "-0";
+      } else return val.toString();
     } else if (typeof val === "boolean" || val == null) {
       return String(val);
     } else if (typeof val === "bigint") {
@@ -2938,7 +2969,14 @@ function implicitFunctionBlock(f) {
   if (followingOverloads(f).length) {
     f.ts = true;
   } else {
-    const block = makeEmptyBlock();
+    let ref1;
+    const lastChild = (ref1 = f.parameters?.children)?.[ref1.length - 1];
+    let ref2;
+    if (Array.isArray(lastChild)) {
+      ref2 = lastChild[lastChild.length - 1];
+    } else ref2 = lastChild;
+    const closeParen = ref2;
+    const block = makeEmptyBlock(closeParen?.$loc);
     block.parent = f;
     f.block = block;
     f.children.push(block);
@@ -3104,10 +3142,10 @@ function processReturnValue(func) {
     r.expression = ref;
     return r.children.splice(-1, 1, " ", ref);
   });
-  let ref1;
-  if (!((ref1 = block.children)[ref1.length - 2]?.type === "ReturnStatement")) {
-    let ref2;
-    const indent = getIndent((ref2 = block.expressions)[ref2.length - 1]);
+  let ref3;
+  if (!((ref3 = block.children)[ref3.length - 2]?.type === "ReturnStatement")) {
+    let ref4;
+    const indent = getIndent((ref4 = block.expressions)[ref4.length - 1]);
     block.expressions.push([
       indent,
       wrapWithReturn(ref, block, !indent)
@@ -3184,16 +3222,16 @@ function patternBindings(pattern) {
   function recurse(pattern2) {
     switch (pattern2.type) {
       case "ArrayBindingPattern": {
-        for (let ref3 = pattern2.elements, i2 = 0, len12 = ref3.length; i2 < len12; i2++) {
-          const element = ref3[i2];
+        for (let ref5 = pattern2.elements, i2 = 0, len12 = ref5.length; i2 < len12; i2++) {
+          const element = ref5[i2];
           recurse(element);
         }
         ;
         break;
       }
       case "ObjectBindingPattern": {
-        for (let ref4 = pattern2.properties, i3 = 0, len22 = ref4.length; i3 < len22; i3++) {
-          const property = ref4[i3];
+        for (let ref6 = pattern2.properties, i3 = 0, len22 = ref6.length; i3 < len22; i3++) {
+          const property = ref6[i3];
           recurse(property);
         }
         ;
@@ -3224,8 +3262,8 @@ function assignResults(node, collect) {
   switch (node.type) {
     case "BlockStatement": {
       if (node.expressions.length) {
-        let ref5;
-        assignResults((ref5 = node.expressions)[ref5.length - 1], collect);
+        let ref7;
+        assignResults((ref7 = node.expressions)[ref7.length - 1], collect);
       } else {
         node.expressions.push(["", collect("void 0"), ";"]);
         updateParentPointers(node);
@@ -3233,8 +3271,8 @@ function assignResults(node, collect) {
       return;
     }
     case "CaseBlock": {
-      for (let ref6 = node.clauses, i4 = 0, len3 = ref6.length; i4 < len3; i4++) {
-        const clause = ref6[i4];
+      for (let ref8 = node.clauses, i4 = 0, len3 = ref8.length; i4 < len3; i4++) {
+        const clause = ref8[i4];
         assignResults(clause, collect);
       }
       return;
@@ -3264,8 +3302,7 @@ function assignResults(node, collect) {
   if (exp.type === "LabelledStatement") {
     exp = exp.statement;
   }
-  let ref7;
-  let ref8;
+  let ref9;
   let m1;
   switch (exp.type) {
     case "BreakStatement":
@@ -3277,20 +3314,23 @@ function assignResults(node, collect) {
       return;
     }
     case "Declaration": {
-      let ref9;
-      if (exp.bindings?.length) {
-        ref9 = patternAsValue((ref7 = exp.bindings)[ref7.length - 1].pattern);
-      } else {
-        ref9 = "void 0";
+      {
+        let ref10;
+        if (exp.bindings?.length) {
+          let ref11;
+          ref10 = patternAsValue((ref11 = exp.bindings)[ref11.length - 1].pattern);
+        } else {
+          ref10 = "void 0";
+        }
+        ;
+        const value = ref10;
+        exp.children.push([
+          "",
+          [";", collect(value)]
+        ]);
+        updateParentPointers(exp);
+        return;
       }
-      ;
-      const value = ref9;
-      exp.children.push([
-        "",
-        [";", collect(value)]
-      ]);
-      updateParentPointers(exp);
-      return;
     }
     case "FunctionExpression": {
       if (exp.id) {
@@ -3314,7 +3354,7 @@ function assignResults(node, collect) {
       if (exp.expressions.some(isExit)) {
         return;
       }
-      assignResults((ref8 = exp.expressions)[ref8.length - 1], collect);
+      assignResults((ref9 = exp.expressions)[ref9.length - 1], collect);
       return;
     }
     case "IfStatement": {
@@ -3333,15 +3373,15 @@ function assignResults(node, collect) {
       return;
     }
     case "SwitchStatement": {
-      for (let ref10 = exp.caseBlock.clauses, i5 = 0, len4 = ref10.length; i5 < len4; i5++) {
-        const clause = ref10[i5];
+      for (let ref12 = exp.caseBlock.clauses, i5 = 0, len4 = ref12.length; i5 < len4; i5++) {
+        const clause = ref12[i5];
         assignResults(clause, collect);
       }
       return;
     }
     case "TryStatement": {
-      for (let ref11 = exp.blocks, i6 = 0, len5 = ref11.length; i6 < len5; i6++) {
-        const block = ref11[i6];
+      for (let ref13 = exp.blocks, i6 = 0, len5 = ref13.length; i6 < len5; i6++) {
+        const block = ref13[i6];
         assignResults(block, collect);
       }
       return;
@@ -3398,9 +3438,9 @@ function insertReturn(node) {
       insertReturn(node.block);
       if (!isExit(node.block)) {
         const comment = hasTrailingComment(node.block.expressions);
-        let ref12;
+        let ref14;
         node.block.expressions.push([
-          comment ? (ref12 = node.block.expressions)[ref12.length - 1][0] || "\n" : "",
+          comment ? (ref14 = node.block.expressions)[ref14.length - 1][0] || "\n" : "",
           wrapWithReturn(void 0, node, !comment)
         ]);
       }
@@ -3426,7 +3466,6 @@ function insertReturn(node) {
   if (exp.type === "LabelledStatement") {
     exp = exp.statement;
   }
-  let ref13;
   let m3;
   switch (exp.type) {
     case "BreakStatement":
@@ -3438,32 +3477,35 @@ function insertReturn(node) {
       return;
     }
     case "Declaration": {
-      let ref14;
-      if (exp.bindings?.length) {
-        ref14 = [" ", patternAsValue((ref13 = exp.bindings)[ref13.length - 1].pattern)];
-      } else {
-        ref14 = [];
-      }
-      ;
-      const value = ref14;
-      const parent = outer.parent;
-      const index = findChildIndex(parent?.expressions, outer);
-      assert.notEqual(index, -1, "Could not find declaration in parent");
-      parent.expressions.splice(index + 1, 0, [
-        "",
-        {
-          type: "ReturnStatement",
-          expression: value,
-          children: [
-            !(parent.expressions[index][2] === ";") ? ";" : void 0,
-            "return",
-            value
-          ],
-          parent: exp
+      {
+        let ref15;
+        if (exp.bindings?.length) {
+          let ref16;
+          ref15 = [" ", patternAsValue((ref16 = exp.bindings)[ref16.length - 1].pattern)];
+        } else {
+          ref15 = [];
         }
-      ]);
-      braceBlock(parent);
-      return;
+        ;
+        const value = ref15;
+        const parent = outer.parent;
+        const index = findChildIndex(parent?.expressions, outer);
+        assert.notEqual(index, -1, "Could not find declaration in parent");
+        parent.expressions.splice(index + 1, 0, [
+          "",
+          {
+            type: "ReturnStatement",
+            expression: value,
+            children: [
+              !(parent.expressions[index][2] === ";") ? ";" : void 0,
+              "return",
+              value
+            ],
+            parent: exp
+          }
+        ]);
+        braceBlock(parent);
+        return;
+      }
     }
     case "FunctionExpression": {
       if (exp.id) {
@@ -3492,8 +3534,9 @@ function insertReturn(node) {
     }
     case "IfStatement": {
       insertReturn(exp.then);
-      if (exp.else) insertReturn(exp.else.block);
-      else exp.children.push([
+      if (exp.else) {
+        insertReturn(exp.else.block);
+      } else exp.children.push([
         "",
         // NOTE: add a prefixed semicolon because the if block may not be braced
         wrapWithReturn(void 0, exp, true)
@@ -3505,15 +3548,15 @@ function insertReturn(node) {
       return;
     }
     case "SwitchStatement": {
-      for (let ref15 = exp.caseBlock.clauses, i7 = 0, len6 = ref15.length; i7 < len6; i7++) {
-        const clause = ref15[i7];
+      for (let ref17 = exp.caseBlock.clauses, i7 = 0, len6 = ref17.length; i7 < len6; i7++) {
+        const clause = ref17[i7];
         insertReturn(clause);
       }
       return;
     }
     case "TryStatement": {
-      for (let ref16 = exp.blocks, i8 = 0, len7 = ref16.length; i8 < len7; i8++) {
-        const block = ref16[i8];
+      for (let ref18 = exp.blocks, i8 = 0, len7 = ref18.length; i8 < len7; i8++) {
+        const block = ref18[i8];
         insertReturn(block);
       }
       return;
@@ -3765,9 +3808,9 @@ function iterationDefaultBody(statement) {
   }
   const reduction = statement.type === "ForStatement" && statement.reduction;
   function fillBlock(expression) {
-    let ref17;
+    let ref19;
     let m5;
-    if (m5 = (ref17 = block.expressions)[ref17.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) {
+    if (m5 = (ref19 = block.expressions)[ref19.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);
@@ -3837,8 +3880,8 @@ function processParams(f) {
   function append2(p) {
     (rest ? after : before).push(p);
   }
-  for (let ref18 = parameters.parameters, i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
-    const param = ref18[i9];
+  for (let ref20 = parameters.parameters, i9 = 0, len8 = ref20.length; i9 < len8; i9++) {
+    const param = ref20[i9];
     switch (param.type) {
       case "ThisType": {
         if (tt) {
@@ -3850,8 +3893,8 @@ function processParams(f) {
         } else {
           tt = trimFirstSpace(param);
           if (before.length || rest) {
-            let ref19;
-            let delim = (ref19 = tt.children)[ref19.length - 1];
+            let ref21;
+            let delim = (ref21 = tt.children)[ref21.length - 1];
             if (Array.isArray(delim)) {
               delim = delim[delim.length - 1];
             }
@@ -4041,14 +4084,14 @@ function processParams(f) {
       assert.notEqual(index2, -1, "Could not find constructor in class");
       index2 -= precedingOverloads(f).length;
       const fStatement = classExpressions[index2];
-      for (let ref20 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i10 = 0, len9 = ref20.length; i10 < len9; i10++) {
-        const parameter = ref20[i10];
+      for (let ref22 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i10 = 0, len9 = ref22.length; i10 < len9; i10++) {
+        const parameter = ref22[i10];
         const { accessModifier } = parameter;
         if (!(accessModifier || parameter.typeSuffix)) {
           continue;
         }
-        for (let ref21 = gatherRecursive(parameter, ($15) => $15.type === "AtBinding"), i11 = 0, len10 = ref21.length; i11 < len10; i11++) {
-          const binding = ref21[i11];
+        for (let ref23 = gatherRecursive(parameter, ($15) => $15.type === "AtBinding"), i11 = 0, len10 = ref23.length; i11 < len10; i11++) {
+          const binding = ref23[i11];
           const typeSuffix = binding.parent?.typeSuffix;
           if (!(accessModifier || typeSuffix)) {
             continue;
@@ -4086,8 +4129,8 @@ function processParams(f) {
       decl: "const"
     }));
   }
-  for (let ref22 = splices, i12 = 0, len11 = ref22.length; i12 < len11; i12++) {
-    const binding = ref22[i12];
+  for (let ref24 = splices, i12 = 0, len11 = ref24.length; i12 < len11; i12++) {
+    const binding = ref24[i12];
     assert.equal(binding.type, "PostRestBindingElements", "splice should be of type Binding");
     prefix.push(makeNode({
       type: "Declaration",
@@ -4140,8 +4183,8 @@ function processSignature(f) {
     if (f.async != null) {
       addAsync = true;
     } else {
-      for (let ref23 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i13 = 0, len12 = ref23.length; i13 < len12; i13++) {
-        const a = ref23[i13];
+      for (let ref25 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i13 = 0, len12 = ref25.length; i13 < len12; i13++) {
+        const a = ref25[i13];
         const i = findChildIndex(a.parent, a);
         a.parent.children.splice(i + 1, 0, {
           type: "Error",
@@ -4154,8 +4197,8 @@ function processSignature(f) {
     if (f.generator != null) {
       addGenerator = true;
     } else {
-      for (let ref24 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i14 = 0, len13 = ref24.length; i14 < len13; i14++) {
-        const y = ref24[i14];
+      for (let ref26 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i14 = 0, len13 = ref26.length; i14 < len13; i14++) {
+        const y = ref26[i14];
         const i = y.children.findIndex(($19) => $19.type === "Yield");
         y.children.splice(i + 1, 0, {
           type: "Error",
@@ -4164,8 +4207,8 @@ function processSignature(f) {
       }
     }
   }
-  for (let ref25 = [f, ...precedingOverloads(f)], i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
-    const overload = ref25[i15];
+  for (let ref27 = [f, ...precedingOverloads(f)], i15 = 0, len14 = ref27.length; i15 < len14; i15++) {
+    const overload = ref27[i15];
     if (addAsync && overload.async != null && !overload.async.length) {
       overload.async.push("async ");
       overload.signature.modifier.async = true;
@@ -4184,8 +4227,8 @@ function processSignature(f) {
   }
 }
 function processFunctions(statements, config2) {
-  for (let ref26 = gatherRecursiveAll(statements, ($20) => $20.type === "FunctionExpression" || $20.type === "ArrowFunction" || $20.type === "MethodDefinition"), i16 = 0, len15 = ref26.length; i16 < len15; i16++) {
-    const f = ref26[i16];
+  for (let ref28 = gatherRecursiveAll(statements, ($20) => $20.type === "FunctionExpression" || $20.type === "ArrowFunction" || $20.type === "MethodDefinition"), i16 = 0, len15 = ref28.length; i16 < len15; i16++) {
+    const f = ref28[i16];
     if (f.type === "FunctionExpression" || f.type === "MethodDefinition") {
       implicitFunctionBlock(f);
     }
@@ -4244,9 +4287,9 @@ function expressionizeIteration(exp) {
   }
   let done;
   if (!async) {
-    let ref27;
-    if ((ref27 = blockContainingStatement(exp)) && typeof ref27 === "object" && "block" in ref27 && "index" in ref27) {
-      const { block: parentBlock, index } = ref27;
+    let ref29;
+    if ((ref29 = blockContainingStatement(exp)) && typeof ref29 === "object" && "block" in ref29 && "index" in ref29) {
+      const { block: parentBlock, index } = ref29;
       statements[0][0] = parentBlock.expressions[index][0];
       parentBlock.expressions.splice(index, index + 1 - index, ...statements);
       updateParentPointers(parentBlock);
@@ -4263,8 +4306,8 @@ function expressionizeIteration(exp) {
   }
 }
 function processIterationExpressions(statements) {
-  for (let ref28 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i17 = 0, len16 = ref28.length; i17 < len16; i17++) {
-    const s = ref28[i17];
+  for (let ref30 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i17 = 0, len16 = ref30.length; i17 < len16; i17++) {
+    const s = ref30[i17];
     expressionizeIteration(s);
   }
 }
@@ -4291,9 +4334,9 @@ function processCoffeeDo(ws, expression) {
     for (let i18 = 0, len17 = parameterList.length; i18 < len17; i18++) {
       let parameter = parameterList[i18];
       if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
-        let ref29;
-        if (ref29 = parameter.initializer) {
-          const initializer = ref29;
+        let ref31;
+        if (ref31 = parameter.initializer) {
+          const initializer = ref31;
           args.push(initializer.expression, parameter.delim);
           parameter = {
             ...parameter,
@@ -4451,12 +4494,22 @@ function bracedBlock(block) {
   braceBlock(block);
   return block;
 }
-function makeEmptyBlock() {
+function makeEmptyBlock(loc) {
   const expressions = [];
+  let ref1;
+  if (loc) {
+    ref1 = { $loc: loc, token: "{" };
+  } else ref1 = "{";
+  const open = ref1;
+  let ref2;
+  if (loc) {
+    ref2 = { $loc: { pos: loc.pos + loc.length, length: 0 }, token: "}" };
+  } else ref2 = "}";
+  const close = ref2;
   return {
     type: "BlockStatement",
     expressions,
-    children: ["{", expressions, "}"],
+    children: [open, expressions, close],
     bare: false,
     empty: true
   };
@@ -4540,8 +4593,8 @@ function insertBlockStatements(block, index, ...statements) {
 }
 function processBlocks(statements) {
   insertSemicolon(statements);
-  for (let ref1 = gatherRecursive(statements, ($) => $.type === "BlockStatement"), i2 = 0, len12 = ref1.length; i2 < len12; i2++) {
-    const block = ref1[i2];
+  for (let ref3 = gatherRecursive(statements, ($) => $.type === "BlockStatement"), i2 = 0, len12 = ref3.length; i2 < len12; i2++) {
+    const block = ref3[i2];
     let m1;
     if (block.unwrapObject && block.expressions.length === 1 && (m1 = block.expressions[0][1], typeof m1 === "object" && m1 != null && "type" in m1 && m1.type === "ParenthesizedExpression" && "implicit" in m1 && m1.implicit === true && "expression" in m1 && typeof m1.expression === "object" && m1.expression != null && "type" in m1.expression && m1.expression.type === "ObjectExpression")) {
       const object = block.expressions[0][1].expression;
@@ -4559,9 +4612,9 @@ function processBlocks(statements) {
       }
       block.expressions[0][1] = block.expressions[0][1].expression;
       unbraceBlock(block);
-      for (let ref2 = object.properties, i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
+      for (let ref4 = object.properties, i3 = 0, len22 = ref4.length; i3 < len22; i3++) {
         const i = i3;
-        const prop = ref2[i3];
+        const prop = ref4[i3];
         let m2;
         if (m2 = prop.name, typeof m2 === "object" && m2 != null && "type" in m2 && m2.type === "ComputedPropertyName" && "implicit" in m2 && m2.implicit === true) {
           replaceNode(prop.name, prop.name.expression, prop);
@@ -5292,6 +5345,9 @@ function getPatternBlockPrefix(pattern, ref, decl = "const ", typeSuffix) {
   }
   let [splices, thisAssignments] = gatherBindingCode(pattern);
   const patternBindings2 = nonMatcherBindings(pattern);
+  if ("typeSuffix" in patternBindings2) {
+    typeSuffix = patternBindings2.typeSuffix;
+  }
   const subbindings = gatherSubbindings(patternBindings2);
   simplifyBindingProperties(patternBindings2);
   simplifyBindingProperties(subbindings);
@@ -5437,24 +5493,33 @@ function nonMatcherBindings(pattern) {
     case "ArrayBindingPattern":
     case "PostRestBindingElements": {
       const elements = elideMatchersFromArrayBindings(pattern.elements);
-      return makeNode({
+      const node = makeNode({
         ...pattern,
         elements,
         children: pattern.children.map(($9) => $9 === pattern.elements ? elements : $9)
       });
+      const typePattern = {
+        ...node,
+        typeSuffix: void 0,
+        elements: elements.filter((element) => element?.type != null)
+      };
+      node.typeSuffix = gatherBindingPatternTypeSuffix(typePattern).typeSuffix;
+      return node;
     }
     case "ObjectBindingPattern": {
       const properties = elideMatchersFromPropertyBindings(pattern.properties);
-      return makeNode({
+      return gatherBindingPatternTypeSuffix(makeNode({
         ...pattern,
+        typeSuffix: void 0,
         properties,
         children: pattern.children.map(($10) => $10 === pattern.properties ? properties : $10)
-      });
+      }));
     }
     case "NamedBindingPattern": {
       const bindings = nonMatcherBindings(pattern.pattern);
       return makeNode({
         ...pattern,
+        typeSuffix: bindings?.typeSuffix,
         subbinding: (m2 = bindings?.type, m2 === "ArrayBindingPattern" || m2 === "ObjectBindingPattern" || m2 === "Identifier") ? [bindings, " = ", pattern.binding] : void 0
       });
     }
@@ -6659,8 +6724,9 @@ function forRange(open, forDeclaration, range2, stepExp, close) {
     asc = stepValue > 0;
   }
   let ref2;
-  if (stepRef) ref2 = start;
-  else ref2 = maybeRef(start, "start");
+  if (stepRef) {
+    ref2 = start;
+  } else ref2 = maybeRef(start, "start");
   let startRef = ref2;
   let endRef = maybeRef(end, "end");
   const startRefDec = startRef !== start ? [startRef, " = ", start, ", "] : [];
@@ -8618,8 +8684,9 @@ function processTypes(node) {
         const space = getTrimmingSpace(unary);
         inplaceInsertTrimmingSpace(unary, "");
         let ref22;
-        if (unary.suffix.length) ref22 = unary;
-        else ref22 = unary.t;
+        if (unary.suffix.length) {
+          ref22 = unary;
+        } else ref22 = unary.t;
         const t = ref22;
         const arg = makeNode({
           type: "TypeArgument",
@@ -9147,17 +9214,20 @@ function processPlaceholders(statements) {
         break;
       }
       case "PipelineExpression": {
-        const i = findChildIndex(parent, ancestor);
-        let ref33;
-        if (i === 1) {
-          ref33 = ancestor === parent.children[i];
-        } else if (i === 2) {
-          ref33 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
-        } else {
-          ref33 = void 0;
+        {
+          const i = findChildIndex(parent, ancestor);
+          let ref33;
+          if (i === 1) {
+            ref33 = ancestor === parent.children[i];
+          } else if (i === 2) {
+            ref33 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
+          } else {
+            ref33 = void 0;
+          }
+          ;
+          outer = ref33;
         }
         ;
-        outer = ref33;
         break;
       }
       case "AssignmentExpression":
@@ -9467,7 +9537,9 @@ var grammar = {
   AfterReturnShorthand,
   Parameters,
   ShortArrowParameters,
+  ESArrowIdentifierParameters,
   ArrowParameters,
+  ThinArrowParameters,
   NonEmptyParameters,
   ParameterList,
   NestedParameterList,
@@ -10151,6 +10223,7 @@ var grammar = {
   CoffeeNotEnabled,
   CoffeeOfEnabled,
   CoffeePrototypeEnabled,
+  ESArrowFunctionEnabled,
   JSXCodeNestedEnabled,
   JSXCodeSameLineEnabled,
   ObjectIsEnabled,
@@ -11532,10 +11605,17 @@ function ConditionalExpression(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ConditionalExpression", ConditionalExpression$0);
 }
 var TernaryRest$0 = NestedTernaryRest;
-var TernaryRest$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(CoffeeBinaryExistentialEnabled), (0, import_lib2.$Y)((0, import_lib2.$EXPECT)($R5, "TernaryRest /[ \\t]/")), _, QuestionMark, MaybeNestedExpression, __, Colon, MaybeNestedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+var TernaryRest$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(CoffeeBinaryExistentialEnabled), (0, import_lib2.$Y)((0, import_lib2.$EXPECT)($R5, "TernaryRest /[ \\t]/")), _, QuestionMark, PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Expression, _, Colon, Nested, Expression)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+  var thenelse = $6;
+  if (!thenelse) {
+    return $skip;
+  }
+  return [$3, $4, ...thenelse];
+});
+var TernaryRest$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(CoffeeBinaryExistentialEnabled), (0, import_lib2.$Y)((0, import_lib2.$EXPECT)($R5, "TernaryRest /[ \\t]/")), _, QuestionMark, MaybeNestedExpression, __, Colon, MaybeNestedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
   return $0.slice(2);
 });
-var TernaryRest$$ = [TernaryRest$0, TernaryRest$1];
+var TernaryRest$$ = [TernaryRest$0, TernaryRest$1, TernaryRest$2];
 function TernaryRest(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "TernaryRest", TernaryRest$$);
 }
@@ -11554,27 +11634,37 @@ var ShortCircuitExpression$0 = BinaryOpExpression;
 function ShortCircuitExpression(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ShortCircuitExpression", ShortCircuitExpression$0);
 }
-var PipelineExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PipelineAllowed, (0, import_lib2.$E)(_), PipelineHeadItem, PipelineExpressionBody), function($skip, $loc, $0, $1, $2, $3, $4) {
+var PipelineExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PipelineAllowed, (0, import_lib2.$E)(_), PipelineHeadItem, PipelineExpressionBody, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var ws = $2;
   var head = $3;
   var body = $4;
+  var trailing = $5;
+  let node;
   if (head.type === "ArrowFunction" && head.ampersandBlock) {
     const expressions = [{
       type: "PipelineExpression",
       children: [ws, head.block.expressions[0], body]
     }];
     const block = { ...head.block, expressions, children: [expressions] };
-    return {
+    node = {
       ...head,
       block,
       body: expressions,
       children: [...head.children.slice(0, -1), block]
     };
+  } else {
+    node = {
+      type: "PipelineExpression",
+      children: [ws, head, body]
+    };
   }
-  return {
-    type: "PipelineExpression",
-    children: [ws, head, body]
-  };
+  if (trailing) {
+    return processCallMemberExpression({
+      type: "CallExpression",
+      children: [node, ...trailing]
+    });
+  }
+  return node;
 });
 function PipelineExpression(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "PipelineExpression", PipelineExpression$0);
@@ -12869,29 +12959,56 @@ function Parameters(ctx, state2) {
 var ShortArrowParameters$0 = (0, import_lib2.$TV)((0, import_lib2.$C)(ObjectBindingPattern, ArrayBindingPattern), function($skip, $loc, $0, $1) {
   var binding = $0;
   const { typeSuffix } = binding;
-  return {
+  const parameter = {
     type: "Parameter",
     children: [binding, typeSuffix],
     names: binding.names,
     typeSuffix
   };
+  const parameters = [parameter];
+  return {
+    type: "Parameters",
+    children: ["(", parameters, ")"],
+    parameters
+  };
 });
 function ShortArrowParameters(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ShortArrowParameters", ShortArrowParameters$0);
 }
-var ArrowParameters$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ShortArrowParameters), function($skip, $loc, $0, $1) {
-  const parameters = [$1];
+var ESArrowIdentifierParameters$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ESArrowFunctionEnabled, Identifier), function($skip, $loc, $0, $1, $2) {
+  var id = $2;
+  const parameter = {
+    type: "Parameter",
+    children: [id],
+    names: id.names,
+    binding: id,
+    typeSuffix: void 0,
+    initializer: void 0,
+    delim: void 0
+  };
+  const parameters = [parameter];
   return {
     type: "Parameters",
     children: ["(", parameters, ")"],
     parameters
   };
 });
-var ArrowParameters$1 = Parameters;
-var ArrowParameters$$ = [ArrowParameters$0, ArrowParameters$1];
+function ESArrowIdentifierParameters(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "ESArrowIdentifierParameters", ESArrowIdentifierParameters$0);
+}
+var ArrowParameters$0 = ESArrowIdentifierParameters;
+var ArrowParameters$1 = ShortArrowParameters;
+var ArrowParameters$2 = Parameters;
+var ArrowParameters$$ = [ArrowParameters$0, ArrowParameters$1, ArrowParameters$2];
 function ArrowParameters(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ArrowParameters", ArrowParameters$$);
 }
+var ThinArrowParameters$0 = ShortArrowParameters;
+var ThinArrowParameters$1 = Parameters;
+var ThinArrowParameters$$ = [ThinArrowParameters$0, ThinArrowParameters$1];
+function ThinArrowParameters(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "ThinArrowParameters", ThinArrowParameters$$);
+}
 var NonEmptyParameters$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(TypeParameters), OpenParen, ParameterList, (0, import_lib2.$S)(__, CloseParen)), function($skip, $loc, $0, $1, $2, $3, $4) {
   var tp = $1;
   var open = $2;
@@ -13001,11 +13118,13 @@ function BindingIdentifier(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "BindingIdentifier", BindingIdentifier$0);
 }
 var NWBindingIdentifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(At, AtIdentifierRef), function($skip, $loc, $0, $1, $2) {
+  var at = $1;
   var ref = $2;
   return {
     type: "AtBinding",
     children: [ref],
     ref,
+    at,
     names: []
   };
 });
@@ -13044,7 +13163,8 @@ var PinPattern$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Caret, IdentifierNam
   return {
     type: "PinPattern",
     children: [expression],
-    expression
+    expression,
+    typeSuffix: typeSuffixForExpression(expression)
   };
 });
 var PinPattern$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Caret, SingleLineExpressionWithIndentedApplicationForbidden), function($skip, $loc, $0, $1, $2) {
@@ -13052,7 +13172,8 @@ var PinPattern$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Caret, SingleLineExp
   return {
     type: "PinPattern",
     children: [expression],
-    expression
+    expression,
+    typeSuffix: typeSuffixForExpression(expression)
   };
 });
 var PinPattern$2 = (0, import_lib2.$TV)(ActualMemberExpression, function($skip, $loc, $0, $1) {
@@ -13060,7 +13181,8 @@ var PinPattern$2 = (0, import_lib2.$TV)(ActualMemberExpression, function($skip,
   return {
     type: "PinPattern",
     children: [expression],
-    expression
+    expression,
+    typeSuffix: typeSuffixForExpression(expression)
   };
 });
 var PinPattern$3 = (0, import_lib2.$TV)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R15, "PinPattern /[+-]/"), NumericLiteral), function($skip, $loc, $0, $1) {
@@ -13068,7 +13190,8 @@ var PinPattern$3 = (0, import_lib2.$TV)((0, import_lib2.$S)((0, import_lib2.$EXP
   return {
     type: "PinPattern",
     children: [expression],
-    expression
+    expression,
+    typeSuffix: typeSuffixForExpression(expression)
   };
 });
 var PinPattern$4 = (0, import_lib2.$TV)(Undefined, function($skip, $loc, $0, $1) {
@@ -13076,7 +13199,8 @@ var PinPattern$4 = (0, import_lib2.$TV)(Undefined, function($skip, $loc, $0, $1)
   return {
     type: "PinPattern",
     children: [expression],
-    expression
+    expression,
+    typeSuffix: typeSuffixForExpression(expression)
   };
 });
 var PinPattern$$ = [PinPattern$0, PinPattern$1, PinPattern$2, PinPattern$3, PinPattern$4];
@@ -13304,7 +13428,8 @@ var BindingProperty$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
     value: {
       type: "PinPattern",
       children: [binding],
-      expression: binding
+      expression: binding,
+      typeSuffix: typeSuffixForExpression(binding)
     }
   };
 });
@@ -13822,7 +13947,7 @@ var OperatorAssociativity$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, impor
 function OperatorAssociativity(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "OperatorAssociativity", OperatorAssociativity$0);
 }
-var ThinArrowFunction$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Async, _)), ArrowParameters, (0, import_lib2.$E)(ReturnTypeSuffix), (0, import_lib2.$E)(_), ThinArrow, (0, import_lib2.$C)(BracedObjectSingleLineStatements, NoCommaBracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var ThinArrowFunction$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Async, _)), ThinArrowParameters, (0, import_lib2.$E)(ReturnTypeSuffix), (0, import_lib2.$E)(_), ThinArrow, (0, import_lib2.$C)(BracedObjectSingleLineStatements, NoCommaBracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var async = $1;
   var parameters = $2;
   var returnType = $3;
@@ -15217,6 +15342,17 @@ var PropertyDefinition$5 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
     }
   }
   if (name[0] === "#") name = name.slice(1);
+  if (!pre.length && post?.token === "?" && value.type === "Identifier") {
+    const dots = { $loc, token: "..." };
+    const paren = parenthesizeExpression({ children: ["(", value, " != null) && {", name, "}"] });
+    return {
+      type: "SpreadProperty",
+      children: [ws, dots, paren],
+      names: value.names,
+      dots,
+      value: paren
+    };
+  }
   return {
     type: "Property",
     children: [ws, name, ": ", processUnaryExpression(pre, value, post)],
@@ -15230,7 +15366,22 @@ var PropertyDefinition$$ = [PropertyDefinition$0, PropertyDefinition$1, Property
 function PropertyDefinition(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "PropertyDefinition", PropertyDefinition$$);
 }
-var NamedProperty$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PropertyName, (0, import_lib2.$E)(_), Colon, PostfixedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
+var NamedProperty$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PropertyName, (0, import_lib2.$EXPECT)($L6, 'NamedProperty "?"'), (0, import_lib2.$E)(_), Colon, (0, import_lib2.$E)(_), PostfixedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+  var name = $1;
+  var exp = $6;
+  const { ref, refAssignment } = maybeRefAssignment(exp);
+  const checkExp = refAssignment ? parenthesizeExpression(refAssignment) : exp;
+  const dots = { $loc, token: "..." };
+  const paren = parenthesizeExpression({ children: [checkExp, " != null ? {", name, ": ", ref, "} : {}"] });
+  return {
+    type: "SpreadProperty",
+    children: [dots, paren],
+    names: exp.names || [],
+    dots,
+    value: paren
+  };
+});
+var NamedProperty$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(PropertyName, (0, import_lib2.$E)(_), Colon, PostfixedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
   var name = $1;
   var exp = $4;
   return {
@@ -15241,8 +15392,9 @@ var NamedProperty$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PropertyName, (0,
     value: exp
   };
 });
+var NamedProperty$$ = [NamedProperty$0, NamedProperty$1];
 function NamedProperty(ctx, state2) {
-  return (0, import_lib2.$EVENT)(ctx, state2, "NamedProperty", NamedProperty$0);
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "NamedProperty", NamedProperty$$);
 }
 var SnugNamedProperty$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PropertyName, Colon, MaybeNestedExpression, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement), (0, import_lib2.$Y)((0, import_lib2.$S)(Nested, NamedProperty))))), function($skip, $loc, $0, $1, $2, $3, $4) {
   var name = $1;
@@ -22066,6 +22218,13 @@ var CoffeePrototypeEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0
 function CoffeePrototypeEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeePrototypeEnabled", CoffeePrototypeEnabled$0);
 }
+var ESArrowFunctionEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'ESArrowFunctionEnabled ""'), function($skip, $loc, $0, $1) {
+  if (config.esArrowFunction) return;
+  return $skip;
+});
+function ESArrowFunctionEnabled(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "ESArrowFunctionEnabled", ESArrowFunctionEnabled$0);
+}
 var JSXCodeNestedEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'JSXCodeNestedEnabled ""'), function($skip, $loc, $0, $1) {
   if (config.jsxCodeNested) return;
   return $skip;
@@ -22138,6 +22297,7 @@ var Reset$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'Reset ""'), fu
     globals: [],
     iife: false,
     implicitReturns: true,
+    esArrowFunction: false,
     jsxCode: false,
     objectIs: false,
     react: false,
@@ -22189,6 +22349,17 @@ var Reset$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'Reset ""'), fu
       return;
     }
   });
+  Object.defineProperty(config, "esCompat", {
+    set(b) {
+      for (const option of [
+        "esArrowFunction"
+      ]) {
+        config[option] = b;
+      }
+      config.implicitReturns = !b;
+      return;
+    }
+  });
   Object.defineProperty(config, "jsxCode", {
     set(b) {
       for (const option of ["jsxCodeNested", "jsxCodeSameLine"]) {
@@ -22778,8 +22949,9 @@ var VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
 var encodeVlq = function(value) {
   let answer = "";
   let ref2;
-  if (value < 0) ref2 = 1;
-  else ref2 = 0;
+  if (value < 0) {
+    ref2 = 1;
+  } else ref2 = 0;
   const signBit = ref2;
   let valueToEncode = (Math.abs(value) << 1) + signBit;
   while (valueToEncode || !answer) {
@@ -22887,6 +23059,9 @@ var remapPosition = (position, sourcemapLines) => {
   }
 };
 
+// source/main.civet
+var import_node_path2 = require("node:path");
+
 // source/state-cache.civet
 var StateCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -23213,8 +23388,11 @@ ${counts}`;
       }
       if (options.inlineMap) {
         const outputFilename = options.outputFilename ?? (options.js ? filename2 + ".jsx" : filename2 + ".tsx");
+        const outDir = (0, import_node_path2.dirname)(outputFilename);
+        options.sourceMap.sourceFileName = (0, import_node_path2.relative)(outDir, options.sourceMap.sourceFileName) || options.sourceMap.sourceFileName;
+        const relativeOut = (0, import_node_path2.relative)(outDir, outputFilename) || outputFilename;
         return `${code}
-${options.sourceMap.comment(outputFilename)}`;
+${options.sourceMap.comment(relativeOut)}`;
       } else {
         return { code, sourceMap: options.sourceMap };
       }