@danielx/civet 0.11.6 → 0.11.7

package/dist/browser.js

@@ -35,9 +35,9 @@ var Civet = (() => {
     mod
   )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), 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"(exports, module) {
+    "node_modules/.pnpm/@danielx+hera@0.8.20/node_modules/@danielx/hera/dist/machine.js"(exports, module) {
       "use strict";
       var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
         for (var name in all)
@@ -384,6 +384,9 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
   function resolve(path) {
     return path;
   }
+  function relative(_from, to) {
+    return to;
+  }
   function createRequire(path) {
     return (id) => {
       throw new ReferenceError(
@@ -397,6 +400,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
       browser_shim_default = {
         dirname,
         resolve,
+        relative,
         createRequire
       };
     }
@@ -480,6 +484,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     maybeRefAssignment: () => maybeRefAssignment,
     modifyString: () => modifyString,
     negateCondition: () => negateCondition,
+    parenthesizeExpression: () => parenthesizeExpression,
     precedenceCustomDefault: () => precedenceCustomDefault,
     precedenceStep: () => precedenceStep,
     prepend: () => prepend,
@@ -505,6 +510,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     stripTrailingImplicitComma: () => stripTrailingImplicitComma,
     trimFirstSpace: () => trimFirstSpace,
     typeOfJSX: () => typeOfJSX,
+    typeSuffixForExpression: () => typeSuffixForExpression,
     wrapIIFE: () => wrapIIFE,
     wrapTypeInPromise: () => wrapTypeInPromise
   });
@@ -1433,7 +1439,11 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
       let n = 0, name = base;
       for (; names.has(name); )
         n++, name = `${base}${n}`;
-      names.add(name), ref.children = ref.names = [name];
+      if (names.add(name), ref.$loc) {
+        let loc = ref.$loc;
+        delete ref.$loc, ref.children = [{ $loc: loc, token: name }], ref.names = [name];
+      } else
+        ref.children = ref.names = [name];
     }
   }
 
@@ -1443,7 +1453,11 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
       let binding = ref1[i1], { ref } = binding;
       if (asThis) {
         let atBinding = binding.binding;
-        atBinding.children.pop(), atBinding.type = void 0, binding.children.splice(1, 0, ref.id, ": this.", ref.base), binding.type = "Property", binding.ref = void 0;
+        atBinding.children.pop(), atBinding.type = void 0;
+        let atLoc = atBinding.at?.$loc, ref2;
+        atLoc ? ref2 = { $loc: atLoc, token: "this." } : ref2 = "this.";
+        let thisNode = ref2;
+        binding.children.splice(1, 0, ref.id, ": ", thisNode, ref.base), binding.type = "Property", binding.ref = void 0;
       } else
         ref.names[0] !== ref.base && binding.children.unshift(ref.base, ": ");
     }
@@ -1498,16 +1512,16 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     };
   }
   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;
+    for (let ref3 = gatherRecursiveAll(node, ($) => $.subbinding != null), i3 = 0, len22 = ref3.length; i3 < len22; i3++) {
+      let p = ref3[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;
+    for (let ref4 = gatherRecursiveAll(node, ($3) => $3.type === "BindingProperty"), i4 = 0, len3 = ref4.length; i4 < len3; i4++) {
+      let p = ref4[i4], { name, value } = p;
       if (value?.type === "NamedBindingPattern" && value.binding === name) {
         let [ws] = p.children;
         results.push(p.children = [ws, name, p.delim]);
@@ -1520,14 +1534,19 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     let thisAssignments = [], 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") {
-          let { ref } = n, { id } = ref;
-          thisAssignments2.push([`this.${id} = `, ref]);
+          let { ref, at } = n, { id } = ref, atLoc = at?.$loc;
+          atLoc ? (ref.$loc = { pos: atLoc.pos + 1, length: id.length }, thisAssignments2.push([
+            { $loc: atLoc, token: "this." },
+            { $loc: ref.$loc, token: id },
+            " = ",
+            ref
+          ])) : thisAssignments2.push([`this.${id} = `, ref]);
           continue;
         }
         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")) {
@@ -1544,8 +1563,8 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
           continue;
         }
         if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-          for (let ref5 = n.names, i6 = 0, len5 = ref5.length; i6 < len5; i6++) {
-            let id = ref5[i6];
+          for (let ref6 = n.names, i6 = 0, len5 = ref6.length; i6 < len5; i6++) {
+            let id = ref6[i6];
             thisAssignments2.push({
               type: "AssignmentExpression",
               children: [`this.${id} = `, id],
@@ -1561,7 +1580,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     return insertRestSplices(statements, splices, thisAssignments), [splices, thisAssignments];
   }
   function arrayElementHasTrailingComma(elementNode) {
-    let ref6, lastChild = (ref6 = elementNode.children)[ref6.length - 1];
+    let ref7, lastChild = (ref7 = elementNode.children)[ref7.length - 1];
     return lastChild && lastChild[lastChild.length - 1]?.token === ",";
   }
   function gatherBindingPatternTypeSuffix(pattern) {
@@ -1572,8 +1591,8 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
       case "ArrayBindingPattern": {
         {
           let results1 = [];
-          for (let ref7 = pattern.elements, i7 = 0, len6 = ref7.length; i7 < len6; i7++) {
-            let elem = ref7[i7], { typeSuffix, initializer } = elem;
+          for (let ref8 = pattern.elements, i7 = 0, len6 = ref8.length; i7 < len6; i7++) {
+            let elem = ref8[i7], { typeSuffix, initializer } = elem;
             typeSuffix ??= elem.binding?.typeSuffix, typeSuffix && count++, initializer != null && (typeSuffix ??= typeSuffixForExpression(trimFirstSpace(initializer.expression)));
             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", results1.push(typeElement);
@@ -1594,14 +1613,15 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
       case "ObjectBindingPattern": {
         {
           let restType, results2 = [];
-          for (let ref8 = pattern.properties, i8 = 0, len7 = ref8.length; i8 < len7; i8++) {
-            let prop = ref8[i8], { typeSuffix, initializer } = prop;
+          for (let ref9 = pattern.properties, i8 = 0, len7 = ref9.length; i8 < len7; i8++) {
+            let prop = ref9[i8], { typeSuffix, initializer } = prop;
             switch (typeSuffix ??= prop.value?.typeSuffix, typeSuffix && count++, initializer != null && (typeSuffix ??= typeSuffixForExpression(trimFirstSpace(initializer.expression))), typeSuffix ??= {
               type: "TypeSuffix",
               ts: !0,
               children: [": unknown"]
             }, prop.initializer && !typeSuffix.optional && typeSuffix.children.unshift(typeSuffix.optional = "?"), prop.type) {
-              case "BindingProperty": {
+              case "BindingProperty":
+              case "PinProperty": {
                 let ws = prop.children.slice(0, prop.children.indexOf(prop.name));
                 results2.push([...ws, prop.name, typeSuffix, prop.delim]);
                 break;
@@ -2330,7 +2350,9 @@ ${js}`
       if (followingOverloads(f).length)
         f.ts = !0;
       else {
-        let block = makeEmptyBlock();
+        let ref1, lastChild = (ref1 = f.parameters?.children)?.[ref1.length - 1], ref2;
+        Array.isArray(lastChild) ? ref2 = lastChild[lastChild.length - 1] : ref2 = lastChild;
+        let block = makeEmptyBlock(ref2?.$loc);
         block.parent = f, f.block = block, f.children.push(block), f.ts = !1;
       }
   }
@@ -2424,9 +2446,9 @@ ${js}`
       block,
       (r) => r.type === "ReturnStatement" && !r.expression
     ).forEach((r) => (r.expression = ref, r.children.splice(-1, 1, " ", ref)));
-    let ref1;
-    if ((ref1 = block.children)[ref1.length - 2]?.type !== "ReturnStatement") {
-      let ref2, indent = getIndent((ref2 = block.expressions)[ref2.length - 1]);
+    let ref3;
+    if ((ref3 = block.children)[ref3.length - 2]?.type !== "ReturnStatement") {
+      let ref4, indent = getIndent((ref4 = block.expressions)[ref4.length - 1]);
       block.expressions.push([
         indent,
         wrapWithReturn(ref, block, !indent)
@@ -2488,15 +2510,15 @@ ${js}`
     function recurse(pattern2) {
       switch (pattern2.type) {
         case "ArrayBindingPattern": {
-          for (let ref3 = pattern2.elements, i2 = 0, len12 = ref3.length; i2 < len12; i2++) {
-            let element = ref3[i2];
+          for (let ref5 = pattern2.elements, i2 = 0, len12 = ref5.length; i2 < len12; i2++) {
+            let element = ref5[i2];
             recurse(element);
           }
           break;
         }
         case "ObjectBindingPattern": {
-          for (let ref4 = pattern2.properties, i3 = 0, len22 = ref4.length; i3 < len22; i3++) {
-            let property = ref4[i3];
+          for (let ref6 = pattern2.properties, i3 = 0, len22 = ref6.length; i3 < len22; i3++) {
+            let property = ref6[i3];
             recurse(property);
           }
           break;
@@ -2526,15 +2548,15 @@ ${js}`
     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);
         return;
       }
       case "CaseBlock": {
-        for (let ref6 = node.clauses, i4 = 0, len3 = ref6.length; i4 < len3; i4++) {
-          let clause = ref6[i4];
+        for (let ref8 = node.clauses, i4 = 0, len3 = ref8.length; i4 < len3; i4++) {
+          let clause = ref8[i4];
           assignResults(clause, collect);
         }
         return;
@@ -2554,7 +2576,7 @@ ${js}`
     exp = exp;
     let outer = exp;
     exp.type === "LabelledStatement" && (exp = exp.statement);
-    let ref7, ref8, m1;
+    let ref9, m1;
     switch (exp.type) {
       case "BreakStatement":
       case "ContinueStatement":
@@ -2564,9 +2586,13 @@ ${js}`
       case "ThrowStatement":
         return;
       case "Declaration": {
-        let ref9;
-        exp.bindings?.length ? ref9 = patternAsValue((ref7 = exp.bindings)[ref7.length - 1].pattern) : ref9 = "void 0";
-        let value = ref9;
+        let ref10;
+        if (exp.bindings?.length) {
+          let ref11;
+          ref10 = patternAsValue((ref11 = exp.bindings)[ref11.length - 1].pattern);
+        } else
+          ref10 = "void 0";
+        let value = ref10;
         exp.children.push([
           "",
           [";", collect(value)]
@@ -2593,7 +2619,7 @@ ${js}`
       case "BlockStatement": {
         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": {
@@ -2605,15 +2631,15 @@ ${js}`
         return;
       }
       case "SwitchStatement": {
-        for (let ref10 = exp.caseBlock.clauses, i5 = 0, len4 = ref10.length; i5 < len4; i5++) {
-          let clause = ref10[i5];
+        for (let ref12 = exp.caseBlock.clauses, i5 = 0, len4 = ref12.length; i5 < len4; i5++) {
+          let clause = ref12[i5];
           assignResults(clause, collect);
         }
         return;
       }
       case "TryStatement": {
-        for (let ref11 = exp.blocks, i6 = 0, len5 = ref11.length; i6 < len5; i6++) {
-          let block = ref11[i6];
+        for (let ref13 = exp.blocks, i6 = 0, len5 = ref13.length; i6 < len5; i6++) {
+          let block = ref13[i6];
           assignResults(block, collect);
         }
         return;
@@ -2656,9 +2682,9 @@ ${js}`
           assert.notEqual(breakIndex, -1, "Could not find break in when clause"), node.children.splice(breakIndex, 1), node.break = void 0;
         }
         if (insertReturn(node.block), !isExit(node.block)) {
-          let comment = hasTrailingComment(node.block.expressions), ref12;
+          let comment = hasTrailingComment(node.block.expressions), ref14;
           node.block.expressions.push([
-            comment ? (ref12 = node.block.expressions)[ref12.length - 1][0] || `
+            comment ? (ref14 = node.block.expressions)[ref14.length - 1][0] || `
 ` : "",
             wrapWithReturn(void 0, node, !comment)
           ]);
@@ -2676,7 +2702,7 @@ ${js}`
       return;
     let outer = exp;
     exp.type === "LabelledStatement" && (exp = exp.statement);
-    let ref13, m3;
+    let m3;
     switch (exp.type) {
       case "BreakStatement":
       case "ContinueStatement":
@@ -2686,9 +2712,13 @@ ${js}`
       case "ThrowStatement":
         return;
       case "Declaration": {
-        let ref14;
-        exp.bindings?.length ? ref14 = [" ", patternAsValue((ref13 = exp.bindings)[ref13.length - 1].pattern)] : ref14 = [];
-        let value = ref14, parent = outer.parent, index = findChildIndex(parent?.expressions, outer);
+        let ref15;
+        if (exp.bindings?.length) {
+          let ref16;
+          ref15 = [" ", patternAsValue((ref16 = exp.bindings)[ref16.length - 1].pattern)];
+        } else
+          ref15 = [];
+        let value = ref15, parent = outer.parent, index = findChildIndex(parent?.expressions, outer);
         assert.notEqual(index, -1, "Could not find declaration in parent"), parent.expressions.splice(index + 1, 0, [
           "",
           {
@@ -2739,15 +2769,15 @@ ${js}`
         return;
       }
       case "SwitchStatement": {
-        for (let ref15 = exp.caseBlock.clauses, i7 = 0, len6 = ref15.length; i7 < len6; i7++) {
-          let clause = ref15[i7];
+        for (let ref17 = exp.caseBlock.clauses, i7 = 0, len6 = ref17.length; i7 < len6; i7++) {
+          let clause = ref17[i7];
           insertReturn(clause);
         }
         return;
       }
       case "TryStatement": {
-        for (let ref16 = exp.blocks, i8 = 0, len7 = ref16.length; i8 < len7; i8++) {
-          let block = ref16[i8];
+        for (let ref18 = exp.blocks, i8 = 0, len7 = ref18.length; i8 < len7; i8++) {
+          let block = ref18[i8];
           insertReturn(block);
         }
         return;
@@ -2925,8 +2955,8 @@ ${js}`
       return !1;
     let reduction = statement.type === "ForStatement" && statement.reduction;
     function fillBlock(expression) {
-      let ref17, m5;
-      return 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 === !0 && block.expressions.pop(), block.expressions.push(expression), block.empty = !1, braceBlock(block);
+      let ref19, m5;
+      return 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 === !0 && block.expressions.pop(), block.expressions.push(expression), block.empty = !1, braceBlock(block);
     }
     if (reduction)
       switch (reduction.subtype) {
@@ -2972,8 +3002,8 @@ ${js}`
     function append2(p) {
       (rest ? after : before).push(p);
     }
-    for (let ref18 = parameters.parameters, i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
-      let param = ref18[i9];
+    for (let ref20 = parameters.parameters, i9 = 0, len8 = ref20.length; i9 < len8; i9++) {
+      let param = ref20[i9];
       switch (param.type) {
         case "ThisType": {
           if (tt)
@@ -2982,7 +3012,7 @@ ${js}`
               message: "Only one typed this parameter is allowed"
             }), append2(param);
           else if (tt = trimFirstSpace(param), before.length || rest) {
-            let ref19, delim = (ref19 = tt.children)[ref19.length - 1];
+            let ref21, delim = (ref21 = tt.children)[ref21.length - 1];
             Array.isArray(delim) && (delim = delim[delim.length - 1]), typeof delim == "object" && delim != null && "token" in delim && delim.token === "," || (tt = {
               ...tt,
               children: [...tt.children, ", "]
@@ -3110,11 +3140,11 @@ ${js}`
         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"), index2 -= precedingOverloads(f).length;
         let fStatement = classExpressions[index2];
-        for (let ref20 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i10 = 0, len9 = ref20.length; i10 < len9; i10++) {
-          let parameter = ref20[i10], { accessModifier } = parameter;
+        for (let ref22 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i10 = 0, len9 = ref22.length; i10 < len9; i10++) {
+          let parameter = ref22[i10], { accessModifier } = parameter;
           if (accessModifier || parameter.typeSuffix)
-            for (let ref21 = gatherRecursive(parameter, ($15) => $15.type === "AtBinding"), i11 = 0, len10 = ref21.length; i11 < len10; i11++) {
-              let binding = ref21[i11], typeSuffix = binding.parent?.typeSuffix;
+            for (let ref23 = gatherRecursive(parameter, ($15) => $15.type === "AtBinding"), i11 = 0, len10 = ref23.length; i11 < len10; i11++) {
+              let binding = ref23[i11], typeSuffix = binding.parent?.typeSuffix;
               if (!(accessModifier || typeSuffix))
                 continue;
               parameter.accessModifier && (replaceNode(parameter.accessModifier, void 0), parameter.accessModifier = void 0);
@@ -3140,8 +3170,8 @@ ${js}`
       bindings: [],
       decl: "const"
     }));
-    for (let ref22 = splices, i12 = 0, len11 = ref22.length; i12 < len11; i12++) {
-      let binding = ref22[i12];
+    for (let ref24 = splices, i12 = 0, len11 = ref24.length; i12 < len11; i12++) {
+      let binding = ref24[i12];
       assert.equal(binding.type, "PostRestBindingElements", "splice should be of type Binding"), prefix.push(makeNode({
         type: "Declaration",
         children: ["let ", binding],
@@ -3179,8 +3209,8 @@ ${js}`
       if (f.async != null)
         addAsync = !0;
       else
-        for (let ref23 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i13 = 0, len12 = ref23.length; i13 < len12; i13++) {
-          let a = ref23[i13], i = findChildIndex(a.parent, a);
+        for (let ref25 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i13 = 0, len12 = ref25.length; i13 < len12; i13++) {
+          let a = ref25[i13], i = findChildIndex(a.parent, a);
           a.parent.children.splice(i + 1, 0, {
             type: "Error",
             message: `await invalid in ${signature.modifier.get ? "getter" : signature.modifier.set ? "setter" : signature.name}`
@@ -3190,15 +3220,15 @@ ${js}`
       if (f.generator != null)
         addGenerator = !0;
       else
-        for (let ref24 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i14 = 0, len13 = ref24.length; i14 < len13; i14++) {
-          let y = ref24[i14], i = y.children.findIndex(($19) => $19.type === "Yield");
+        for (let ref26 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i14 = 0, len13 = ref26.length; i14 < len13; i14++) {
+          let y = ref26[i14], 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}`
           });
         }
-    for (let ref25 = [f, ...precedingOverloads(f)], i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
-      let overload = ref25[i15];
+    for (let ref27 = [f, ...precedingOverloads(f)], i15 = 0, len14 = ref27.length; i15 < len14; i15++) {
+      let overload = ref27[i15];
       addAsync && overload.async != null && !overload.async.length && (overload.async.push("async "), overload.signature.modifier.async = !0), addGenerator && overload.generator != null && !overload.generator.length && (overload.generator.push("*"), overload.signature.modifier.generator = !0), overload.signature.modifier.async && !overload.signature.modifier.generator && overload.signature.returnType && !isPromiseType(overload.signature.returnType.t) && replaceNode(
         overload.signature.returnType.t,
         wrapTypeInPromise(overload.signature.returnType.t),
@@ -3207,8 +3237,8 @@ ${js}`
     }
   }
   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++) {
-      let 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++) {
+      let f = ref28[i16];
       (f.type === "FunctionExpression" || f.type === "MethodDefinition") && implicitFunctionBlock(f), processSignature(f), processParams(f), processReturn(f, config2.implicitReturns);
     }
   }
@@ -3255,17 +3285,17 @@ ${js}`
     }
     let done;
     if (!async) {
-      let ref27;
-      if ((ref27 = blockContainingStatement(exp)) && typeof ref27 == "object" && "block" in ref27 && "index" in ref27) {
-        let { block: parentBlock, index } = ref27;
+      let ref29;
+      if ((ref29 = blockContainingStatement(exp)) && typeof ref29 == "object" && "block" in ref29 && "index" in ref29) {
+        let { block: parentBlock, index } = ref29;
         statements[0][0] = parentBlock.expressions[index][0], parentBlock.expressions.splice(index, index + 1 - index, ...statements), updateParentPointers(parentBlock), braceBlock(parentBlock), done = !0;
       }
     }
     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 ref28 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i17 = 0, len16 = ref28.length; i17 < len16; i17++) {
-      let s = ref28[i17];
+    for (let ref30 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i17 = 0, len16 = ref30.length; i17 < len16; i17++) {
+      let s = ref30[i17];
       expressionizeIteration(s);
     }
   }
@@ -3284,9 +3314,9 @@ ${js}`
       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) {
-            let initializer = ref29;
+          let ref31;
+          if (ref31 = parameter.initializer) {
+            let initializer = ref31;
             args.push(initializer.expression, parameter.delim), parameter = {
               ...parameter,
               initializer: void 0,
@@ -3396,12 +3426,14 @@ ${js}`
   function bracedBlock(block) {
     return block = duplicateBlock(block), braceBlock(block), block;
   }
-  function makeEmptyBlock() {
-    let expressions = [];
-    return {
+  function makeEmptyBlock(loc) {
+    let expressions = [], ref1;
+    loc ? ref1 = { $loc: loc, token: "{" } : ref1 = "{";
+    let open = ref1, ref2;
+    return loc ? ref2 = { $loc: { pos: loc.pos + loc.length, length: 0 }, token: "}" } : ref2 = "}", {
       type: "BlockStatement",
       expressions,
-      children: ["{", expressions, "}"],
+      children: [open, expressions, ref2],
       bare: !1,
       empty: !0
     };
@@ -3450,8 +3482,8 @@ ${js}`
   }
   function processBlocks(statements) {
     insertSemicolon(statements);
-    for (let ref1 = gatherRecursive(statements, ($) => $.type === "BlockStatement"), i2 = 0, len12 = ref1.length; i2 < len12; i2++) {
-      let block = ref1[i2], m1;
+    for (let ref3 = gatherRecursive(statements, ($) => $.type === "BlockStatement"), i2 = 0, len12 = ref3.length; i2 < len12; i2++) {
+      let block = ref3[i2], 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 === !0 && "expression" in m1 && typeof m1.expression == "object" && m1.expression != null && "type" in m1.expression && m1.expression.type === "ObjectExpression")) {
         let object = block.expressions[0][1].expression;
         if (!(() => {
@@ -3465,8 +3497,8 @@ ${js}`
         })())
           continue;
         block.expressions[0][1] = block.expressions[0][1].expression, unbraceBlock(block);
-        for (let ref2 = object.properties, i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
-          let i = i3, prop = ref2[i3], m2;
+        for (let ref4 = object.properties, i3 = 0, len22 = ref4.length; i3 < len22; i3++) {
+          let i = i3, prop = ref4[i3], m2;
           m2 = prop.name, typeof m2 == "object" && m2 != null && "type" in m2 && m2.type === "ComputedPropertyName" && "implicit" in m2 && m2.implicit === !0 && replaceNode(prop.name, prop.name.expression, prop), prop.delim?.implicit && (needsPrecedingSemicolon(object.properties[i + 1]) ? prop.delim.token = ";" : (replaceNode(prop.delim, void 0, prop), prop.delim = void 0));
           let colon = prop.children.indexOf(": ");
           colon < 0 || prop.children[colon - 1] === prop.name && prop.children.splice(colon - 1, 2);
@@ -3936,7 +3968,9 @@ ${js}`
         break;
       }
     }
-    let [splices, thisAssignments] = gatherBindingCode(pattern), patternBindings2 = nonMatcherBindings(pattern), subbindings = gatherSubbindings(patternBindings2);
+    let [splices, thisAssignments] = gatherBindingCode(pattern), patternBindings2 = nonMatcherBindings(pattern);
+    "typeSuffix" in patternBindings2 && (typeSuffix = patternBindings2.typeSuffix);
+    let 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) {
@@ -4048,25 +4082,31 @@ ${js}`
     switch (pattern.type) {
       case "ArrayBindingPattern":
       case "PostRestBindingElements": {
-        let elements = elideMatchersFromArrayBindings(pattern.elements);
-        return makeNode({
+        let elements = elideMatchersFromArrayBindings(pattern.elements), node = makeNode({
           ...pattern,
           elements,
           children: pattern.children.map(($9) => $9 === pattern.elements ? elements : $9)
-        });
+        }), typePattern = {
+          ...node,
+          typeSuffix: void 0,
+          elements: elements.filter((element) => element?.type != null)
+        };
+        return node.typeSuffix = gatherBindingPatternTypeSuffix(typePattern).typeSuffix, node;
       }
       case "ObjectBindingPattern": {
         let 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": {
         let 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)
         });
       }
@@ -6690,8 +6730,10 @@ ${js}`
           break;
         }
         case "PipelineExpression": {
-          let i = findChildIndex(parent, ancestor), ref33;
-          i === 1 ? ref33 = ancestor === parent.children[i] : i === 2 ? ref33 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3] : ref33 = void 0, outer = ref33;
+          {
+            let i = findChildIndex(parent, ancestor), ref33;
+            i === 1 ? ref33 = ancestor === parent.children[i] : i === 2 ? ref33 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3] : ref33 = void 0, outer = ref33;
+          }
           break;
         }
         case "AssignmentExpression":
@@ -6950,7 +6992,9 @@ ${js}`
     AfterReturnShorthand,
     Parameters,
     ShortArrowParameters,
+    ESArrowIdentifierParameters,
     ArrowParameters,
+    ThinArrowParameters,
     NonEmptyParameters,
     ParameterList,
     NestedParameterList,
@@ -7634,6 +7678,7 @@ ${js}`
     CoffeeNotEnabled,
     CoffeeOfEnabled,
     CoffeePrototypeEnabled,
+    ESArrowFunctionEnabled,
     JSXCodeNestedEnabled,
     JSXCodeSameLineEnabled,
     ObjectIsEnabled,
@@ -8365,9 +8410,12 @@ ${js}`
   function ConditionalExpression(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "ConditionalExpression", ConditionalExpression$0);
   }
-  var TernaryRest$0 = NestedTernaryRest, 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$0 = NestedTernaryRest, 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;
+    return thenelse ? [$3, $4, ...thenelse] : $skip;
+  }), 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);
-  }), TernaryRest$$ = [TernaryRest$0, TernaryRest$1];
+  }), TernaryRest$$ = [TernaryRest$0, TernaryRest$1, TernaryRest$2];
   function TernaryRest(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "TernaryRest", TernaryRest$$);
   }
@@ -8381,24 +8429,29 @@ ${js}`
   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 ws = $2, head = $3, body = $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, head = $3, body = $4, trailing = $5;
+    let node;
     if (head.type === "ArrowFunction" && head.ampersandBlock) {
       let expressions = [{
         type: "PipelineExpression",
         children: [ws, head.block.expressions[0], body]
       }], block = { ...head.block, expressions, children: [expressions] };
-      return {
+      node = {
         ...head,
         block,
         body: expressions,
         children: [...head.children.slice(0, -1), block]
       };
-    }
-    return {
-      type: "PipelineExpression",
-      children: [ws, head, body]
-    };
+    } else
+      node = {
+        type: "PipelineExpression",
+        children: [ws, head, body]
+      };
+    return trailing ? processCallMemberExpression({
+      type: "CallExpression",
+      children: [node, ...trailing]
+    }) : node;
   });
   function PipelineExpression(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "PipelineExpression", PipelineExpression$0);
@@ -9346,28 +9399,49 @@ ${js}`
   }
   var ShortArrowParameters$0 = (0, import_lib2.$TV)((0, import_lib2.$C)(ObjectBindingPattern, ArrayBindingPattern), function($skip, $loc, $0, $1) {
     var binding = $0;
-    let { typeSuffix } = binding;
-    return {
+    let { typeSuffix } = binding, parameters = [{
       type: "Parameter",
       children: [binding, typeSuffix],
       names: binding.names,
       typeSuffix
+    }];
+    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) {
-    let parameters = [$1];
+  var ESArrowIdentifierParameters$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ESArrowFunctionEnabled, Identifier), function($skip, $loc, $0, $1, $2) {
+    var id = $2;
+    let parameters = [{
+      type: "Parameter",
+      children: [id],
+      names: id.names,
+      binding: id,
+      typeSuffix: void 0,
+      initializer: void 0,
+      delim: void 0
+    }];
     return {
       type: "Parameters",
       children: ["(", parameters, ")"],
       parameters
     };
-  }), ArrowParameters$1 = Parameters, ArrowParameters$$ = [ArrowParameters$0, ArrowParameters$1];
+  });
+  function ESArrowIdentifierParameters(ctx, state2) {
+    return (0, import_lib2.$EVENT)(ctx, state2, "ESArrowIdentifierParameters", ESArrowIdentifierParameters$0);
+  }
+  var ArrowParameters$0 = ESArrowIdentifierParameters, ArrowParameters$1 = ShortArrowParameters, ArrowParameters$2 = Parameters, 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, ThinArrowParameters$1 = Parameters, 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, open = $2, parameters = $3, close = $4;
     return {
@@ -9453,11 +9527,12 @@ ${js}`
     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 ref = $2;
+    var at = $1, ref = $2;
     return {
       type: "AtBinding",
       children: [ref],
       ref,
+      at,
       names: []
     };
   }), NWBindingIdentifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Hash, AtIdentifierRef), function($skip, $loc, $0, $1, $2) {
@@ -9489,35 +9564,40 @@ ${js}`
     return {
       type: "PinPattern",
       children: [expression],
-      expression
+      expression,
+      typeSuffix: typeSuffixForExpression(expression)
     };
   }), PinPattern$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Caret, SingleLineExpressionWithIndentedApplicationForbidden), function($skip, $loc, $0, $1, $2) {
     var expression = $2;
     return {
       type: "PinPattern",
       children: [expression],
-      expression
+      expression,
+      typeSuffix: typeSuffixForExpression(expression)
     };
   }), PinPattern$2 = (0, import_lib2.$TV)(ActualMemberExpression, function($skip, $loc, $0, $1) {
     var expression = $0;
     return {
       type: "PinPattern",
       children: [expression],
-      expression
+      expression,
+      typeSuffix: typeSuffixForExpression(expression)
     };
   }), PinPattern$3 = (0, import_lib2.$TV)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R15, "PinPattern /[+-]/"), NumericLiteral), function($skip, $loc, $0, $1) {
     var expression = $0;
     return {
       type: "PinPattern",
       children: [expression],
-      expression
+      expression,
+      typeSuffix: typeSuffixForExpression(expression)
     };
   }), PinPattern$4 = (0, import_lib2.$TV)(Undefined, function($skip, $loc, $0, $1) {
     var expression = $0;
     return {
       type: "PinPattern",
       children: [expression],
-      expression
+      expression,
+      typeSuffix: typeSuffixForExpression(expression)
     };
   }), PinPattern$$ = [PinPattern$0, PinPattern$1, PinPattern$2, PinPattern$3, PinPattern$4];
   function PinPattern(ctx, state2) {
@@ -9678,7 +9758,8 @@ ${js}`
       value: {
         type: "PinPattern",
         children: [binding],
-        expression: binding
+        expression: binding,
+        typeSuffix: typeSuffixForExpression(binding)
       }
     };
   }), BindingProperty$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), BindingIdentifier, (0, import_lib2.$E)(Caret), (0, import_lib2.$E)(BindingTypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
@@ -10026,7 +10107,7 @@ ${js}`
   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, parameters = $2, returnType = $3, ws = $4, arrow = $5, block = $6;
     async || (async = []);
     let generator = [];
@@ -11060,7 +11141,17 @@ ${js}`
       };
     else if ({ name } = last, !name)
       return $skip;
-    return name[0] === "#" && (name = name.slice(1)), {
+    if (name[0] === "#" && (name = name.slice(1)), !pre.length && post?.token === "?" && value.type === "Identifier") {
+      let dots = { $loc, token: "..." }, 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)],
       name,
@@ -11072,7 +11163,17 @@ ${js}`
   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, exp = $6;
+    let { ref, refAssignment } = maybeRefAssignment(exp), checkExp = refAssignment ? parenthesizeExpression(refAssignment) : exp, dots = { $loc, token: "..." }, paren = parenthesizeExpression({ children: [checkExp, " != null ? {", name, ": ", ref, "} : {}"] });
+    return {
+      type: "SpreadProperty",
+      children: [dots, paren],
+      names: exp.names || [],
+      dots,
+      value: paren
+    };
+  }), 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, exp = $4;
     return {
       type: "Property",
@@ -11081,9 +11182,9 @@ ${js}`
       names: exp.names || [],
       value: exp
     };
-  });
+  }), 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, colon = $2, expression = $3, post = $4;
@@ -16384,6 +16485,13 @@ ${js}`
   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 $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 $skip;
@@ -16440,6 +16548,7 @@ ${js}`
       globals: [],
       iife: !1,
       implicitReturns: !0,
+      esArrowFunction: !1,
       jsxCode: !1,
       objectIs: !1,
       react: !1,
@@ -16482,6 +16591,14 @@ ${js}`
           config[option] = b;
         b && (config.objectIs = !1);
       }
+    }), Object.defineProperty(config, "esCompat", {
+      set(b) {
+        for (let option of [
+          "esArrowFunction"
+        ])
+          config[option] = b;
+        config.implicitReturns = !b;
+      }
     }), Object.defineProperty(config, "jsxCode", {
       set(b) {
         for (let option of ["jsxCodeNested", "jsxCodeSameLine"])
@@ -16936,6 +17053,9 @@ ${upstreamMap.comment(targetPath)}`;
       return [lastMapping[2], lastMapping[3] + character - lastMappingPosition];
   };
 
+  // source/main.civet
+  init_browser_shim();
+
   // source/state-cache.civet
   var StateCache = class {
     cache = /* @__PURE__ */ new Map();
@@ -17082,9 +17202,11 @@ ${counts}`;
         options.sourceMap = new SourceMap(src, filename2);
         let code = generate_default(ast2, options);
         if (checkErrors(), options.upstreamSourceMap != null && options.sourceMap.composeUpstream(options.upstreamSourceMap), options.inlineMap) {
-          let outputFilename = options.outputFilename ?? (options.js ? filename2 + ".jsx" : filename2 + ".tsx");
+          let outputFilename = options.outputFilename ?? (options.js ? filename2 + ".jsx" : filename2 + ".tsx"), outDir = dirname(outputFilename);
+          options.sourceMap.sourceFileName = relative(outDir, options.sourceMap.sourceFileName) || options.sourceMap.sourceFileName;
+          let relativeOut = relative(outDir, outputFilename) || outputFilename;
           return `${code}
-${options.sourceMap.comment(outputFilename)}`;
+${options.sourceMap.comment(relativeOut)}`;
         } else
           return { code, sourceMap: options.sourceMap };
       }